void SHA256::Finalize( void* hash )
{
if ( m_context == nullptr )
throw Error( "SHA256::Finalize(): Invalid call on uninitialized object." );
SHA256Result( CTX, static_cast<uint8_t*>( hash ) );
SHA256Reset( CTX );
}
void md_map_sh256(uint8_t *hash, const uint8_t *msg, int len) {
SHA256Context ctx;
if (SHA256Reset(&ctx) != shaSuccess) {
THROW(ERR_NO_VALID);
}
if (SHA256Input(&ctx, msg, len) != shaSuccess) {
THROW(ERR_NO_VALID);
}
if (SHA256Result(&ctx, hash) != shaSuccess) {
THROW(ERR_NO_VALID);
}
}
/*
* USHAResult
*
* Description:
* This function will return the 160-bit message digest into the
* Message_Digest array provided by the caller.
* NOTE: The first octet of hash is stored in the 0th element,
* the last octet of hash in the 19th element.
*
* Parameters:
* context: [in/out]
* The context to use to calculate the SHA-1 hash.
* Message_Digest: [out]
* Where the digest is returned.
*
* Returns:
* sha Error Code.
*
*/
int USHAResult(USHAContext *ctx,
uint8_t Message_Digest[USHAMaxHashSize])
{
if (ctx) {
switch (ctx->whichSha) {
case SHA1:
return SHA1Result((SHA1Context*)&ctx->ctx, Message_Digest);
case SHA224:
return SHA224Result((SHA224Context*)&ctx->ctx, Message_Digest);
case SHA256:
return SHA256Result((SHA256Context*)&ctx->ctx, Message_Digest);
case SHA384:
return SHA384Result((SHA384Context*)&ctx->ctx, Message_Digest);
case SHA512:
return SHA512Result((SHA512Context*)&ctx->ctx, Message_Digest);
default: return shaBadParam;
}
}
else {
return shaNull;
}
}
/*!
Returns the final hash value.
\sa QByteArray::toHex()
*/
QByteArray QCryptographicHash::result() const
{
if (!d->result.isEmpty())
return d->result;
switch (d->method) {
case Sha1: {
Sha1State copy = d->sha1Context;
d->result.resize(20);
sha1FinalizeState(©);
sha1ToHash(©, (unsigned char *)d->result.data());
break;
}
#ifdef QT_CRYPTOGRAPHICHASH_ONLY_SHA1
default:
Q_ASSERT_X(false, "QCryptographicHash", "Method not compiled in");
Q_UNREACHABLE();
break;
#else
case Md4: {
md4_context copy = d->md4Context;
d->result.resize(MD4_RESULTLEN);
md4_final(©, (unsigned char *)d->result.data());
break;
}
case Md5: {
MD5Context copy = d->md5Context;
d->result.resize(16);
MD5Final(©, (unsigned char *)d->result.data());
break;
}
case Sha224: {
SHA224Context copy = d->sha224Context;
d->result.resize(SHA224HashSize);
SHA224Result(©, reinterpret_cast<unsigned char *>(d->result.data()));
break;
}
case Sha256:{
SHA256Context copy = d->sha256Context;
d->result.resize(SHA256HashSize);
SHA256Result(©, reinterpret_cast<unsigned char *>(d->result.data()));
break;
}
case Sha384:{
SHA384Context copy = d->sha384Context;
d->result.resize(SHA384HashSize);
SHA384Result(©, reinterpret_cast<unsigned char *>(d->result.data()));
break;
}
case Sha512:{
SHA512Context copy = d->sha512Context;
d->result.resize(SHA512HashSize);
SHA512Result(©, reinterpret_cast<unsigned char *>(d->result.data()));
break;
}
case RealSha3_224: {
d->sha3Finish(224, QCryptographicHashPrivate::Sha3Variant::Sha3);
break;
}
case RealSha3_256: {
d->sha3Finish(256, QCryptographicHashPrivate::Sha3Variant::Sha3);
break;
}
case RealSha3_384: {
d->sha3Finish(384, QCryptographicHashPrivate::Sha3Variant::Sha3);
break;
}
case RealSha3_512: {
d->sha3Finish(512, QCryptographicHashPrivate::Sha3Variant::Sha3);
break;
}
case Keccak_224: {
d->sha3Finish(224, QCryptographicHashPrivate::Sha3Variant::Keccak);
break;
}
case Keccak_256: {
d->sha3Finish(256, QCryptographicHashPrivate::Sha3Variant::Keccak);
break;
}
case Keccak_384: {
d->sha3Finish(384, QCryptographicHashPrivate::Sha3Variant::Keccak);
break;
}
case Keccak_512: {
d->sha3Finish(512, QCryptographicHashPrivate::Sha3Variant::Keccak);
break;
}
#endif
}
return d->result;
}
static int load_registration_id(PROV_AUTH_INFO* handle)
{
int result;
if (handle->sec_type == PROV_AUTH_TYPE_TPM)
{
SHA256Context sha_ctx;
uint8_t msg_digest[SHA256HashSize];
unsigned char* endorsement_key;
size_t ek_len;
if (handle->hsm_client_get_endorsement_key(handle->hsm_client_handle, &endorsement_key, &ek_len) != 0)
{
LogError("Failed getting device reg id");
result = MU_FAILURE;
}
else
{
if (SHA256Reset(&sha_ctx) != 0)
{
LogError("Failed sha256 reset");
result = MU_FAILURE;
}
else if (SHA256Input(&sha_ctx, endorsement_key, (unsigned int)ek_len) != 0)
{
LogError("Failed SHA256Input");
result = MU_FAILURE;
}
else if (SHA256Result(&sha_ctx, msg_digest) != 0)
{
LogError("Failed SHA256Result");
result = MU_FAILURE;
}
else
{
handle->registration_id = encode_value(msg_digest, SHA256HashSize);
if (handle->registration_id == NULL)
{
LogError("Failed allocating registration Id");
result = MU_FAILURE;
}
else
{
result = 0;
}
}
free(endorsement_key);
}
}
else
{
handle->registration_id = handle->hsm_client_get_common_name(handle->hsm_client_handle);
if (handle->registration_id == NULL)
{
LogError("Failed getting common name from certificate");
result = MU_FAILURE;
}
else
{
result = 0;
}
}
return result;
}
int sha256_low_final(SHA256Context *context, unsigned char *out) {
return SHA256Result(context, (uint8_t *) out);
}
