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;
}
byteBuffer
bytesToBytes(void *bytes, size_t len)
{
byteBuffer retval = mallocByteBuffer(len);
if(retval && bytes) memcpy(retval->bytes, bytes, len);
return retval;
}
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;
}
/* Convert a string of characters representing a hex buffer into a series of bytes of that real value */
byteBuffer
hexStringToBytes(char *inhex)
{
byteBuffer retval;
uint8_t *p;
int len, i;
len = (int) strlen(inhex) / 2;
if((retval = mallocByteBuffer(len)) == NULL) return NULL;
for(i=0, p = (uint8_t *) inhex; i<len; i++) {
retval->bytes[i] = (nibbleFromChar(*p) << 4) | nibbleFromChar(*(p+1));
p += 2;
}
retval->bytes[len] = 0;
return retval;
}
byteBuffer
genRandomByteBuffer(size_t minSize, size_t maxSize)
{
byteBuffer retval;
size_t randomInt;
CCCryptorStatus err;
randomInt = genRandomSize(minSize, maxSize);
retval = mallocByteBuffer(randomInt);
if(retval == NULL) return NULL;
if(retval->len != randomInt) return NULL;
bzero(retval->bytes, retval->len);
// fill bytes randomly
while((err = CCRandomCopyBytes(kCCRandomDefault, retval->bytes, retval->len)) != kCCSuccess) {
printf("got %d from CCRandomCopyBytes\n", err);
}
return retval;
}
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;
}
static int tests_rng(const char *seed) {
byteBuffer entropyBuffer;
int status=-1; // Allocation error;
if (seed==NULL || strlen(seed)<=0) {
// If the seed is not in the argument, we generate one
struct ccrng_system_state system_rng;
size_t entropy_size=16; // Default size of the seed
cc_require((entropyBuffer=mallocByteBuffer(entropy_size))!=NULL,errOut);
cc_require((status=ccrng_system_init(&system_rng))==0, errOut);
cc_require((status=ccrng_generate((struct ccrng_state *)&system_rng, entropyBuffer->len, entropyBuffer->bytes))==0, errOut);
ccrng_system_done(&system_rng);
cc_print("random seed value:",entropyBuffer->len,entropyBuffer->bytes);
} else {
// Otherwise, take the value from the arguments
entropyBuffer = hexStringToBytes(seed);
cc_print("input seed value:",entropyBuffer->len,entropyBuffer->bytes);
}
cc_require((status=ccrng_test_init(&test_rng, entropyBuffer->len,entropyBuffer->bytes))==0, errOut);
return status;
errOut:
printf("Error initializing test rng: %d\n",status);
return -1;
}
