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; }