HashResult Sha256CommonCryptoImpl::Calculate(Aws::IStream& stream) { CC_SHA256_CTX sha256; CC_SHA256_Init(&sha256); 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_SHA256_Update(&sha256, streamBuffer, static_cast<CC_LONG>(bytesRead)); } } stream.clear(); stream.seekg(currentPos, stream.beg); ByteBuffer hash(CC_SHA256_DIGEST_LENGTH); CC_SHA256_Final(hash.GetUnderlyingData(), &sha256); return HashResult(std::move(hash)); }
int32_t mz_crypt_sha_end(void *handle, uint8_t *digest, int32_t digest_size) { mz_crypt_sha *sha = (mz_crypt_sha *)handle; if (sha == NULL || digest == NULL || !sha->initialized) return MZ_PARAM_ERROR; if (sha->algorithm == MZ_HASH_SHA1) { if (digest_size < MZ_HASH_SHA1_SIZE) return MZ_BUF_ERROR; sha->error = CC_SHA1_Final(digest, &sha->ctx1); } else { if (digest_size < MZ_HASH_SHA256_SIZE) return MZ_BUF_ERROR; sha->error = CC_SHA256_Final(digest, &sha->ctx256); } if (!sha->error) return MZ_HASH_ERROR; return MZ_OK; }
/* functions */ u2_weak // produce j2_mbc(Pt5, shax)(u2_wire wir_r, u2_atom a) // retain { c3_w met_w = u2_met(3, a); c3_y* fat_y = malloc(met_w + 1); u2_bytes(0, met_w, fat_y, a); { c3_y dig_y[32]; #if defined(U2_OS_linux) SHA256_CTX ctx_h; SHA256_Init(&ctx_h); SHA256_Update(&ctx_h, fat_y, met_w); SHA256_Final(dig_y, &ctx_h); #elif defined(U2_OS_osx) CC_SHA256_CTX ctx_h; CC_SHA256_Init(&ctx_h); CC_SHA256_Update(&ctx_h, fat_y, met_w); CC_SHA256_Final(dig_y, &ctx_h); #endif return u2_rl_bytes(wir_r, 32, dig_y); } }
u3_noun u3qe_shay(u3_atom a, u3_atom b) { c3_assert(_(u3a_is_cat(a))); c3_y* fat_y = u3a_malloc(a + 1); u3r_bytes(0, a, fat_y, b); { c3_y dig_y[32]; #if defined(U3_OS_osx) CC_SHA256_CTX ctx_h; CC_SHA256_Init(&ctx_h); CC_SHA256_Update(&ctx_h, fat_y, a); CC_SHA256_Final(dig_y, &ctx_h); #else SHA256_CTX ctx_h; SHA256_Init(&ctx_h); SHA256_Update(&ctx_h, fat_y, a); SHA256_Final(dig_y, &ctx_h); #endif u3a_free(fat_y); return u3i_bytes(32, dig_y); } }
Vector<uint8_t> CryptoDigest::computeHash() { Vector<uint8_t> result; switch (m_context->algorithm) { case CryptoAlgorithmIdentifier::SHA_1: result.resize(CC_SHA1_DIGEST_LENGTH); CC_SHA1_Final(result.data(), toSHA1Context(m_context.get())); break; case CryptoAlgorithmIdentifier::SHA_224: result.resize(CC_SHA224_DIGEST_LENGTH); CC_SHA224_Final(result.data(), toSHA224Context(m_context.get())); break; case CryptoAlgorithmIdentifier::SHA_256: result.resize(CC_SHA256_DIGEST_LENGTH); CC_SHA256_Final(result.data(), toSHA256Context(m_context.get())); break; case CryptoAlgorithmIdentifier::SHA_384: result.resize(CC_SHA384_DIGEST_LENGTH); CC_SHA384_Final(result.data(), toSHA384Context(m_context.get())); break; case CryptoAlgorithmIdentifier::SHA_512: result.resize(CC_SHA512_DIGEST_LENGTH); CC_SHA512_Final(result.data(), toSHA512Context(m_context.get())); break; default: ASSERT_NOT_REACHED(); } return result; }
// u3_noun // u3qe_shax( // u3_atom a) // { // c3_w met_w = u3r_met(3, a); // return u3qe_shay(met_w, a); // } // XX preformance u3_noun u3qe_shax(u3_atom a) { c3_w met_w = u3r_met(3, a); c3_y* fat_y = u3a_malloc(met_w + 1); u3r_bytes(0, met_w, fat_y, a); { c3_y dig_y[32]; #if defined(U3_OS_osx) CC_SHA256_CTX ctx_h; CC_SHA256_Init(&ctx_h); CC_SHA256_Update(&ctx_h, fat_y, met_w); CC_SHA256_Final(dig_y, &ctx_h); #else SHA256_CTX ctx_h; SHA256_Init(&ctx_h); SHA256_Update(&ctx_h, fat_y, met_w); SHA256_Final(dig_y, &ctx_h); #endif u3a_free(fat_y); return u3i_bytes(32, dig_y); } }
static NTSTATUS hash_finish( struct hash *hash, UCHAR *output, ULONG size ) { switch (hash->alg_id) { case ALG_ID_SHA1: CC_SHA1_Final( output, &hash->u.sha1_ctx ); break; case ALG_ID_SHA256: CC_SHA256_Final( output, &hash->u.sha256_ctx ); break; case ALG_ID_SHA384: CC_SHA384_Final( output, &hash->u.sha512_ctx ); break; case ALG_ID_SHA512: CC_SHA512_Final( output, &hash->u.sha512_ctx ); break; default: ERR( "unhandled id %u\n", hash->alg_id ); break; } return STATUS_SUCCESS; }
int sCCHashFinalSHA256(void *ctx, unsigned char *out) { CC_SHA256_Final(out, ctx); #ifdef LTC_CLEAN_STACK zeromem(ctx, sizeof(CC_SHA1_CTX)); #endif return CRYPT_OK; }
void ocspdSHA256( const void *data, CC_LONG len, unsigned char *md) // allocd by caller, CC_SHA256_DIGEST_LENGTH bytes { CC_SHA256_CTX ctx; CC_SHA256_Init(&ctx); CC_SHA256_Update(&ctx, data, len); CC_SHA256_Final(md, &ctx); }
static OSStatus HashSHA256Final(SSLBuffer *digestCtx, SSLBuffer *digest) { assert(digestCtx->length >= sizeof(CC_SHA256_CTX)); CC_SHA256_CTX *ctx = (CC_SHA256_CTX *)digestCtx->data; dgprintf(("###HashSHA256Final ctx %p\n", ctx)); assert(digest->length >= CC_SHA256_DIGEST_LENGTH); //if (digest->length < CC_SHA256_DIGEST_LENGTH) // return errSSLCrypto; CC_SHA256_Final(digest->data, ctx); digest->length = CC_SHA256_DIGEST_LENGTH; return noErr; }
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; } }
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; } }
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; }
void Download::FinalizeDigestAndCompare () { Sha256Digest digest; CC_SHA256_Final (digest, &mSHA256Context); // make sure we don't overflow the digest buffer if (mCurrentHash >= mNumHashes || memcmp (digest, mDigests[mCurrentHash++], CC_SHA256_DIGEST_LENGTH) != 0) { // Something's really wrong! MacOSError::throwMe (errSecureDownloadInvalidDownload); } // setup for the next receipt of data mBytesInCurrentDigest = 0; CC_SHA256_Init (&mSHA256Context); }
const static void signatura_hash(const char *input, char *result) { unsigned char hash[CC_SHA256_DIGEST_LENGTH]; CC_SHA256_CTX context; int i; CC_SHA256_Init(&context); CC_SHA256_Update(&context, input, strlen(input)); CC_SHA256_Final(hash, &context); for(i = 1; i < CC_SHA256_DIGEST_LENGTH; i++) { sprintf(result + (i * 2), "%02x", hash[i]); } result[64] = 0; }
static void _wi_sha2_ctx_final(unsigned char *buffer, _wi_sha2_ctx_t *ctx) { #ifdef WI_SHA2_OPENSSL switch(ctx->bits) { case WI_SHA2_224: SHA224_Final(buffer, &ctx->openssl_256_ctx); break; case WI_SHA2_256: SHA256_Final(buffer, &ctx->openssl_256_ctx); break; case WI_SHA2_384: SHA384_Final(buffer, &ctx->openssl_512_ctx); break; case WI_SHA2_512: SHA512_Final(buffer, &ctx->openssl_512_ctx); break; } #endif #ifdef WI_SHA2_COMMONCRYPTO switch(ctx->bits) { case WI_SHA2_224: CC_SHA224_Final(buffer, &ctx->commondigest_256_ctx); break; case WI_SHA2_256: CC_SHA256_Final(buffer, &ctx->commondigest_256_ctx); break; case WI_SHA2_384: CC_SHA384_Final(buffer, &ctx->commondigest_512_ctx); break; case WI_SHA2_512: CC_SHA512_Final(buffer, &ctx->commondigest_512_ctx); break; } #endif }
ssize_t /* O - Size of hash or -1 on error */ cupsHashData(const char *algorithm, /* I - Algorithm name */ const void *data, /* I - Data to hash */ size_t datalen, /* I - Length of data to hash */ unsigned char *hash, /* I - Hash buffer */ size_t hashsize) /* I - Size of hash buffer */ { if (!algorithm || !data || datalen == 0 || !hash || hashsize == 0) { _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Bad arguments to function"), 1); return (-1); } #ifdef __APPLE__ if (!strcmp(algorithm, "sha")) { /* * SHA-1... */ CC_SHA1_CTX ctx; /* SHA-1 context */ if (hashsize < CC_SHA1_DIGEST_LENGTH) goto too_small; CC_SHA1_Init(&ctx); CC_SHA1_Update(&ctx, data, (CC_LONG)datalen); CC_SHA1_Final(hash, &ctx); return (CC_SHA1_DIGEST_LENGTH); } else if (!strcmp(algorithm, "sha2-224")) { CC_SHA256_CTX ctx; /* SHA-224 context */ if (hashsize < CC_SHA224_DIGEST_LENGTH) goto too_small; CC_SHA224_Init(&ctx); CC_SHA224_Update(&ctx, data, (CC_LONG)datalen); CC_SHA224_Final(hash, &ctx); return (CC_SHA224_DIGEST_LENGTH); } else if (!strcmp(algorithm, "sha2-256")) { CC_SHA256_CTX ctx; /* SHA-256 context */ if (hashsize < CC_SHA256_DIGEST_LENGTH) goto too_small; CC_SHA256_Init(&ctx); CC_SHA256_Update(&ctx, data, (CC_LONG)datalen); CC_SHA256_Final(hash, &ctx); return (CC_SHA256_DIGEST_LENGTH); } else if (!strcmp(algorithm, "sha2-384")) { CC_SHA512_CTX ctx; /* SHA-384 context */ if (hashsize < CC_SHA384_DIGEST_LENGTH) goto too_small; CC_SHA384_Init(&ctx); CC_SHA384_Update(&ctx, data, (CC_LONG)datalen); CC_SHA384_Final(hash, &ctx); return (CC_SHA384_DIGEST_LENGTH); } else if (!strcmp(algorithm, "sha2-512")) { CC_SHA512_CTX ctx; /* SHA-512 context */ if (hashsize < CC_SHA512_DIGEST_LENGTH) goto too_small; CC_SHA512_Init(&ctx); CC_SHA512_Update(&ctx, data, (CC_LONG)datalen); CC_SHA512_Final(hash, &ctx); return (CC_SHA512_DIGEST_LENGTH); } else if (!strcmp(algorithm, "sha2-512_224")) { CC_SHA512_CTX ctx; /* SHA-512 context */ unsigned char temp[CC_SHA512_DIGEST_LENGTH]; /* SHA-512 hash */ /* * SHA2-512 truncated to 224 bits (28 bytes)... */ if (hashsize < CC_SHA224_DIGEST_LENGTH) goto too_small; CC_SHA512_Init(&ctx); CC_SHA512_Update(&ctx, data, (CC_LONG)datalen); CC_SHA512_Final(temp, &ctx); memcpy(hash, temp, CC_SHA224_DIGEST_LENGTH); return (CC_SHA224_DIGEST_LENGTH); } else if (!strcmp(algorithm, "sha2-512_256")) { CC_SHA512_CTX ctx; /* SHA-512 context */ unsigned char temp[CC_SHA512_DIGEST_LENGTH]; /* SHA-512 hash */ /* * SHA2-512 truncated to 256 bits (32 bytes)... */ if (hashsize < CC_SHA256_DIGEST_LENGTH) goto too_small; CC_SHA512_Init(&ctx); CC_SHA512_Update(&ctx, data, (CC_LONG)datalen); CC_SHA512_Final(temp, &ctx); memcpy(hash, temp, CC_SHA256_DIGEST_LENGTH); return (CC_SHA256_DIGEST_LENGTH); } #elif defined(HAVE_GNUTLS) gnutls_digest_algorithm_t alg = GNUTLS_DIG_UNKNOWN; /* Algorithm */ unsigned char temp[64]; /* Temporary hash buffer */ size_t tempsize = 0; /* Truncate to this size? */ if (!strcmp(algorithm, "sha")) alg = GNUTLS_DIG_SHA1; else if (!strcmp(algorithm, "sha2-224")) alg = GNUTLS_DIG_SHA224; else if (!strcmp(algorithm, "sha2-256")) alg = GNUTLS_DIG_SHA256; else if (!strcmp(algorithm, "sha2-384")) alg = GNUTLS_DIG_SHA384; else if (!strcmp(algorithm, "sha2-512")) alg = GNUTLS_DIG_SHA512; else if (!strcmp(algorithm, "sha2-512_224")) { alg = GNUTLS_DIG_SHA512; tempsize = 28; } else if (!strcmp(algorithm, "sha2-512_256")) { alg = GNUTLS_DIG_SHA512; tempsize = 32; } if (alg != GNUTLS_DIG_UNKNOWN) { if (tempsize > 0) { /* * Truncate result to tempsize bytes... */ if (hashsize < tempsize) goto too_small; gnutls_hash_fast(alg, data, datalen, temp); memcpy(hash, temp, tempsize); return ((ssize_t)tempsize); } if (hashsize < gnutls_hash_get_len(alg)) goto too_small; gnutls_hash_fast(alg, data, datalen, hash); return (gnutls_hash_get_len(alg)); } #else /* * No hash support without CommonCrypto or GNU TLS... */ if (hashsize < 64) goto too_small; #endif /* __APPLE__ */ /* * Unknown hash algorithm... */ _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unknown hash algorithm."), 1); return (-1); /* * We get here if the buffer is too small. */ too_small: _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Hash buffer too small."), 1); return (-1); }
static int __archive_libsystem_sha256final(archive_sha256_ctx *ctx, void *md) { CC_SHA256_Final(md, ctx); return (ARCHIVE_OK); }
void SHA256Object::digestFinal( void *digest) { CC_SHA256_Final((unsigned char *)digest, &mCtx); mIsDone = true; }
const void* SHA256Digest::Finalize() { CC_SHA256_Final(mDigestBuffer, &mContext); return mDigestBuffer; }