extern int command_digest(int argc, char * const *argv)
{
int result = 1;
uint8_t *data = NULL;
size_t data_len;
const struct ccdigest_info *di;
unsigned char *digest = NULL;
unsigned long i,j;
if (argc < 3)
return 2; /* Return 2 triggers usage message. */
if (strcasecmp("sha1", argv[1]) == 0)
{
//printf("Calculating sha1\n");
di = ccsha1_di();
}
else if (strcasecmp("sha256", argv[1]) == 0)
{
//printf("Calculating sha256\n");
di = ccsha256_di();
}
else if (strcasecmp("sha512", argv[1]) == 0)
{
//printf("Calculating sha256\n");
di = ccsha512_di();
}
else
return 2; /* Return 2 triggers usage message. */
digest = malloc(di->output_size);
if (!digest)
goto exit;
for (i = 2; i < (unsigned int)argc; ++i)
{
printf("%s(%s)= ", argv[1], argv[i]);
if (read_file( argv[i], &data, &data_len) != 0 || !data)
{
printf("error reading file\n");
continue;
}
ccdigest(di, data_len, data, digest);
for (j = 0; j < di->output_size; j++)
printf("%02x", digest[j]);
printf("\n");
free(data);
data = NULL;
}
result = 0;
exit:
if(data)
free(data);
if (digest)
free(digest);
return result;
}
void SecOTRAppendDHMessage(SecOTRSessionRef session,
CFMutableDataRef appendTo)
{
//
// Message Type: kDHMessage (0x02)
// AES_CTR(r, 0) of G^X MPI
// SHA256(gxmpi)
//
if(!session) return;
CFMutableDataRef gxmpi = CFDataCreateMutable(kCFAllocatorDefault, 0);
if(!gxmpi) return;
AppendHeader(appendTo, kDHMessage);
SecFDHKAppendPublicSerialization(session->_myKey, gxmpi);
size_t gxmpiSize = (size_t)CFDataGetLength(gxmpi);
if(gxmpiSize == 0) {
CFReleaseNull(gxmpi);
return;
}
const uint8_t* gxmpiLocation = CFDataGetBytePtr(gxmpi);
/* 64 bits cast: gxmpiSize is the size of the EC public key, which is hardcoded and never more than 2^32 bytes. */
assert(gxmpiSize<UINT32_MAX); /* debug check only */
AppendLong(appendTo, (uint32_t)gxmpiSize);
assert(gxmpiSize<INT32_MAX);
uint8_t* encGxmpiLocation = CFDataIncreaseLengthAndGetMutableBytes(appendTo, (CFIndex)gxmpiSize);
AES_CTR_IV0_Transform(sizeof(session->_r), session->_r, gxmpiSize, gxmpiLocation, encGxmpiLocation);
AppendLong(appendTo, CCSHA256_OUTPUT_SIZE);
uint8_t* hashLocation = CFDataIncreaseLengthAndGetMutableBytes(appendTo, CCSHA256_OUTPUT_SIZE);
#ifdef USECOMMONCRYPTO
(void) CC_SHA256(gxmpiLocation, (uint32_t)gxmpiSize, hashLocation);
#else
ccdigest(ccsha256_di(), gxmpiSize, gxmpiLocation, hashLocation);
#endif
CFReleaseNull(gxmpi);
}
int ccrsa_test_verify_pkcs1v15_vector(const struct ccrsa_verify_vector *v)
{
bool ok;
int rc;
const struct ccdigest_info *di = v->di;
const cc_size n = ccn_nof(v->modlen);
const size_t s = ccn_sizeof(v->modlen);
unsigned char H[di->output_size];
cc_unit exponent[n];
cc_unit modulus[n];
ccrsa_pub_ctx_decl(ccn_sizeof(v->modlen), key);
ccrsa_ctx_n(key) = n;
ccn_seti(n, exponent, v->exp);
ccn_read_uint(n, modulus, s, v->mod);
ccrsa_init_pub(key, modulus, exponent);
ccdigest(di, v->msglen, v->msg, H);
rc=ccrsa_verify_pkcs1v15(key, di->oid.oid, di->output_size, H, v->siglen, v->sig, &ok);
return ((rc==0)
&& ((ok && v->valid) || (!ok && !v->valid)))?0:1;
}
static int test_oneshot(const struct ccdigest_info *di, test_vector *vector) {
uint8_t answer[128];
ccdigest(di, vector->len, vector->input, answer);
ok(test_answer(di, vector, answer), "check answer");
return 1;
}
static int SHA_POST()
{
int result = -1;
size_t messageSize = 10;
const struct ccdigest_info* sha1Impl = ccsha1_di();
const struct ccdigest_info* sha224Impl = ccsha224_di();
const struct ccdigest_info* sha256Impl = ccsha256_di();
const struct ccdigest_info* sha384Impl = ccsha384_di();
const struct ccdigest_info* sha512Impl = ccsha512_di();
typedef struct
{
const struct ccdigest_info* digest_info;
unsigned char* msgBuffer;
unsigned char* digestBuffer;
size_t digestBufferLength;
} digest_test;
// SHA1 Test Data
unsigned char* sha1MsgBuffer = (unsigned char*)"\xd2\x32\xb4\x7e\xa4\x52\xd5\xd7\xa0\x89";
#ifdef FORCE_FAIL
unsigned char* shaDigestBuffer = (unsigned char*)"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13";
#else
unsigned char* shaDigestBuffer = (unsigned char*)"\xb3\x31\xfe\x2c\xda\xc9\xc5\x2b\x0f\xae\xff\xfb\x04\x09\xa7\x3a\xaf\x86\xb3\x28";
#endif
size_t sha1DigestBufferLength = 20;
// SHA224 Test Data
unsigned char* sha224MsgBuffer = (unsigned char*)"\x1e\x3b\x6a\x3b\xdc\x28\x69\x2a\x91\xcb";
unsigned char* sha224DigestBuffer = (unsigned char*)"\x15\x11\x75\xc0\x02\x80\x87\x3a\x2a\xc1\x62\x8d\x84\x4b\x7b\x67\x42\xa0\x39\x2d\xc5\xbd\x3a\xa7\x2b\x31\xed\x0b";
size_t sha224DigestBufferLength = 28;
// SHA256 Test Data
unsigned char* sha256MsgBuffer = (unsigned char*)"\xbe\x3b\x88\x4a\x36\x46\x4d\x88\x14\x28";
unsigned char* sha256DigestBuffer = (unsigned char*)"\xb3\x34\x8a\x1a\x93\x23\xbe\xef\x01\x77\x47\x99\xa2\x46\xea\xd9\x4b\xd8\x97\x41\x54\x09\xc7\xec\x3f\xb1\xa4\x5c\x62\x89\x85\xaa";
size_t sha256DigestBufferLength = 32;
// SHA384 Test Data
unsigned char* sha384MsgBuffer = (unsigned char*)"\x23\xcb\xcb\x15\xc6\xb5\xd3\xe7\xcc\x6a";
unsigned char* sha384DigestBuffer = (unsigned char*)"\x83\x3d\xdc\xf2\xf2\x9e\x7e\x3c\x3f\x73\x16\xa2\xdc\x10\x8c\x83\x1f\xbd\x4f\x7b\x61\x59\x53\x0d\xa9\x63\x64\xc8\xcd\x9e\xcf\xbe\x98\x9d\x7e\x97\x4b\xed\xba\xa0\x03\xa8\x2e\xd7\x06\x0b\xb3\xc8";
size_t sha384DigestBufferLength = 48;
// SHA512 Test Data
unsigned char* sha512MsgBuffer = (unsigned char*)"\x44\xc8\x73\x00\x21\x13\x2b\x4a\x2b\x7e";
unsigned char* sha512DigestBuffer = (unsigned char*)"\xbd\x5c\xa4\x21\xe4\x85\x8d\x3f\x1e\x11\xdf\xfb\x27\x38\xb0\x54\x7f\xec\xdb\xc1\x66\x7c\xed\x6a\x69\x44\x9b\x69\xcd\xf9\xb3\x91\x29\x55\x78\xb3\x80\xab\xde\x52\x48\x96\x6a\xd0\x7a\xf9\x5c\x77\x70\x7c\xc1\x5f\xf9\x08\xf6\xef\xb5\x9e\xf7\xc2\x45\x95\x46\x02";
size_t sha512DigestBufferLength = 64;
uint8_t outputDigestBuffer[sha512DigestBufferLength];
memset(outputDigestBuffer, 0, sha512DigestBufferLength);
digest_test testToRun[] =
{
// SHA1
{sha1Impl, sha1MsgBuffer, shaDigestBuffer, sha1DigestBufferLength},
// SHA224
{sha224Impl, sha224MsgBuffer, sha224DigestBuffer, sha224DigestBufferLength},
// SHA356
{sha256Impl, sha256MsgBuffer, sha256DigestBuffer, sha256DigestBufferLength},
// SHA384
{sha384Impl, sha384MsgBuffer, sha384DigestBuffer, sha384DigestBufferLength},
// SHA512
{sha512Impl, sha512MsgBuffer, sha512DigestBuffer, sha512DigestBufferLength}
};
int numTestToRun = 5;
for (int iCnt = 0; iCnt < numTestToRun; iCnt++)
{
digest_test* currentTest = &(testToRun[iCnt]);
const struct ccdigest_info* di_ptr = currentTest->digest_info;
ccdigest(di_ptr, messageSize, currentTest->msgBuffer, outputDigestBuffer);
if (0 != memcmp(currentTest->digestBuffer, outputDigestBuffer, currentTest->digestBufferLength))
{
return result;
}
}
return 0;
}
