static unsigned char * hash( SRP_HashAlgorithm alg, const unsigned char *d, size_t n, unsigned char *md ) { switch (alg) { case SRP_SHA1 : return SHA1( d, n, md ); case SRP_SHA224: return SHA224( d, n, md ); case SRP_SHA256: return SHA256( d, n, md ); case SRP_SHA384: return SHA384( d, n, md ); case SRP_SHA512: return SHA512( d, n, md ); default: return 0; } }
ikptr ikrt_openssl_sha224 (ikptr s_input, ikptr s_input_len, ikpcb * pcb) { #ifdef HAVE_SHA224 ik_ssl_cuchar * in = (ik_ssl_cuchar *)IK_GENERALISED_C_STRING(s_input); ik_ulong in_len = (ik_ulong)ik_generalised_c_buffer_len(s_input, s_input_len); unsigned char sum[SHA224_DIGEST_LENGTH]; SHA224(in, in_len, sum); return ika_bytevector_from_memory_block(pcb, sum, SHA224_DIGEST_LENGTH); #else feature_failure(__func__); #endif }
static inline std::string digest(Name name, const char *buf, size_t bufSize) { unsigned char md[128]; const unsigned char *src = cybozu::cast<const unsigned char *>(buf); switch (name) { case N_SHA1: SHA1(src, bufSize, md); break; case N_SHA224: SHA224(src, bufSize, md); break; case N_SHA256: SHA256(src, bufSize, md); break; case N_SHA384: SHA384(src, bufSize, md); break; case N_SHA512: SHA512(src, bufSize, md); break; default: throw cybozu::Exception("crypt:Hash:digest") << name; } return std::string(cybozu::cast<const char*>(md), getSize(name)); }
bool OpensslManager::HashString(Openssl_Hash algorithm, unsigned char *input, int size, unsigned char *output, int *outlength) { switch(algorithm) { case Openssl_Hash_MD5: MD5(input, size, output); *outlength = MD5_DIGEST_LENGTH; return true; case Openssl_Hash_MD4: MD4(input, size, output); *outlength = MD4_DIGEST_LENGTH; return true; case Openssl_Hash_MD2: MD2(input, size, output); *outlength = MD2_DIGEST_LENGTH; return true; case Openssl_Hash_SHA: SHA(input, size, output); *outlength = SHA_DIGEST_LENGTH; return true; case Openssl_Hash_SHA1: SHA1(input, size, output); *outlength = SHA_DIGEST_LENGTH; return true; case Openssl_Hash_SHA224: SHA224(input, size, output); *outlength = SHA224_DIGEST_LENGTH; return true; case Openssl_Hash_SHA256: SHA256(input, size, output); *outlength = SHA256_DIGEST_LENGTH; return true; case Openssl_Hash_SHA384: SHA384(input, size, output); *outlength = SHA384_DIGEST_LENGTH; return true; case Openssl_Hash_SHA512: SHA512(input, size, output); *outlength = SHA512_DIGEST_LENGTH; return true; case Openssl_Hash_RIPEMD160: RIPEMD160(input, size, output); *outlength = RIPEMD160_DIGEST_LENGTH; return true; } return false; }
static ErlDrvSSizeT sha_drv_control(ErlDrvData handle, unsigned int command, char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen) { ErlDrvBinary *b = NULL; switch (command) { #ifdef HAVE_MD2 case 2: rlen = MD2_DIGEST_LENGTH; b = driver_alloc_binary(rlen); if (b) MD2((unsigned char*)buf, len, (unsigned char*)b->orig_bytes); break; #endif case 224: rlen = SHA224_DIGEST_LENGTH; b = driver_alloc_binary(rlen); if (b) SHA224((unsigned char*)buf, len, (unsigned char*)b->orig_bytes); break; case 256: rlen = SHA256_DIGEST_LENGTH; b = driver_alloc_binary(rlen); if (b) SHA256((unsigned char*)buf, len, (unsigned char*)b->orig_bytes); break; case 384: rlen = SHA384_DIGEST_LENGTH; b = driver_alloc_binary(rlen); if (b) SHA384((unsigned char*)buf, len, (unsigned char*)b->orig_bytes); break; case 512: rlen = SHA512_DIGEST_LENGTH; b = driver_alloc_binary(rlen); if (b) SHA512((unsigned char*)buf, len, (unsigned char*)b->orig_bytes); break; }; if (b) { *rbuf = (char *)b; } else { *rbuf = NULL; rlen = 0; }; return rlen; }
int PICA_id_from_X509(X509 *x, unsigned char *id) { unsigned char *der = NULL; int len; len = i2d_X509(x, &der); if (len <= 0) { return 0; } SHA224(der, len, id); OPENSSL_free(der); return 1; }
/* SHA-2: 224 Bits output */ OpcUa_StatusCode OpcUa_P_OpenSSL_SHA2_224_Generate( OpcUa_CryptoProvider* a_pProvider, OpcUa_Byte* a_pData, OpcUa_UInt32 a_dataLen, OpcUa_Byte* a_pMessageDigest) { OpcUa_InitializeStatus(OpcUa_Module_P_OpenSSL, "SHA2_224_Generate"); OpcUa_ReferenceParameter(a_pProvider); OpcUa_ReturnErrorIfArgumentNull(a_pData); OpcUa_ReturnErrorIfArgumentNull(a_pMessageDigest); if(SHA224(a_pData, a_dataLen, a_pMessageDigest) == OpcUa_Null) { OpcUa_GotoErrorWithStatus(OpcUa_Bad); } OpcUa_ReturnStatusCode; OpcUa_BeginErrorHandling; OpcUa_FinishErrorHandling; }
/*** impl Sha ***/ bool Sha::Sum(const int64_t type, const void* bytes, const int64_t len, char* pbuffer){ if(!(type>=TYPE_MIN && type<=TYPE_MAX) || !bytes || len<=0 || !pbuffer){ return false; } bool ok =false; unsigned char digest[SHA512_DIGEST_LENGTH] ={0}; int digest_len =0; if(type == TYPE_SHA1){ digest_len =SHA_DIGEST_LENGTH; ok =SHA1(reinterpret_cast< const unsigned char* >(bytes), len, digest); } else if(type == TYPE_SHA224){ digest_len =SHA224_DIGEST_LENGTH; ok =SHA224(reinterpret_cast< const unsigned char* >(bytes), len, digest); } else if(type == TYPE_SHA256){ digest_len =SHA256_DIGEST_LENGTH; ok =SHA256(reinterpret_cast< const unsigned char* >(bytes), len, digest); } else if(type == TYPE_SHA384){ digest_len =SHA384_DIGEST_LENGTH; ok =SHA384(reinterpret_cast< const unsigned char* >(bytes), len, digest); } else if(type == TYPE_SHA512){ digest_len =SHA512_DIGEST_LENGTH; ok =SHA512(reinterpret_cast< const unsigned char* >(bytes), len, digest); } if(ok){ for(int i=0; i<digest_len; ++i){ sprintf(pbuffer+i*2, "%02x", digest[i]); } return true; } else{ return false; } }