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;
}
}
