ikptr
ikrt_openssl_mdc2 (ikptr s_input, ikptr s_input_len, ikpcb * pcb)
{
#ifdef HAVE_MDC2
  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[MDC2_DIGEST_LENGTH];
  MDC2(in, in_len, sum);
  return ika_bytevector_from_memory_block(pcb, sum, MDC2_DIGEST_LENGTH);
#else
  feature_failure(__func__);
#endif
}
示例#2
0
void f_hash(void)
{
    const char *algo;
        const char *data;
        char *res;
        
        algo = (sp - 1)->u.string;
        data = sp->u.string;
        
        /* MD2 Digest */
        if (strcasecmp(algo, (const char *)"md2") == 0)
        {
            unsigned char md[MD2_DIGEST_LENGTH];
                MD2((unsigned char *)data, strlen(data), md);
                res = hexdump(md, MD2_DIGEST_LENGTH);
        }
    
        /* MD4 Digest */
        else if (strcasecmp(algo, (const char *)"md4") == 0)
        {
            unsigned char md[MD4_DIGEST_LENGTH];
                MD4((unsigned char *)data, strlen(data), md);      
                res = hexdump(md, MD4_DIGEST_LENGTH);      
        }
    
        /* MD5 Digest */
        else if (strcasecmp(algo, (const char *)"md5") == 0)
        {
            unsigned char md[MD5_DIGEST_LENGTH];
                MD5((unsigned char *)data, strlen(data), md);      
                res = hexdump(md, MD5_DIGEST_LENGTH);      
        }
    
        /* MDC2 Digest */
        else if (strcasecmp(algo, (const char *)"mdc2") == 0)
        {
            unsigned char md[MDC2_DIGEST_LENGTH];
                MDC2((unsigned char *)data, strlen(data), md);      
                res = hexdump(md, MDC2_DIGEST_LENGTH);      
        }
    
        /* RIPEMD160 Digest */
        else if (strcasecmp(algo, (const char *)"ripemd160") == 0)
        {
            unsigned char md[RIPEMD160_DIGEST_LENGTH];
                RIPEMD160((unsigned char *)data, strlen(data), md);      
                res = hexdump(md, RIPEMD160_DIGEST_LENGTH);      
        }
    
        /* SHA1 Digest */
        else if (strcasecmp(algo, (const char *)"sha1") == 0)
        {
            unsigned char md[SHA_DIGEST_LENGTH];
                SHA1((unsigned char *)data, strlen(data), md);
                res = hexdump(md, SHA_DIGEST_LENGTH);
        }
    
        else
        {
            pop_stack();
                res = malloc(29 + strlen(algo));
                sprintf(res, "hash() unknown hash type: %s.\n", algo);
                error(res);
        }
    
        /* Pop the arguments off the stack and push the result */
        free_string_svalue(sp--);
        free_string_svalue(sp);
        
        sp->subtype = STRING_MALLOC;
        sp->u.string = res;
}