static boolean_t should_update_icon(FILE *current_icon) { struct stat sbuf; off_t current_icon_size; CC_MD5_CTX ctx; size_t n; unsigned char buf[1024]; unsigned char current_icon_md[CC_MD5_DIGEST_LENGTH]; int i; fstat(fileno(current_icon), &sbuf); current_icon_size = sbuf.st_size; if (current_icon_size != snowflake_icon_size) { return (B_FALSE); } CC_MD5_Init(&ctx); while ((n = fread(buf, 1, 1024, current_icon)) > 0) { CC_MD5_Update(&ctx, buf, (CC_LONG)n); } CC_MD5_Final(current_icon_md, &ctx); rewind(current_icon); for(i = 0; i < CC_MD5_DIGEST_LENGTH; i++) { if (current_icon_md[i] != snowflake_icon_md[i]) { return (B_FALSE); } } return (B_TRUE); }
static char * build_A2_hash(heim_digest_t context, const char *method) { unsigned char md[CC_MD5_DIGEST_LENGTH]; CC_MD5_CTX ctx; char *A2; CC_MD5_Init(&ctx); if (method) CC_MD5_Update(&ctx, method, (CC_LONG)strlen(method)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->clientURI, (CC_LONG)strlen(context->clientURI)); /* conf|int */ if (context->type == HEIM_DIGEST_TYPE_RFC2831) { if (strcasecmp(context->clientQOP, "auth-int") == 0 || strcasecmp(context->clientQOP, "auth-conf") == 0) { /* XXX if we have a body hash, use that */ static char conf_zeros[] = ":00000000000000000000000000000000"; CC_MD5_Update(&ctx, conf_zeros, sizeof(conf_zeros) - 1); } } else { /* support auth-int ? */ if (context->clientQOP && strcasecmp(context->clientQOP, "auth") != 0) return NULL; } CC_MD5_Final(md, &ctx); hex_encode(md, sizeof(md), &A2); if (A2) strlwr(A2); return A2; }
HashResult MD5CommonCryptoImpl::Calculate(Aws::IStream& stream) { CC_MD5_CTX md5; CC_MD5_Init(&md5); auto currentPos = stream.tellg(); stream.seekg(0, stream.beg); char streamBuffer[Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE]; while(stream.good()) { stream.read(streamBuffer, Aws::Utils::Crypto::Hash::INTERNAL_HASH_STREAM_BUFFER_SIZE); auto bytesRead = stream.gcount(); if(bytesRead > 0) { CC_MD5_Update(&md5, streamBuffer, static_cast<CC_LONG>(bytesRead)); } } stream.clear(); stream.seekg(currentPos, stream.beg); ByteBuffer hash(CC_MD5_DIGEST_LENGTH); CC_MD5_Final(hash.GetUnderlyingData(), &md5); return HashResult(std::move(hash)); }
CFDataRef WebApiClientMD5DigestCreateWithFilePath(CFStringRef filePath, size_t bufferSize) { // Declare needed variables CFDataRef result = NULL; CFReadStreamRef readStream = NULL; // Get the file URL CFURLRef fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, (CFStringRef)filePath, kCFURLPOSIXPathStyle, (Boolean)false); if ( fileURL ) { // Create and open the read stream readStream = CFReadStreamCreateWithFile(kCFAllocatorDefault, fileURL); if ( readStream ) { Boolean didSucceed = CFReadStreamOpen(readStream); if ( didSucceed ) { // Initialize the hash object CC_MD5_CTX hashObject; CC_MD5_Init(&hashObject); // Make sure chunkSizeForReadingData is valid if ( bufferSize < 1 ) { bufferSize = FileHashDefaultChunkSizeForReadingData; } // Feed the data to the hash object bool hasMoreData = true; while ( hasMoreData ) { uint8_t buffer[bufferSize]; CFIndex readBytesCount = CFReadStreamRead(readStream, (UInt8 *)buffer, (CFIndex)sizeof(buffer)); if ( readBytesCount == -1 ) break; if ( readBytesCount == 0 ) { hasMoreData = false; continue; } CC_MD5_Update(&hashObject, (const void *)buffer, (CC_LONG)readBytesCount); } // Check if the read operation succeeded didSucceed = !hasMoreData; // Compute the hash digest unsigned char digest[CC_MD5_DIGEST_LENGTH]; CC_MD5_Final(digest, &hashObject); // Abort if the read operation failed if ( didSucceed ) { result = CFDataCreate(kCFAllocatorDefault, digest, CC_MD5_DIGEST_LENGTH); } } } } if ( readStream ) { CFReadStreamClose(readStream); CFRelease(readStream); } if ( fileURL ) { CFRelease(fileURL); } return result; }
static char * build_digest(heim_digest_t context, const char *a1, const char *method) { CC_MD5_CTX ctx; uint8_t md[CC_MD5_DIGEST_LENGTH]; char *a2, *str = NULL; a2 = build_A2_hash(context, method); if (a2 == NULL) return NULL; CC_MD5_Init(&ctx); CC_MD5_Update(&ctx, a1, (CC_LONG)strlen(a1)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->serverNonce, (CC_LONG)strlen(context->serverNonce)); if (context->type != HEIM_DIGEST_TYPE_RFC2069) { CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->clientNC, (CC_LONG)strlen(context->clientNC)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->clientNonce, (CC_LONG)strlen(context->clientNonce)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->clientQOP, (CC_LONG)strlen(context->clientQOP)); } CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, a2, (CC_LONG)strlen(a2)); CC_MD5_Final(md, &ctx); free(a2); hex_encode(md, sizeof(md), &str); if (str) strlwr(str); return str; }
void MD5Object::digestFinal( void *digest) { if(mIsDone) { throw std::runtime_error("MD5 digestFinal after final"); } CC_MD5_Final((unsigned char *)digest, &mCtx); mIsDone = true; }
static void _wi_md5_ctx_final(unsigned char *buffer, _wi_md5_ctx_t *ctx) { #ifdef WI_MD5_OPENSSL MD5_Final(buffer, &ctx->openssl_ctx); #endif #ifdef WI_MD5_COMMONCRYPTO CC_MD5_Final(buffer, &ctx->commondigest_ctx); #endif }
void crypt_md5_hash(const void* content, size_t content_size, void* md5, size_t md5_size) { assert(md5_size >= 16); CC_MD5_CTX context; CC_MD5_Init(&context); CC_MD5_Update(&context, content, (CC_LONG)content_size); CC_MD5_Final(md5, &context); }
void cCCHmacFinal(CCHmacContext *ctx, void *m) { size_t i; unsigned char md5[CC_MD5_DIGEST_LENGTH]; /* 4. Compute MD5 of result of step 3 */ CC_MD5_Final(md5, &ctx->md5ctx); /* 5. XOR step 1 key with 0x5c */ for (i=0; i<CC_MD5_BLOCK_BYTES; ++i) ctx->keydata[i] ^= (0x36 ^ 0x5c); /* 6. Append MD5 result from step 4 to result of step 5 */ /* 7. Compute MD5 of result of step 6 and output the result */ CC_MD5_Init(&ctx->md5ctx); CC_MD5_Update(&ctx->md5ctx, ctx->keydata, CC_MD5_BLOCK_BYTES); CC_MD5_Update(&ctx->md5ctx, md5, CC_MD5_DIGEST_LENGTH); CC_MD5_Final(m, &ctx->md5ctx); }
int sCCHashFinalMD5(void *ctx, unsigned char *out) { CC_MD5_Final(out, ctx); #ifdef LTC_CLEAN_STACK zeromem(ctx, sizeof(CC_SHA1_CTX)); #endif return CRYPT_OK; }
void ocspdMD5( const void *data, CC_LONG len, unsigned char *md) // allocd by caller, CC_MD5_DIGEST_LENGTH bytes { CC_MD5_CTX ctx; CC_MD5_Init(&ctx); CC_MD5_Update(&ctx, data, len); CC_MD5_Final(md, &ctx); }
static int file_compare(FILE *f1, FILE *f2) { struct stat sbuf; off_t f1size, f2size; CC_MD5_CTX ctx; size_t n; unsigned char buf[1024]; unsigned char mdresult1[CC_MD5_DIGEST_LENGTH]; unsigned char mdresult2[CC_MD5_DIGEST_LENGTH]; int i; fstat(fileno(f1), &sbuf); f1size = sbuf.st_size; fstat(fileno(f2), &sbuf); f2size = sbuf.st_size; if (f1size != f2size) return (-1); CC_MD5_Init(&ctx); while ((n = fread(buf, 1, 1024, f1)) > 0) { CC_MD5_Update(&ctx, buf, (CC_LONG)n); } CC_MD5_Final(mdresult1, &ctx); rewind(f1); CC_MD5_Init(&ctx); while ((n = fread(buf, 1, 1024, f2)) > 0) { CC_MD5_Update(&ctx, buf, (CC_LONG)n); } CC_MD5_Final(mdresult2, &ctx); rewind(f2); for(i = 0; i < CC_MD5_DIGEST_LENGTH; i++) { if (mdresult1[i] != mdresult2[i]) return (-1); } return (0); }
static char * build_A1_hash(int type, const char *username, const char *password, const char *realm, const char *serverNonce, const char *clientNonce, const char *auth_id) { unsigned char md[CC_MD5_DIGEST_LENGTH]; CC_MD5_CTX ctx; char *A1; CC_MD5_Init(&ctx); CC_MD5_Update(&ctx, username, strlen(username)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, realm, strlen(realm)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, password, strlen(password)); CC_MD5_Final(md, &ctx); if (type != HEIM_DIGEST_TYPE_RFC2069) { CC_MD5_Init(&ctx); CC_MD5_Update(&ctx, md, sizeof(md)); memset(md, 0, sizeof(md)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, serverNonce, strlen(serverNonce)); if (clientNonce) { CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, clientNonce, strlen(clientNonce)); } if (auth_id) { CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, auth_id, strlen(auth_id)); } CC_MD5_Final(md, &ctx); } hex_encode(md, sizeof(md), &A1); if (A1) strlwr(A1); return A1; }
static void md_final(int type, unsigned char *str, void *ctx) { switch (type) { case MD_TYPE_MD5: CC_MD5_Final(str, ctx); break; case MD_TYPE_SHA1: CC_SHA1_Final(str, ctx); break; case MD_TYPE_SHA256: CC_SHA256_Final(str, ctx); break; case MD_TYPE_SHA384: CC_SHA384_Final(str, ctx); break; case MD_TYPE_SHA512: CC_SHA512_Final(str, ctx); break; default: break; } }
static OSStatus HashMD5Final(SSLBuffer *digestCtx, SSLBuffer *digest) { assert(digestCtx->length >= sizeof(CC_MD5_CTX)); CC_MD5_CTX *ctx = (CC_MD5_CTX *)digestCtx->data; dgprintf(("###HashMD5Final ctx %p\n", ctx)); assert(digest->length >= CC_MD5_DIGEST_LENGTH); //if (digest->length < CC_MD5_DIGEST_LENGTH) // return errSSLCrypto; CC_MD5_Final(digest->data, ctx); digest->length = CC_MD5_DIGEST_LENGTH; return noErr; }
extern "C" int32_t AppleCryptoNative_DigestFinal(DigestCtx* ctx, uint8_t* pOutput, int32_t cbOutput) { if (ctx == nullptr || pOutput == nullptr || cbOutput < ctx->cbDigest) return -1; int32_t ret = 0; switch (ctx->algorithm) { case PAL_MD5: ret = CC_MD5_Final(pOutput, &ctx->d.md5); break; case PAL_SHA1: ret = CC_SHA1_Final(pOutput, &ctx->d.sha1); break; case PAL_SHA256: ret = CC_SHA256_Final(pOutput, &ctx->d.sha256); break; case PAL_SHA384: ret = CC_SHA384_Final(pOutput, &ctx->d.sha384); break; case PAL_SHA512: ret = CC_SHA512_Final(pOutput, &ctx->d.sha512); break; default: ret = -1; break; } if (ret != 1) { return ret; } switch (ctx->algorithm) { case PAL_MD5: return CC_MD5_Init(&ctx->d.md5); case PAL_SHA1: return CC_SHA1_Init(&ctx->d.sha1); case PAL_SHA256: return CC_SHA256_Init(&ctx->d.sha256); case PAL_SHA384: return CC_SHA384_Init(&ctx->d.sha384); case PAL_SHA512: return CC_SHA512_Init(&ctx->d.sha512); default: assert(false); return -2; } }
static void digest_userhash(const char *user, const char *realm, const char *password, unsigned char md[CC_MD5_DIGEST_LENGTH]) { CC_MD5_CTX ctx; CC_MD5_Init(&ctx); CC_MD5_Update(&ctx, user, (CC_LONG)strlen(user)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, realm, (CC_LONG)strlen(realm)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, password, (CC_LONG)strlen(password)); CC_MD5_Final(md, &ctx); }
string Crypto::DigestFinish(Digest x) { auto d = FromVoid<CCDigest*>(x); string ret; switch(d->algo) { case CCDigestAlgo::MD5: ret.resize(CC_MD5_DIGEST_LENGTH); CC_MD5_Final (MakeUnsigned(&ret[0]), static_cast<CC_MD5_CTX*> (d->v)); free(d->v); d->v=0; break; case CCDigestAlgo::SHA1: ret.resize(CC_SHA1_DIGEST_LENGTH); CC_SHA1_Final (MakeUnsigned(&ret[0]), static_cast<CC_SHA1_CTX*> (d->v)); free(d->v); d->v=0; break; case CCDigestAlgo::SHA256: ret.resize(CC_SHA256_DIGEST_LENGTH); CC_SHA256_Final(MakeUnsigned(&ret[0]), static_cast<CC_SHA256_CTX*>(d->v)); free(d->v); d->v=0; break; case CCDigestAlgo::SHA384: ret.resize(CC_SHA384_DIGEST_LENGTH); CC_SHA384_Final(MakeUnsigned(&ret[0]), static_cast<CC_SHA512_CTX*>(d->v)); free(d->v); d->v=0; break; case CCDigestAlgo::SHA512: ret.resize(CC_SHA512_DIGEST_LENGTH); CC_SHA512_Final(MakeUnsigned(&ret[0]), static_cast<CC_SHA512_CTX*>(d->v)); free(d->v); d->v=0; break; default: break; } delete d; return ret; }
static char * build_A1_hash(heim_digest_t context) { unsigned char md[CC_MD5_DIGEST_LENGTH]; CC_MD5_CTX ctx; char *A1; if (context->flags & F_HAVE_HA1) { memcpy(md, context->SecretHash, sizeof(md)); } else if (context->flags & F_HAVE_HASH) { memcpy(md, context->SecretHash, sizeof(md)); } else if (context->password) { if (context->clientUsername == NULL) return NULL; if (context->serverRealm == NULL) return NULL; digest_userhash(context->clientUsername, context->serverRealm, context->password, md); } else return NULL; if ((context->type == HEIM_DIGEST_TYPE_RFC2617_MD5_SESS || context->type == HEIM_DIGEST_TYPE_RFC2831) && (context->flags & F_HAVE_HA1) == 0) { if (context->serverNonce == NULL) return NULL; CC_MD5_Init(&ctx); CC_MD5_Update(&ctx, md, sizeof(md)); memset(md, 0, sizeof(md)); CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->serverNonce, (CC_LONG)strlen(context->serverNonce)); if (context->clientNonce) { CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->clientNonce, (CC_LONG)strlen(context->clientNonce)); } if (context->type == HEIM_DIGEST_TYPE_RFC2831 && context->auth_id) { CC_MD5_Update(&ctx, ":", 1); CC_MD5_Update(&ctx, context->auth_id, (CC_LONG)strlen(context->auth_id)); } CC_MD5_Final(md, &ctx); } hex_encode(md, sizeof(md), &A1); if (A1) strlwr(A1); return A1; }
static krb5_error_code k5_md5_hash(unsigned int icount, const krb5_data *input, krb5_data *output) { CC_MD5_CTX ctx; unsigned int i; if (output->length != CC_MD5_DIGEST_LENGTH) return(KRB5_CRYPTO_INTERNAL); CC_MD5_Init(&ctx); for (i=0; i<icount; i++) CC_MD5_Update(&ctx, (unsigned char *) input[i].data, input[i].length); CC_MD5_Final((unsigned char *)output->data, &ctx); return(0); }
/* * Compute a HMAC MD5 sum. * Taken from rfc2104, Appendix. */ static void signature_compute_hmac_md5(const u_int8_t *text, int text_len, unsigned char *key, unsigned int key_len, u_int8_t *digest) { CC_MD5_CTX context; unsigned char k_ipad[65]; /* inner padding - key XORd with ipad */ unsigned char k_opad[65]; /* outer padding - key XORd with opad */ unsigned char tk[16]; int i; /* if key is longer than 64 bytes reset it to key=MD5(key) */ if (key_len > 64) { CC_MD5_CTX tctx; CC_MD5_Init(&tctx); CC_MD5_Update(&tctx, key, key_len); CC_MD5_Final(tk, &tctx); key = tk; key_len = 16; } /* * the HMAC_MD5 transform looks like: * * MD5(K XOR opad, MD5(K XOR ipad, text)) * * where K is an n byte key * ipad is the byte 0x36 repeated 64 times * opad is the byte 0x5c repeated 64 times * and text is the data being protected */ /* start out by storing key in pads */ memset(k_ipad, 0, sizeof k_ipad); memset(k_opad, 0, sizeof k_opad); memcpy(k_ipad, key, key_len); memcpy(k_opad, key, key_len); /* XOR key with ipad and opad values */ for (i=0; i<64; i++) { k_ipad[i] ^= 0x36; k_opad[i] ^= 0x5c; } /* * perform inner MD5 */ CC_MD5_Init(&context); /* init context for 1st pass */ CC_MD5_Update(&context, k_ipad, 64); /* start with inner pad */ CC_MD5_Update(&context, text, text_len); /* then text of datagram */ CC_MD5_Final(digest, &context); /* finish up 1st pass */ /* * perform outer MD5 */ CC_MD5_Init(&context); /* init context for 2nd pass */ CC_MD5_Update(&context, k_opad, 64); /* start with outer pad */ CC_MD5_Update(&context, digest, 16); /* then results of 1st hash */ CC_MD5_Final(digest, &context); /* finish up 2nd pass */ }
CFStringRef FileMD5HashCreateWithPath(CFStringRef filePath, size_t chunkSizeForReadingData) { CFStringRef result = NULL; CFReadStreamRef readStream = NULL; CFURLRef fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, (CFStringRef)filePath, kCFURLPOSIXPathStyle, (Boolean) false); if (!fileURL) { goto done; } readStream = CFReadStreamCreateWithFile(kCFAllocatorDefault, (CFURLRef)fileURL); if (!readStream) { goto done; } bool didSucceed = (bool)CFReadStreamOpen(readStream); if (!didSucceed) { goto done; } // Initialize the hash object CC_MD5_CTX hashObject; CC_MD5_Init(&hashObject); // Make sure the chunkSizeForReadindData is valid if (!chunkSizeForReadingData) { chunkSizeForReadingData = FileHashDefaultChunksSizeForReadingData; } // Feed the data to the hash object bool hasMoreData = true; while (hasMoreData) { uint8_t buffer[chunkSizeForReadingData]; CFIndex readBytesCount = CFReadStreamRead(readStream, (UInt8 *)buffer, (CFIndex)sizeof(buffer)); if (readBytesCount == -1) { break; } if (readBytesCount == 0) { hasMoreData = false; continue; } CC_MD5_Update(&hashObject, (const void *)buffer, (CC_LONG)readBytesCount); } // Check if the read operation has succeded didSucceed = !hasMoreData; // Compute the hash digest unsigned char digest[CC_MD5_DIGEST_LENGTH]; CC_MD5_Final(digest, &hashObject); // Abort if the read operation fails if (!didSucceed) { goto done; } // Compute the string result char hash[2 * sizeof(digest) + 1]; for (size_t i = 0; i < sizeof(digest); ++i) { snprintf(hash + (2 * i), 3, "%02x", (int)(digest[i])); } result = CFStringCreateWithCString(kCFAllocatorDefault, (const char *)hash, kCFStringEncodingUTF8); done: if (readStream) { CFReadStreamClose(readStream); CFRelease(readStream); } if (fileURL) { CFRelease(fileURL); } return result; }
CFStringRef GCCreateMD5HashWithPath(CFStringRef filePath) { CFStringRef result = NULL; CFReadStreamRef readStream = NULL; CFURLRef fileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, (CFStringRef)filePath, kCFURLPOSIXPathStyle, (Boolean)false); if (!fileURL) goto done; readStream = CFReadStreamCreateWithFile(kCFAllocatorDefault, (CFURLRef)fileURL); if (!readStream) goto done; bool didSucceed = (bool)CFReadStreamOpen(readStream); if (!didSucceed) goto done; CC_MD5_CTX hashObject; CC_MD5_Init(&hashObject); bool hasMoreData = true; while (hasMoreData) { uint8_t buffer[GCFileChunkSize]; CFIndex readBytesCount = CFReadStreamRead(readStream, (UInt8 *)buffer, (CFIndex)sizeof(buffer)); if (readBytesCount == -1) break; if (readBytesCount == 0) { hasMoreData = false; continue; } CC_MD5_Update(&hashObject, (const void *)buffer, (CC_LONG)readBytesCount); } didSucceed = !hasMoreData; unsigned char digest[CC_MD5_DIGEST_LENGTH]; CC_MD5_Final(digest, &hashObject); if (!didSucceed) goto done; char hash[2 * sizeof(digest) + 1]; for (size_t i = 0; i < sizeof(digest); ++i) { snprintf(hash + (2 * i), 3, "%02x", (int)(digest[i])); } result = CFStringCreateWithCString(kCFAllocatorDefault, (const char *)hash, kCFStringEncodingUTF8); done: if (readStream) { CFReadStreamClose(readStream); CFRelease(readStream); } if (fileURL) { CFRelease(fileURL); } return result; }
static int __archive_libsystem_md5final(archive_md5_ctx *ctx, void *md) { CC_MD5_Final(md, ctx); return (ARCHIVE_OK); }
const void* MD5Digest::Finalize() { CC_MD5_Final(mDigestBuffer, &mContext); return mDigestBuffer; }