Example #1
0
char * md5_identity(void *data, int len)
{
    unsigned char hash[16];
    char* result;
    int ptr,i;

    result = (char*)malloc(sizeof(char)*512);
    memset(result, 0, sizeof(result));
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx,(char*)data,len);
    MD5_Final(hash,&ctx);

    ptr = 0;
    for(i=0;i<16;i++)
    {
        ptr += sprintf(result+ptr, "%02x", hash[i]);
    }
    return result;
}
Example #2
0
ClientWardenModule* WardenWin::GetModuleForClient()
{
    ClientWardenModule *mod = new ClientWardenModule;

    uint32 length = sizeof(Module.Module);

    // data assign
    mod->CompressedSize = length;
    mod->CompressedData = new uint8[length];
    memcpy(mod->CompressedData, Module.Module, length);
    memcpy(mod->Key, Module.ModuleKey, 16);

    // md5 hash
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx, mod->CompressedData, length);
    MD5_Final((uint8*)&mod->Id, &ctx);

    return mod;
}
ClientWardenModule *WardenMac::GetModuleForClient(WorldSession *session)
{
    ClientWardenModule *mod = new ClientWardenModule;

    uint32 len = sizeof(Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data);

    // data assign
    mod->CompressedSize = len;
    mod->CompressedData = new uint8[len];
    memcpy(mod->CompressedData, Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data, len);
    memcpy(mod->Key, Module_0DBBF209A27B1E279A9FEC5C168A15F7_Key, 16);
        
    // md5 hash
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx, mod->CompressedData, len);
    MD5_Final((uint8*)&mod->ID, &ctx);

    return mod;
}
Example #4
0
string md5sum(const char * str, int len)
{
	int n;
    MD5_CTX ctx;
    char buf[SLICECAP];
    unsigned char out[MD5_DIGEST_LENGTH];
    string md5str;

	MD5_Init(&ctx);
	MD5_Update(&ctx, str, len);
    MD5_Final(out, &ctx);

    for(n = 0; n< MD5_DIGEST_LENGTH; n++)
	{
		snprintf(buf, SLICECAP, "%02x", out[n]);
		md5str += buf;
	}

    return md5str;     
}
// computes an RSA-MD5 signature over 'buf' using 'priv_key'
// signature data is returned is 'sig_buf' which should be at least
// SIGNATURE_LEN bytes in size.  
// Method returns 0 on success.   
int get_signature(char *buf, unsigned int buf_size, RSA *priv_key,
                   unsigned char *sig_buf, unsigned int *sig_len) {

  unsigned char digest[16];
  unsigned int digest_len = 16;
  MD5_CTX md5;
  MD5_Init(&md5);
  MD5_Update(&md5, (unsigned char*)buf, buf_size);
  MD5_Final(digest, &md5);

  int ret_val = RSA_sign(NID_md5, digest, digest_len, 
			sig_buf, sig_len, priv_key);
  if(!ret_val) {
      unsigned long e = ERR_get_error();
      DPRINTF(DEBUG_ERROR,"RSA_sign error: %s", ERR_error_string(e, buf));
      return 1;
  }
 
  return 0;
}
Example #6
0
/*
 * Selects the cipher, and keys if by computing the MD5 checksum of the
 * passphrase and using the resulting 16 bytes as the key.
 */
int
cipher_set_key_string(struct sshcipher_ctx *cc, struct sshcipher *cipher,
    const char *pphrase, int do_encrypt)
{
	MD5_CTX md;
	u_char digest[16];
	int ret = SSH_ERR_LIBCRYPTO_ERROR;

	if (MD5_Init(&md) != 1 ||
	    MD5_Update(&md, (const u_char *)pphrase, strlen(pphrase)) != 1 ||
	    MD5_Final(digest, &md) != 1)
		goto out;

	ret = cipher_init(cc, cipher, digest, 16, NULL, 0, do_encrypt);

 out:
	memset(digest, 0, sizeof(digest));
	memset(&md, 0, sizeof(md));
	return ret;
}
Example #7
0
//Return value is on the heap.
char* md5(const char *filename) {

	//Open the input file.
	FILE *in_file = fopen(filename, "rb");

	if (!in_file) {
		printf ("%s can't be opened.\n", filename);
		return NULL;
	}

	//Initialise the md5 function.
	MD5_CTX md_context;
	MD5_Init (&md_context);
	
	//Read in the data from the file and feed it to the md5 function.
	int bytes;
	unsigned char data[1024];

	while ((bytes = fread(data, 1, 1024, in_file)) != 0) {
		MD5_Update(&md_context, data, bytes);
	}

	//Recieve the final md5 value inside c.
	unsigned char c[MD5_DIGEST_LENGTH];
	MD5_Final(c,&md_context);

	//Allocate memory for the return value.
	char tmp[2];
	char *hash = malloc((MD5_DIGEST_LENGTH * 2) + 1);

	//Format the md5 digits as chars.
	for (int i = 0; i < MD5_DIGEST_LENGTH; i++) {
		sprintf(tmp, "%02x", c[i]);
		memcpy(hash+(i*2), tmp, 2);
	}

	hash[MD5_DIGEST_LENGTH*2] = '\0';
	fclose (in_file);

	return hash;
}
int ssl3_PRF( const u_char* secret, uint32_t secret_len, 
		const u_char* random1, uint32_t random1_len,
		const u_char* random2, uint32_t random2_len,
		u_char* out, uint32_t out_len )
{
	MD5_CTX md5;
	SHA_CTX sha;
	u_char buf[20];
	uint32_t off;
	u_char i;

	if( !out ) return NM_ERROR( DSSL_E_INVALID_PARAMETER );

	for( off=0, i = 1; off < out_len; off+=16, ++i )
	{
		u_char md5_buf[16];
		uint32_t cnt;
		uint32_t j;

		MD5_Init(&md5);
		SHA1_Init(&sha);

		/* salt: A, BB, CCC,  ... */
		for( j=0; j < i; j++ ) buf[j]='A' + (i-1);

		SHA1_Update( &sha, buf, i );
		if( secret ) SHA1_Update( &sha, secret, secret_len );
		SHA1_Update( &sha, random1, random1_len );
		SHA1_Update( &sha, random2, random2_len );
		SHA1_Final( buf, &sha );

		MD5_Update( &md5, secret, secret_len );
		MD5_Update( &md5, buf, 20 );
		MD5_Final( md5_buf, &md5 );

		cnt = out_len - off < 16 ? out_len - off : 16;
		memcpy( out + off, md5_buf, cnt );
	}

	return DSSL_RC_OK;
}
Example #9
0
/*
 * Computes the proper response to a RSA challenge, and sends the response to
 * the server.
 */
static void
respond_to_rsa_challenge(struct ssh *ssh, BIGNUM * challenge, RSA * prv)
{
    u_char buf[32], response[16];
    MD5_CTX md;
    int r, len;

    /* Decrypt the challenge using the private key. */
    /* XXX think about Bleichenbacher, too */
    if ((r = rsa_private_decrypt(challenge, challenge, prv)) != 0) {
        ssh_packet_disconnect(ssh,  "%s: rsa_private_decrypt: %s",
                              __func__, ssh_err(r));
    }

    /* Compute the response. */
    /* The response is MD5 of decrypted challenge plus session id. */
    len = BN_num_bytes(challenge);
    if (len <= 0 || (u_int)len > sizeof(buf))
        ssh_packet_disconnect(ssh,
                              "respond_to_rsa_challenge: bad challenge length %d", len);

    memset(buf, 0, sizeof(buf));
    BN_bn2bin(challenge, buf + sizeof(buf) - len);
    MD5_Init(&md);
    MD5_Update(&md, buf, 32);
    MD5_Update(&md, session_id, 16);
    MD5_Final(response, &md);

    debug("Sending response to host key RSA challenge.");

    /* Send the response back to the server. */
    if ((r = sshpkt_start(ssh, SSH_CMSG_AUTH_RSA_RESPONSE)) != 0 ||
            (r = sshpkt_put(ssh, &response, sizeof(response))) != 0 ||
            (r = sshpkt_send(ssh)) != 0)
        fatal("%s: %s", __func__, ssh_err(r));
    ssh_packet_write_wait(ssh);

    memset(buf, 0, sizeof(buf));
    memset(response, 0, sizeof(response));
    memset(&md, 0, sizeof(md));
}
Example #10
0
void md5(FILE * f)
{
 MD5_CTX ctx;
 unsigned char tab[MD5_DIGEST_LENGTH];
 MD5_Init(&ctx);
 unsigned char bufor[size];
 int read;
 
 while (!feof(f))
       {
        read = fread(bufor, 1, size, f);
        MD5_Update(&ctx, bufor, read);
       }
 
 MD5_Final(tab, &ctx);
 
 int i;
 for (i = 0; i < MD5_DIGEST_LENGTH; i++)
     printf("%02x", tab[i]);
 printf("\n");   
}
bool	Checksum::get_final(struct_file* file) {
	if ( file == NULL )
		return false;

	if ( SHA1_Final(sha1, &sha1_ctx) == 0 || MD5_Final(md5, &md5_ctx) == 0 ) {
		// error !
		return false;
	}

	file->sha1.clear();
	for ( int i = 0 ; i < SHA_DIGEST_LENGTH ; ++i ) {
		file->sha1.append(QString::number(sha1[i], 16));
	}

	// FIXME: the MD5 sum is wrong:w
	file->md5.clear();
	for ( int i = 0 ; i < MD5_DIGEST_LENGTH ; ++i ) {
		file->md5.append(QString::number(md5[i], 16));
	}
	return true;
}
Example #12
0
// Function which calculates MD5 for comparison with Response Authenticator
void GetSubscriberMD5(BYTE subResponseAuth[MD5_DIGEST_LENGTH], RADIUS_PACKET *aaaData, SUBSCRIBER *sub) {

	int i, j;
	BYTE hash[MAX_ARGUMENT_LENGTH];
	MD5_CTX context;

	// Init MD5
	MD5_Init(&context);
	// Create string to be hashed and execute MD5 hashing
	bzero(hash, MAX_ARGUMENT_LENGTH);
	hash[0] = aaaData->code;
	hash[1] = aaaData->identifier;
	memcpy(hash + 2, (unsigned char *)&aaaData->length, 2);
	memcpy(hash + 4, sub->aaaAuthenticator, 16);
	memcpy(hash + 20, aaaData->options, htons(aaaData->length) - RADIUS_HEADER_LENGTH);
	memcpy(hash + ntohs(aaaData->length), Radius_secret, strlen(Radius_secret));
	MD5_Update (&context, hash, ntohs(aaaData->length) + strlen(Radius_secret));
	MD5_Final (subResponseAuth, &context);

	return;
}
Example #13
0
// Password is did_u_really_reverse_me
int verify_password(char *pass) {
	MD5_CTX c;
	unsigned char digest[16] = {
		0x87, 0xe0, 0xbe, 0x2f, 0x4f, 0x39, 0x86, 0x29, 
		0x5d, 0x86, 0xe3, 0x27, 0xaf, 0x53, 0xee, 0xd2
	};
	unsigned char pass_digest[16];
	int i;

	MD5_Init(&c);
	MD5_Update(&c, pass, strlen(pass));
	MD5_Final(pass_digest, &c);

	for (i = 0; i < 16; i++) {
		if (digest[i] != pass_digest[i]) {
			return -1;
		}
	}

	return 0;
}
Example #14
0
unsigned char * Condor_MD_MAC::computeOnce(unsigned char * buffer, 
                                           unsigned long   length, 
                                           KeyInfo       * key)
{
#ifdef HAVE_EXT_OPENSSL
    unsigned char * md = (unsigned char *) malloc(MAC_SIZE);
    MD5_CTX  context;

    MD5_Init(&context);

    MD5_Update(&context, key->getKeyData(), key->getKeyLength());

    MD5_Update(&context, buffer, length);

    MD5_Final(md, &context);

    return md;
#else
    return NULL;
#endif
}
Example #15
0
void generate_data( dcp_info_t * info ) { 
    // init static random generator
    srand(STATIC_SEED);

    MD5_CTX ctx;
    int idx;
    for( idx=0; idx<info->nbuffer; ++idx) {
        MD5_Init(&ctx);
        uintptr_t ptr = (uintptr_t) info->buffer[idx];
        uintptr_t ptr_e = (uintptr_t)info->buffer[idx] + (uintptr_t)info->size[idx];
        while ( ptr < ptr_e ) {
            unsigned int rui = (unsigned int) rand();
            int init_size = ( (ptr_e - ptr) > UI_UNIT ) ? UI_UNIT : ptr_e-ptr;
            memcpy((void*)ptr, &rui, init_size);
            MD5_Update( &ctx, (void*)ptr, init_size); 
            ptr += init_size;
        }
        assert( ptr == ptr_e );
        MD5_Final(info->hash[idx], &ctx);
    }
}
Example #16
0
void
compute_session_id(u_char session_id[16],
    u_char cookie[8],
    BIGNUM* host_key_n,
    BIGNUM* session_key_n)
{
	u_int host_key_bytes = BN_num_bytes(host_key_n);
	u_int session_key_bytes = BN_num_bytes(session_key_n);
	u_int bytes = host_key_bytes + session_key_bytes;
	u_char *buf = xmalloc(bytes);
	MD5_CTX md;

	BN_bn2bin(host_key_n, buf);
	BN_bn2bin(session_key_n, buf + host_key_bytes);
	MD5_Init(&md);
	MD5_Update(&md, buf, bytes);
	MD5_Update(&md, cookie, 8);
	MD5_Final(session_id, &md);
	memset(buf, 0, bytes);
	xfree(buf);
}
Example #17
0
static int crypt_all(int *pcount, struct db_salt *salt)
{
	int count = *pcount;
	int index = 0;

#ifdef _OPENMP
#pragma omp parallel for
#endif
#if defined(_OPENMP) || MAX_KEYS_PER_CRYPT > 1
	for (index = 0; index < count; index++)
#endif
	{
		unsigned char hash[16];
		MD5_CTX ctx;
		MD5_Init(&ctx);
		MD5_Update(&ctx, saved_key[index], strlen(saved_key[index]));
		MD5_Final(hash, &ctx);
		hex_encode(hash, 16, (unsigned char*)crypt_out[index]);
	}
	return count;
}
Example #18
0
int stun_produce_integrity_key_str(u08bits *uname, u08bits *realm, u08bits *upwd, u08bits *key)
{
	MD5_CTX ctx;
	size_t ulen = strlen((s08bits*)uname);
	size_t rlen = strlen((s08bits*)realm);
	size_t plen = strlen((s08bits*)upwd);
	u08bits *str = (u08bits*)malloc(ulen+1+rlen+1+plen+1);

	strcpy((s08bits*)str,(s08bits*)uname);
	str[ulen]=':';
	strcpy((s08bits*)str+ulen+1,(s08bits*)realm);
	str[ulen+1+rlen]=':';
	strcpy((s08bits*)str+ulen+1+rlen+1,(s08bits*)upwd);

	MD5_Init(&ctx);
	MD5_Update(&ctx,str,ulen+1+rlen+1+plen);
	MD5_Final(key,&ctx);
	free(str);

	return 0;
}
Example #19
0
int gen_md5(headers_t *headers, char *target) {
    unsigned long key1 = parse_hixie76_key(headers->key1);
    unsigned long key2 = parse_hixie76_key(headers->key2);
    char *key3 = headers->key3;

    MD5_CTX c;
    char in[HIXIE_MD5_DIGEST_LENGTH] = {
        key1 >> 24, key1 >> 16, key1 >> 8, key1,
        key2 >> 24, key2 >> 16, key2 >> 8, key2,
        key3[0], key3[1], key3[2], key3[3],
        key3[4], key3[5], key3[6], key3[7]
    };

    MD5_Init(&c);
    MD5_Update(&c, (void *)in, sizeof in);
    MD5_Final((void *)target, &c);

    target[HIXIE_MD5_DIGEST_LENGTH] = '\0';

    return 1;
}
Example #20
0
/*
 * Computes the proper response to a RSA challenge, and sends the response to
 * the server.
 */
static void
respond_to_rsa_challenge(BIGNUM * challenge, RSA * prv)
{
	u_char buf[32], response[16];
	MD5_CTX md;
	int i, len;

	/* Decrypt the challenge using the private key. */
	/* XXX think about Bleichenbacher, too */
	if (rsa_private_decrypt(challenge, challenge, prv) <= 0)
		packet_disconnect(
		    "respond_to_rsa_challenge: rsa_private_decrypt failed");

	/* Compute the response. */
	/* The response is MD5 of decrypted challenge plus session id. */
	len = BN_num_bytes(challenge);
	if (len <= 0 || len > sizeof(buf))
		packet_disconnect(
		    "respond_to_rsa_challenge: bad challenge length %d", len);

	memset(buf, 0, sizeof(buf));
	BN_bn2bin(challenge, buf + sizeof(buf) - len);
	MD5_Init(&md);
	MD5_Update(&md, buf, 32);
	MD5_Update(&md, session_id, 16);
	MD5_Final(response, &md);

	debug("Sending response to host key RSA challenge.");

	/* Send the response back to the server. */
	packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);
	for (i = 0; i < 16; i++)
		packet_put_char(response[i]);
	packet_send();
	packet_write_wait();

	memset(buf, 0, sizeof(buf));
	memset(response, 0, sizeof(response));
	memset(&md, 0, sizeof(md));
}
Example #21
0
File: bedup.c Project: kaptk2/burp
static int get_full_cksum(struct file *f, FILE **fp)
{
	size_t s=0;
	MD5_CTX md5;
	static char buf[FULL_CHUNK];
	unsigned char checksum[MD5_DIGEST_LENGTH+1];

	if(*fp) fseek(*fp, 0, SEEK_SET);
	else if(!(*fp=open_file(f)))
	{
		f->full_cksum=0;
		return 0;
	}

	if(!MD5_Init(&md5))
	{
		logp("MD5_Init() failed\n");
		return -1;
	}

	while((s=fread(buf, 1, FULL_CHUNK, *fp))>0)
	{
		if(!MD5_Update(&md5, buf, s))
		{
			logp("MD5_Update() failed\n");
			return -1;
		}
		if(s<FULL_CHUNK) break;
	}

	if(!MD5_Final(checksum, &md5))
	{
		logp("MD5_Final() failed\n");
		return -1;
	}

	memcpy(&(f->full_cksum), checksum, sizeof(unsigned));

	return 0;
}
Example #22
0
void md5String(const char* input1, const char* input2, char** out)
{
	int i;

	buffer* b = buffer_init();
	unsigned char signature[16];
	MD5_CTX ctx;
	MD5_Init(&ctx);

	if(input1){
		//Cdbg(1, "input1 %s", input1);
		MD5_Update(&ctx, input1, strlen(input1));	
	}
	
	if(input2){
		//Cdbg(1, "input2 %s", input2);
		MD5_Update(&ctx, input2, strlen(input2));	
	}
	
	MD5_Final(signature, &ctx);
	char tempstring[2];

	for(i=0; i<16; i++){
		int x = signature[i]/16;
		sprintf(tempstring, "%x", x);
		buffer_append_string(b, tempstring);
		
		int y = signature[i]%16;
		sprintf(tempstring, "%x", y);
		buffer_append_string(b, tempstring);		
	}

	//Cdbg(1, "result %s", b->ptr);
	
	int len = b->used + 1;
	*out = (char*)malloc(len);
	memset(*out, '\0', len);
	strcpy(*out, b->ptr);
	buffer_free(b);
}
Example #23
0
char* str2md5(const char* str, int length)
{
  int n;
  MD5_CTX c;
  unsigned char digest[16];
  char* out = (char*)malloc(33);

  MD5_Init(&c);
  while (length > 0)
  {
    if (length > 512)
      MD5_Update(&c, str, 512);
    else
      MD5_Update(&c, str, length);
    length -= 512;
    str += 512;
  }
  MD5_Final(digest, &c);
  for (n = 0; n < 16; ++n)
    snprintf(&(out[n * 2]), 16 * 2, "%02x", (unsigned int)digest[n]);
  return out;
}
Example #24
0
/* Function to generate key from the passphrase entered by the user */
unsigned char * md5_key_generate(char * a, int len)
{

	MD5_CTX c;
	unsigned char *digest=(unsigned char*)malloc(16);
	MD5_Init(&c);
	while(len>0){
		if(len>512){
			MD5_Update(&c,a,512);
		}
		else{
			MD5_Update(&c,a,len);
	
		}
	len-=512;
	a+=512;
	}

	MD5_Final(digest,&c);
	
	return digest;
}
Example #25
0
void
doit (void)
{
  MD5_CTX c;
  unsigned char md[MD5_DIGEST_LENGTH];

  if (!gnutls_check_version (LIBGNUTLS_VERSION))
    success ("gnutls_check_version ERROR\n");

  MD5_Init (&c);
  MD5_Update (&c, "abc", 3);
  MD5_Final (&(md[0]), &c);

  if (memcmp (md, "\x90\x01\x50\x98\x3c\xd2\x4f\xb0"
	      "\xd6\x96\x3f\x7d\x28\xe1\x7f\x72", sizeof (md)) != 0)
    {
      hexprint (md, sizeof (md));
      fail ("MD5 failure\n");
    }
  else
    success ("MD5 OK\n");
}
Example #26
0
u_int
res_nrandomid(res_state statp) {
	struct timeval now;
	u_int16_t u16;
	MD5_CTX ctx;
	u_char *rnd = statp->_rnd == NULL ? srnd : statp->_rnd;

	gettimeofday(&now, NULL);
	u16 = (u_int16_t) (now.tv_sec ^ now.tv_usec);
	memcpy(rnd + 14, &u16, 2);
#ifndef HAVE_MD5
	MD5_Init(&ctx);
	MD5_Update(&ctx, rnd, 16);
	MD5_Final(rnd, &ctx);
#else
	MD5Init(&ctx);
	MD5Update(&ctx, rnd, 16);
	MD5Final(rnd, &ctx);
#endif
	memcpy(&u16, rnd + 14, 2);
	return ((u_int) u16);
}
Example #27
0
static int crypt_all(int *pcount, struct db_salt *salt)
{
	const int count = *pcount;
	int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
	for (index = 0; index < count; index++)
#endif
	{
		// hash is compressor(md5(password))
		MD5_CTX ctx;
		unsigned char *out = (unsigned char*)crypt_out[index];
		unsigned char hash[16];

		MD5_Init(&ctx);
		MD5_Update(&ctx, saved_key[index], saved_len[index]);
		MD5_Final(hash, &ctx);

		compressor(hash, out);
	}
	return count;
}
Example #28
0
    unsigned char* samHive::generateHashedBootKey(unsigned char* bootKey) {
        unsigned char aqwerty[] = "!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%";
        unsigned char anum[] = "0123456789012345678901234567890123456789";

        MD5_CTX md5Context;
        unsigned char md5Hash[0x10];
        RC4_KEY rc4Key;
        unsigned char* hashedBootKey = new unsigned char[0x20];

        unsigned char* fValue = this->getGlobalFValue();

        MD5_Init(&md5Context);
        MD5_Update(&md5Context, &fValue[0x70], 0x10);
        MD5_Update(&md5Context, aqwerty, 0x2f);
        MD5_Update(&md5Context, bootKey, 0x10);
        MD5_Update(&md5Context, anum, 0x29);
        MD5_Final(md5Hash, &md5Context);
        RC4_set_key(&rc4Key, 0x10, md5Hash);
        RC4(&rc4Key, 0x20, &fValue[0x80], hashedBootKey);

        return hashedBootKey;
    }
Example #29
0
char *check_validity(
    const char *certPath, const char *origFile, unsigned char *signature,
    char* caPath
) {
    MD5_CTX md5CTX;
    int rbytes;
    unsigned char md5_md[MD5_DIGEST_LENGTH],  rbuf[2048];

    SSL_load_error_strings();
    SSL_library_init();

    if (!is_file(origFile)) {
        return NULL;
    }
    FILE* of = boinc_fopen(origFile, "r");
    if (!of) return NULL;
    MD5_Init(&md5CTX);
    while (0 != (rbytes = (int)fread(rbuf, 1, sizeof(rbuf), of))) {
	    MD5_Update(&md5CTX, rbuf, rbytes);
    }
    MD5_Final(md5_md, &md5CTX);
    fclose(of);

    DIRREF dir = dir_open(certPath);

    char file[MAXPATHLEN];
    while (!dir_scan(file, dir, sizeof(file))) {
        char fpath[MAXPATHLEN];
	    snprintf(fpath, sizeof(fpath), "%s/%s", certPath, file);
        // TODO : replace '128'  
	    if (check_validity_of_cert(fpath, md5_md, signature, 128, caPath)) {
	        dir_close(dir);
	        return strdup(fpath);
	    }
    }

    dir_close(dir);
    return NULL;
}
Example #30
0
int check_fmhdr(char *b, ssize_t len) {
  if (gV > 1) puts("check_fmhdr");

  MD5_CTX context;
  frm_t *buf = (frm_t *) b;

  unsigned char cmp_digest[0x10] = {0},    hdr_digest[0x10];
  unsigned char cmp_signature[0x20] = {0}, hdr_signature[0x20];
  unsigned char cmp_randseq[0x10] = {0},   hdr_randseq[0x10];

  memcpy(hdr_signature, buf->h.fm_signature, sizeof(hdr_signature));
  memset(buf->h.fm_signature, 0, 0x20);
  memcpy(hdr_digest,    buf->h.fm_digest,    sizeof(hdr_digest));
  memset(buf->h.fm_digest,    0, 0x10);

  MD5_Init(&context);							// Compute hash
  MD5_Update(&context, buf, len);
  MD5_Final(cmp_digest, &context);

  memcpy(hdr_randseq,   buf->h.fm_randseq,   sizeof(hdr_randseq));
  memset(buf->h.fm_randseq, 0, sizeof(buf->h.fm_randseq));
  nsdigest(cmp_randseq, (char *)buf, len);				// Compute digest
  memcpy(buf->h.fm_randseq,   cmp_randseq, sizeof(buf->h.fm_randseq));
  memcpy(buf->h.fm_digest,    cmp_digest, sizeof(buf->h.fm_digest));
  memcpy(buf->h.fm_signature, cmp_signature, sizeof(buf->h.fm_signature));

  if (memcmp(cmp_digest, hdr_digest, sizeof(hdr_digest))) {
    puts("Header digest error");
  print_digest(cmp_digest); print_digest(hdr_digest);
    return -1;
  }
  if (memcmp(cmp_randseq, hdr_randseq, sizeof(hdr_randseq))) {
    puts("Header randseq error");
  print_digest_x(cmp_randseq, 0x20); print_digest_x(hdr_randseq, 0x20);
    return -1;
  }
  puts ("Header OK!");
  return 0;
}