int
decryptFinal(HMACCheck hmacCheck)
{
CCCryptorStatus status;
int rv;
uint8_t hmacDigest[CC_SHA512_DIGEST_LENGTH];
status = CCCryptorFinal(cryptorRef,
compressed, sizeof(compressed), &compressedLen);
if (status != kCCSuccess) {
printf("cryptor update error\n");
return(-1);
}
status = CCCryptorRelease(cryptorRef);
if (status != kCCSuccess) {
printf("cryptor release error\n");
}
if (compressedLen) {
strm.next_in = compressed;
strm.avail_in = (uint)compressedLen;
do {
strm.next_out = bufOut;
strm.avail_out = sizeof(bufOut);
rv = inflate(&strm, Z_FINISH);
if (rv != Z_OK && rv != Z_STREAM_END && rv != Z_BUF_ERROR) {
printf("zlib error\n");
}
bufOutLen = sizeof(bufOut) - strm.avail_out;
if (bufOutLen) {
CCHmacUpdate(&hmacContextPlain, bufOut, bufOutLen);
writer(bufOut, bufOutLen);
}
} while (strm.avail_out == 0);
}
inflateEnd(&strm);
if (hmacCheck == kHmacNoCheck)
return(0);
/* CHECK */
CCHmacFinal(&hmacContext, &hmacDigest);
if (memcmp(header.hmacDigest, hmacDigest, sizeof(hmacDigest)))
printf("CRYPT CORRUPT\n");
CCHmacFinal(&hmacContextPlain, &hmacDigest);
if (memcmp(header.hmacDigestPlain, hmacDigest, sizeof(hmacDigest)))
printf("PLAIN CORRUPT\n");
return(0);
}
int
encryptFinal(void)
{
CCCryptorStatus status;
int rv;
/* finish zlib */
do {
strm.next_out = compressed;
strm.avail_out = sizeof(compressed);
rv = deflate(&strm, Z_FINISH);
if (rv != Z_OK && rv != Z_STREAM_END && rv != Z_BUF_ERROR) {
printf("zlib error %d\n", rv);
}
status = CCCryptorUpdate(cryptorRef,
compressed, sizeof(compressed) - strm.avail_out,
bufOut, sizeof(bufOut), &bufOutLen);
if (status != kCCSuccess) {
printf("cryptor update error\n");
return(-1);
}
if (bufOutLen) {
CCHmacUpdate(&hmacContext, bufOut, bufOutLen);
writer(bufOut, bufOutLen);
}
} while (strm.avail_out == 0);
deflateEnd(&strm);
status = CCCryptorFinal(cryptorRef,
bufOut, sizeof(bufOut), &bufOutLen);
if (status != kCCSuccess) {
printf("cryptor update error: %d\n", status);
}
if (bufOutLen) {
CCHmacUpdate(&hmacContext, bufOut, bufOutLen);
writer(bufOut, bufOutLen);
}
status = CCCryptorRelease(cryptorRef);
if (status != kCCSuccess) {
printf("cryptor release error\n");
}
CCHmacFinal(&hmacContext, &header.hmacDigest);
CCHmacFinal(&hmacContextPlain, &header.hmacDigestPlain);
seeker(0);
writer(&header, sizeof(header));
return(0);
}
extern "C" int AppleCryptoNative_HmacFinal(HmacCtx* ctx, uint8_t* pbOutput)
{
if (ctx == nullptr || pbOutput == nullptr)
return 0;
// No return value
CCHmacFinal(&ctx->hmac, pbOutput);
return 1;
}
static mrb_value
lib_hmac_digest(mrb_state *mrb, const struct mrb_hmac *hmac)
{
CCHmacContext ctx;
unsigned char str[MAX_DIGEST_LENGTH];
memcpy(&ctx, &hmac->ctx, sizeof(ctx));
CCHmacFinal(&ctx, str);
return mrb_str_new(mrb, (const char *)str, md_digest_length(hmac->type));
}
static
void
hmac_sha1(const uint8_t *key, size_t key_len, const uint8_t *text, size_t text_len,
uint8_t digest[CC_SHA1_DIGEST_LENGTH])
{
CCHmacContext hmac_sha1_context;
CCHmacInit(&hmac_sha1_context, kCCHmacAlgSHA1, key, key_len);
CCHmacUpdate(&hmac_sha1_context, text, text_len);
CCHmacFinal(&hmac_sha1_context, digest);
}
int Crypto::MACFinish(MAC x, char *out, int outlen) {
unique_ptr<CCMAC> m(FromVoid<CCMAC*>(x));
CCHmacFinal(&m->ctx, out);
switch(m->algo) {
case kCCHmacAlgMD5: return CC_MD5_DIGEST_LENGTH;
case kCCHmacAlgSHA1: return CC_SHA1_DIGEST_LENGTH;
case kCCHmacAlgSHA256: return CC_SHA256_DIGEST_LENGTH;
case kCCHmacAlgSHA512: return CC_SHA512_DIGEST_LENGTH;
default: return -1;
}
}
static OSStatus HMAC_Final(
HMACContextRef hmacCtx,
void *hmac, // mallocd by caller
unsigned *hmacLen) // IN/OUT
{
if(*hmacLen < hmacCtx->macSize) {
return errSSLInternal;
}
CCHmacFinal(&hmacCtx->ccHmac, hmac);
*hmacLen = hmacCtx->macSize;
return noErr;
}
int32_t mz_crypt_hmac_end(void *handle, uint8_t *digest, int32_t digest_size)
{
mz_crypt_hmac *hmac = (mz_crypt_hmac *)handle;
if (hmac == NULL || digest == NULL)
return MZ_PARAM_ERROR;
if (hmac->algorithm == MZ_HASH_SHA1)
{
if (digest_size < MZ_HASH_SHA1_SIZE)
return MZ_BUF_ERROR;
CCHmacFinal(&hmac->ctx, digest);
}
else
{
if (digest_size < MZ_HASH_SHA256_SIZE)
return MZ_BUF_ERROR;
CCHmacFinal(&hmac->ctx, digest);
}
return MZ_OK;
}
/*
* Stateless, one-shot HMAC function.
* Output is written to caller-spullied buffer, as in CCHmacFinal().
*/
void CCHmac(
CCHmacAlgorithm algorithm, /* kCCHmacSHA1, kCCHmacMD5 */
const void *key,
size_t keyLength, /* length of key in bytes */
const void *data,
size_t dataLength, /* length of data in bytes */
void *macOut) /* MAC written here */
{
CCHmacContext ctx;
CCHmacInit(&ctx, algorithm, key, keyLength);
CCHmacUpdate(&ctx, data, dataLength);
CCHmacFinal(&ctx, macOut);
}
/*
* Given an initialized CCHmacContext, feed it some data and get the result.
*/
static void hmacRun(
CCHmacContext *ctx,
bool randomUpdates,
const unsigned char *ptext,
size_t ptextLen,
void *dataOut)
{
while(ptextLen) {
size_t thisMoveIn; /* input to CCryptUpdate() */
if(randomUpdates) {
thisMoveIn = genRandomSize(1, ptextLen);
}
else {
thisMoveIn = ptextLen;
}
logSize(("###ptext segment (1) len %lu\n", (unsigned long)thisMoveIn));
CCHmacUpdate(ctx, ptext, thisMoveIn);
ptext += thisMoveIn;
ptextLen -= thisMoveIn;
}
CCHmacFinal(ctx, dataOut);
}
virtual bool write(byte *out) {
CCHmacFinal(&ctx, out);
return true;
}
static void
__hmac_sha1_final(archive_hmac_sha1_ctx *ctx, uint8_t *out, size_t *out_len)
{
CCHmacFinal(ctx, out);
*out_len = 20;
}
const void* Hmac::Finalize()
{
CCHmacFinal(&mHMACContext, mDigestBuffer);
return mDigestBuffer;
}