Exemplo n.º 1
0
static int test_answer(const struct ccdigest_info *di, test_vector *vector, void*answer) {
    uint8_t *correct_answer = NULL;
    if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_MD2)) correct_answer = vector->md2_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_MD4)) correct_answer = vector->md4_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_MD5)) correct_answer = vector->md5_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_SHA1)) correct_answer = vector->sha1_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_SHA224)) correct_answer = vector->sha224_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_SHA256)) correct_answer = vector->sha256_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_SHA384)) correct_answer = vector->sha384_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_SHA512)) correct_answer = vector->sha512_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_RMD128)) correct_answer = vector->rmd128_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_RMD160)) correct_answer = vector->rmd160_answer;
    else if(ccdigest_oid_equal(di, (ccoid_t) CC_DIGEST_OID_RMD256)) correct_answer = vector->rmd256_answer;
    else correct_answer = vector->rmd320_answer; // hack
    byteBuffer answer_bb = bytesToBytes(answer, di->output_size);
    if(correct_answer == NULL) {
        printByteBuffer(answer_bb, "Answer Provided");
        return 1;
    }
    byteBuffer correct_answer_bb = hexStringToBytes((char *) correct_answer);
    ok(bytesAreEqual(correct_answer_bb, answer_bb), "compare memory of answer");
    if(bytesAreEqual(correct_answer_bb, answer_bb) == 0) {
        printByteBuffer(correct_answer_bb, "Correct Answer");
        printByteBuffer(answer_bb, "Provided Answer");
    }
    free(correct_answer_bb);
    free(answer_bb);
    return 1;
}
Exemplo n.º 2
0
static int showBytesAreEqual(byteBuffer bb1, byteBuffer bb2, char *label) {
        ok(bytesAreEqual(bb1, bb2), label);
    if(bytesAreEqual(bb1, bb2) == 0) {
        printByteBuffer(bb1, "Want");
        printByteBuffer(bb2, "Got ");
        return 0;
    }
    return 1;
}
Exemplo n.º 3
0
static int testData()
{
    CCStatus status;
    char *hexstring = "1002030405060708090021222324252627282920";
    byteBuffer bb = hexStringToBytes(hexstring);
    CCBigNumRef num1 = CCBigNumFromData(&status, bb->bytes, bb->len);
    char *output;
    
    ok(status == 0, "BigNum Created");
    output = CCBigNumToHexString(&status, num1);
    ok(status == 0, "Value retrieved");
    ok(strcmp(output, hexstring) == 0, "strings are equal");
    if(strcmp(output, hexstring)) {
        printf("output: %s\n", output);
        printf("input : %s\n", hexstring);
    }
    free(output);
    
    byteBuffer outbuf = mallocByteBuffer(64);
    outbuf->len = CCBigNumToData(&status, num1, outbuf->bytes);
    ok(status == 0, "Value retrieved 2");
    
    ok(bytesAreEqual(bb, outbuf), "input == output");
    free(bb);
    free(outbuf);
    CCBigNumFree(num1);

    return 0;
    
}
Exemplo n.º 4
0
int CommonHKDF(int argc, char *const *argv)
{
	size_t i, n;
	int err;
	
	plan_tests(10 * 2);
		
	n = sizeof(hkdf_sha256_tests) / sizeof(*hkdf_sha256_tests);
	for(i = 0; i < n; ++i) {
		const test_vector_t *			tv   = &hkdf_sha256_tests[ i ];
		byteBuffer						ikm  = hexStringToBytes(tv->ikm);
		byteBuffer						salt = hexStringToBytes(tv->salt);
		byteBuffer						info = hexStringToBytes(tv->info);
		byteBuffer						okmActual = mallocByteBuffer(tv->len);
		byteBuffer						okmExpected = hexStringToBytes(tv->okm);
		CCDigestAlgorithm				digestType;
		
		if(     tv->type == type_sha1)   digestType = kCCDigestSHA1;
		else if(tv->type == type_sha256) digestType = kCCDigestSHA256;
		else if(tv->type == type_sha512) digestType = kCCDigestSHA512;
		else abort();
		
		err = CCKeyDerivationHMac(kCCKDFAlgorithmHKDF, digestType, 0, ikm->bytes, ikm->len, NULL, 0, 
			info->bytes, info->len, NULL, 0, salt->bytes, salt->len, okmActual->bytes, okmActual->len );
		ok(!err, "check return value");
		ok(bytesAreEqual(okmActual, okmExpected), "compare memory of answer");
		
		free(ikm);
		free(salt);
		free(info);
		free(okmActual);
		free(okmExpected);
	}
	return 0;
}
Exemplo n.º 5
0
static int test_answer(char *mode_name, test_vector *vector, void*answer, char *test_type) {
    byteBuffer answer_bb = bytesToBytes(answer, CMAC_BLOCKSIZE);
    if(vector->outStr == NULL) {
        diag("/* CMAC-128 test %d */", vector->cnt);
        diag("\t\t\"%s\",\n", bytesToHexString(answer_bb));
        return 1;
    }
    byteBuffer correct_answer_bb = hexStringToBytes((char *) vector->outStr);
    ok(bytesAreEqual(correct_answer_bb, answer_bb), "compare memory of answer");
    if(bytesAreEqual(correct_answer_bb, answer_bb) == 0) {
        diag("Failed Test (%d) for CMAC-128-%s %s\n", vector->cnt, mode_name, test_type);
        printByteBuffer(correct_answer_bb, "Correct Answer");
        printByteBuffer(answer_bb, "Provided Answer");
    }
    free(correct_answer_bb);
    free(answer_bb);
    return 1;
}
Exemplo n.º 6
0
int cchkdftest(TM_UNUSED int argc, TM_UNUSED char *const *argv) {
	size_t i, n;
	int err;
	
	plan_tests(10 * 2);
	
	if(verbose) diag("Starting hkdf tests\n");
	
	n = sizeof(hkdf_sha256_tests) / sizeof(*hkdf_sha256_tests);
	for(i = 0; i < n; ++i) {
		const test_vector_t *			tv   = &hkdf_sha256_tests[ i ];
		byteBuffer						ikm  = hexStringToBytes(tv->ikm);
		byteBuffer						salt = hexStringToBytes(tv->salt);
		byteBuffer						info = hexStringToBytes(tv->info);
		byteBuffer						okmActual = mallocByteBuffer(tv->len);
		byteBuffer						okmExpected = hexStringToBytes(tv->okm);
		const struct ccdigest_info *	di;
		
		if(     tv->type == type_sha1)   di = ccsha1_di();
		else if(tv->type == type_sha256) di = ccsha256_di();
		else if(tv->type == type_sha512) di = ccsha512_di();
		else abort();
		
		err = cchkdf(di, ikm->len, ikm->bytes, salt->len, salt->bytes, info->len, info->bytes, 
			okmActual->len, okmActual->bytes);
		ok(!err, "check return value");
		ok(bytesAreEqual(okmActual, okmExpected), "compare memory of answer");
		
		free(ikm);
		free(salt);
		free(info);
		free(okmActual);
		free(okmExpected);
	}
	return 0;
}
Exemplo n.º 7
0
int CommonEC(int argc, char *const *argv) {
	CCCryptorStatus retval;
    size_t keysize;
    CCECCryptorRef publicKey, privateKey;
    CCECCryptorRef publicKey2;
    // byteBuffer keydata, dekeydata;
    byteBuffer hash;
    char encryptedKey[8192];
    size_t encryptedKeyLen = 8192;
    // char decryptedKey[8192];
    // size_t decryptedKeyLen = 8192;
    char signature[8192];
    size_t signatureLen = 8192;
    char importexport[8192];
    size_t importexportLen = 8192;
    uint32_t valid;
    int accum = 0;
    int debug = 0;
    
	plan_tests(kTestTestCount);
    
    keysize = 256;
    
    retval = CCECCryptorGeneratePair(keysize, &publicKey, &privateKey);
    if(debug) printf("Keys Generated\n");
    ok(retval == 0, "Generate an EC Key Pair");
	accum |= retval;

#ifdef ECDH
    keydata = hexStringToBytes("000102030405060708090a0b0c0d0e0f");
    
    retval = CCECCryptorWrapKey(publicKey, keydata->bytes, keydata->len, encryptedKey, &encryptedKeyLen, kCCDigestSHA1);
    
    ok(retval == 0, "Wrap Key Data with EC Encryption - ccPKCS1Padding");
    accum |= retval;
    
    retval = CCECCryptorUnwrapKey(privateKey, encryptedKey, encryptedKeyLen,
                        decryptedKey, &decryptedKeyLen);
    
    ok(retval == 0, "Unwrap Key Data with EC Encryption - ccPKCS1Padding");
    accum |= retval;

	dekeydata = bytesToBytes(decryptedKey, decryptedKeyLen);
    
	ok(bytesAreEqual(dekeydata, keydata), "Round Trip CCECCryptorWrapKey/CCECCryptorUnwrapKey");
    accum |= retval;
#endif

    
    hash = hexStringToBytes("000102030405060708090a0b0c0d0e0f");

    retval = CCECCryptorSignHash(privateKey, 
                     hash->bytes, hash->len,
                     signature, &signatureLen);
                     
    ok(retval == 0, "EC Signing");
    valid = 0;
    accum |= retval;
    if(debug) printf("Signing Complete\n");
    
    retval = CCECCryptorVerifyHash(publicKey,
                       hash->bytes, hash->len, 
                       signature, signatureLen, &valid);
    ok(retval == 0, "EC Verifying");
    accum |= retval;
	ok(valid, "EC Validity");
    accum |= retval;
    if(debug) printf("Verify Complete\n");
   
    // Mess with the sig - see what happens
    signature[signatureLen-3] += 3;
    retval = CCECCryptorVerifyHash(publicKey,
                                   hash->bytes, hash->len, 
                                   signature, signatureLen, &valid);
    ok(retval == 0, "EC Verifying");
    accum |= retval;
	ok(!valid, "EC Invalid Signature");
    accum |= retval;
    
    if(debug) printf("Verify2 Complete\n");
    
    encryptedKeyLen = 8192;
	retval = CCECCryptorExportPublicKey(publicKey, importexport, &importexportLen);
    
    ok(retval == 0, "EC Export Public Key");
    accum |= retval;

    retval = CCECCryptorImportPublicKey(importexport, importexportLen, &publicKey2);
    
    ok(retval == 0, "EC Import Public Key");
    accum |= retval;
                          
	encryptedKeyLen = 8192;
    retval = CCECCryptorComputeSharedSecret(privateKey, publicKey, encryptedKey, &encryptedKeyLen);

    ok(retval == 0, "EC Shared Secret");
    accum |= retval;

    return accum;
}