1#include <stdio.h> 2#include "testbyteBuffer.h" 3#include "capabilities.h" 4#include "testmore.h" 5#include <string.h> 6 7#define COMMON_DIGEST_FOR_RFC_1321 8#include <CommonCrypto/CommonCryptor.h> 9#include <CommonCrypto/CommonDigest.h> 10#include <CommonCrypto/CommonHMAC.h> 11 12#ifdef CCDIGEST 13#include <CommonCrypto/CommonDigestSPI.h> 14#endif 15 16#ifdef CCKEYDERIVATION 17#include <CommonCrypto/CommonKeyDerivation.h> 18#endif 19 20static char *digestName(CCDigestAlgorithm digestSelector) { 21 switch(digestSelector) { 22 default: return "None"; 23 case kCCDigestMD2: return "MD2"; 24 case kCCDigestMD4: return "MD4"; 25 case kCCDigestMD5: return "MD5"; 26 case kCCDigestRMD128: return "RMD128"; 27 case kCCDigestRMD160: return "RMD160"; 28 case kCCDigestRMD256: return "RMD256"; 29 case kCCDigestRMD320: return "RMD320"; 30 case kCCDigestSHA1: return "SHA1"; 31 case kCCDigestSHA224: return "SHA224"; 32 case kCCDigestSHA256: return "SHA256"; 33 case kCCDigestSHA384: return "SHA384"; 34 case kCCDigestSHA512: return "SHA512"; 35 case kCCDigestSkein128: return "Skein128"; 36 case kCCDigestSkein160: return "Skein160"; 37 case kCCDigestSkein224: return "Skein224"; 38 case kCCDigestSkein256: return "Skein256"; 39 case kCCDigestSkein384: return "Skein384"; 40 case kCCDigestSkein512: return "Skein512"; 41 } 42} 43 44static size_t nullstrlen(const char *s) { 45 if(!s) return 0; 46 return strlen(s); 47} 48 49#define MAX_DIGEST_SIZE CC_SHA512_DIGEST_LENGTH 50 51#if (CCKEYDERIVATION == 1) 52static int 53PBKDF2Test(char *password, uint8_t *salt, size_t saltlen, int rounds, CCDigestAlgorithm PRF, int dklen, char *expected) 54{ 55 byteBuffer derivedKey; 56 byteBuffer expectedBytes; 57 char outbuf[80]; 58 int retval = 0; 59 60 if(expected) expectedBytes = hexStringToBytes(expected); 61 derivedKey = mallocByteBuffer(dklen); 62 switch(PRF) { 63 case 0: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), (uint8_t *) salt, saltlen, 0, rounds, derivedKey->bytes, derivedKey->len); break; 64 case kCCDigestSHA1: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA1, rounds, derivedKey->bytes, derivedKey->len); break; 65 case kCCDigestSHA224: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA224, rounds, derivedKey->bytes, derivedKey->len); break; 66 case kCCDigestSHA256: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA256, rounds, derivedKey->bytes, derivedKey->len); break; 67 case kCCDigestSHA384: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA384, rounds, derivedKey->bytes, derivedKey->len); break; 68 case kCCDigestSHA512: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA512, rounds, derivedKey->bytes, derivedKey->len); break; 69 default: return 1; 70 } 71 sprintf(outbuf, "PBKDF2-HMAC-%s test for %s", digestName(PRF), password); 72 73 if(expected) { 74 ok(bytesAreEqual(derivedKey, expectedBytes), outbuf); 75 76 if(!bytesAreEqual(derivedKey, expectedBytes)) { 77 diag("KEYDERIVE FAIL: PBKDF2-HMAC-%s(\"%s\")\n expected %s\n got %s\n", digestName(PRF), password, expected, bytesToHexString(derivedKey)); 78 retval = 1; 79 } else { 80 //printf("KEYDERIVE PASS: PBKDF2-HMAC-%s(\"%s\")\n", digestName(PRF), password); 81 } 82 free(expectedBytes); 83 } 84 free(derivedKey); 85 return retval; 86} 87#endif 88 89static byteBuffer mallocDigestBuffer(CCDigestAlgorithm digestSelector) { 90 size_t len; 91 switch(digestSelector) { 92 default: len = CCDigestGetOutputSize(digestSelector); break; 93 case kCCDigestMD2: len = CC_MD2_DIGEST_LENGTH; break; 94 case kCCDigestMD4: len = CC_MD4_DIGEST_LENGTH; break; 95 case kCCDigestMD5: len = CC_MD5_DIGEST_LENGTH; break; 96 case kCCDigestSHA1: len = CC_SHA1_DIGEST_LENGTH; break; 97 case kCCDigestSHA224: len = CC_SHA224_DIGEST_LENGTH; break; 98 case kCCDigestSHA256: len = CC_SHA256_DIGEST_LENGTH; break; 99 case kCCDigestSHA384: len = CC_SHA384_DIGEST_LENGTH; break; 100 case kCCDigestSHA512: len = CC_SHA512_DIGEST_LENGTH; break; 101 } 102 return mallocByteBuffer(len); 103} 104 105static void 106OneShotHmac(CCHmacAlgorithm hmacAlg, uint8_t *key, size_t keylen, const char *data, size_t datalen, uint8_t *output) 107{ 108 CCHmacContext ctx; 109 110 CCHmacInit(&ctx, hmacAlg, key, keylen); 111 CCHmacUpdate(&ctx, data, datalen); 112 CCHmacFinal(&ctx, output); 113} 114 115static int 116HMACTest(const char *input, char *keystr, CCDigestAlgorithm digestSelector, char *expected) 117{ 118 CCHmacAlgorithm hmacAlg; 119 size_t inputLen = nullstrlen(input); 120 char outbuf[80]; 121 int retval = 0; 122 123 byteBuffer expectedBytes = hexStringToBytes(expected); 124 byteBuffer keyBytes = hexStringToBytes(keystr); 125 byteBuffer mdBuf = mallocDigestBuffer(digestSelector); 126 switch(digestSelector) { 127 case kCCDigestMD5: hmacAlg = kCCHmacAlgMD5; break; 128 case kCCDigestSHA1: hmacAlg = kCCHmacAlgSHA1; break; 129 case kCCDigestSHA224: hmacAlg = kCCHmacAlgSHA224; break; 130 case kCCDigestSHA256: hmacAlg = kCCHmacAlgSHA256; break; 131 case kCCDigestSHA384: hmacAlg = kCCHmacAlgSHA384; break; 132 case kCCDigestSHA512: hmacAlg = kCCHmacAlgSHA512; break; 133 default: return 1; 134 } 135 CCHmac(hmacAlg, keyBytes->bytes, keyBytes->len, input, inputLen, mdBuf->bytes); 136 sprintf(outbuf, "Hmac-%s test for %s", digestName(digestSelector), input); 137 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 138 if(!bytesAreEqual(mdBuf, expectedBytes)) { 139 diag("HMAC FAIL: HMAC-%s(\"%s\")\n expected %s\n got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf)); 140 retval = 1; 141 } else { 142 // printf("HMAC PASS: HMAC-%s(\"%s\")\n", digestName(digestSelector), input); 143 } 144 OneShotHmac(hmacAlg, keyBytes->bytes, keyBytes->len, input, inputLen, mdBuf->bytes); 145 sprintf(outbuf, "Hmac-%s test for %s", digestName(digestSelector), input); 146 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 147 if(!bytesAreEqual(mdBuf, expectedBytes)) { 148 diag("HMAC FAIL: HMAC-%s(\"%s\")\n expected %s\n got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf)); 149 retval = 1; 150 } else { 151 //printf("HMAC PASS: HMAC-%s(\"%s\")\n", digestName(digestSelector), input); 152 } 153 free(mdBuf); 154 free(expectedBytes); 155 free(keyBytes); 156 return retval; 157} 158 159#if (CCDIGEST == 1) 160 161static void OneShotDigest(CCDigestAlgorithm algorithm, const uint8_t *bytesToDigest, size_t numbytes, uint8_t *outbuf) 162{ 163 CCDigestRef d; 164 *outbuf = 0; 165 if((d = CCDigestCreate(algorithm)) == NULL) return; 166 167 size_t fromAlg = CCDigestGetOutputSize(algorithm); 168 size_t fromRef = CCDigestGetOutputSizeFromRef(d); 169 size_t fromOldRoutine = CCDigestOutputSize(d); 170 171 ok(fromAlg == fromRef, "Size is the same from ref or alg"); 172 ok(fromAlg == fromOldRoutine, "Size is the same from ref or alg"); 173 if(CCDigestUpdate(d, bytesToDigest, numbytes)) return; 174 if(CCDigestFinal(d, outbuf)) return; 175 176 uint8_t dupBuf[fromRef]; 177 CCDigestReset(d); 178 if(CCDigestUpdate(d, bytesToDigest, numbytes)) return; 179 if(CCDigestFinal(d, dupBuf)) return; 180 ok(memcmp(outbuf, dupBuf, fromRef) == 0, "result should be the same from recycled context"); 181 182 CCDigestDestroy(d); 183 184} 185 186 187static int 188newHashTest(char *input, CCDigestAlgorithm digestSelector, char *expected) 189{ 190 size_t inputLen = nullstrlen(input); 191 char outbuf[4096]; 192 int retval = 0; 193 194 byteBuffer expectedBytes = hexStringToBytes(expected); 195 byteBuffer mdBuf = mallocByteBuffer(CCDigestGetOutputSize(digestSelector)); 196 197 CCDigest(digestSelector, (const uint8_t *) input, inputLen, mdBuf->bytes); 198 sprintf(outbuf, "new interface %s test for %s", digestName(digestSelector), input); 199 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 200 if(!bytesAreEqual(mdBuf, expectedBytes)) { 201 diag("Digestor FAIL: %s(\"%s\")\nexpected %s\ngot %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf)); 202 retval = 1; 203 } else { 204 // printf("Digestor PASS: %s(\"%s\")\n", digestName(digestSelector), input); 205 } 206 207 // printf("Digest is %s\n", digestName(digestSelector)); 208 OneShotDigest(digestSelector, (const uint8_t *) input, inputLen, mdBuf->bytes); 209 sprintf(outbuf, "composite interface %s test for %s", digestName(digestSelector), input); 210 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 211 if(!bytesAreEqual(mdBuf, expectedBytes)) { 212 diag("Digestor FAIL: %s(\"%s\")\nexpected %s\ngot %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf)); 213 retval = 1; 214 } else { 215 // printf("Digestor PASS: %s(\"%s\")\n", digestName(digestSelector), input); 216 } 217 218 free(mdBuf); 219 free(expectedBytes); 220 return retval; 221} 222 223static int 224unHashTest(CCDigestAlgorithm digestSelector) 225{ 226 char *buf[128]; 227 int retval; 228 CCDigestRef retref; 229 230 retval = CCDigest(digestSelector, (const uint8_t *) buf, 128, (uint8_t *) buf); 231 ok(retval == kCCUnimplemented, "Unsupported Digest returns kCCUnimplemented"); 232 retref = CCDigestCreate(digestSelector); 233 ok(retref == NULL, "Unsupported Digest returns NULL"); 234 return 0; 235} 236#endif 237 238#define CC_SHA224_CTX CC_SHA256_CTX 239#define CC_SHA384_CTX CC_SHA512_CTX 240#define OLD_ALL_IN_ONE_HASH(name,input,len,out) \ 241{ \ 242 CC_##name##_CTX ctx; \ 243 ok(CC_##name##_Init(&ctx) == 1, "Old Hash init should result in 1\n"); \ 244 ok(CC_##name##_Update(&ctx, input, len) == 1, "Old Hash update should result in 1\n"); \ 245 ok(CC_##name##_Final(out, &ctx) == 1, "Old Hash final should result in 1\n"); \ 246} \ 247break 248 249 250static int 251hashTest(char *input, CCDigestAlgorithm digestSelector, char *expected) 252{ 253 CC_LONG inputLen = (CC_LONG) nullstrlen(input); 254 char outbuf[4096]; 255 int retval = 0; 256 byteBuffer mdBuf = mallocDigestBuffer(digestSelector); 257 byteBuffer expectedBytes = hexStringToBytes(expected); 258 259 switch(digestSelector) { 260 case kCCDigestMD2: CC_MD2(input, inputLen, mdBuf->bytes); break; 261 case kCCDigestMD4: CC_MD4(input, inputLen, mdBuf->bytes); break; 262 case kCCDigestMD5: CC_MD5(input, inputLen, mdBuf->bytes); break; 263 case kCCDigestSHA1: CC_SHA1(input, inputLen, mdBuf->bytes); break; 264 case kCCDigestSHA224: CC_SHA224(input, inputLen, mdBuf->bytes); break; 265 case kCCDigestSHA256: CC_SHA256(input, inputLen, mdBuf->bytes); break; 266 case kCCDigestSHA384: CC_SHA384(input, inputLen, mdBuf->bytes); break; 267 case kCCDigestSHA512: CC_SHA512(input, inputLen, mdBuf->bytes); break; 268 default: return 1; 269 } 270 sprintf(outbuf, "Legacy %s test for %s", digestName(digestSelector), input); 271 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 272 273 if(!bytesAreEqual(mdBuf, expectedBytes)) { 274 diag("Legacy FAIL: %s(\"%s\") expected %s got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf)); 275 retval = 1; 276 } else { 277 // printf("Legacy PASS: %s(\"%s\")\n", digestName(digestSelector), input); 278 } 279 280 switch(digestSelector) { 281 case kCCDigestMD2: OLD_ALL_IN_ONE_HASH(MD2, input, inputLen, mdBuf->bytes); 282 case kCCDigestMD4: OLD_ALL_IN_ONE_HASH(MD4, input, inputLen, mdBuf->bytes); 283 case kCCDigestMD5: OLD_ALL_IN_ONE_HASH(MD5, input, inputLen, mdBuf->bytes); 284 case kCCDigestSHA1: OLD_ALL_IN_ONE_HASH(SHA1, input, inputLen, mdBuf->bytes); 285 case kCCDigestSHA224: OLD_ALL_IN_ONE_HASH(SHA224, input, inputLen, mdBuf->bytes); 286 case kCCDigestSHA256: OLD_ALL_IN_ONE_HASH(SHA256, input, inputLen, mdBuf->bytes); 287 case kCCDigestSHA384: OLD_ALL_IN_ONE_HASH(SHA384, input, inputLen, mdBuf->bytes); 288 case kCCDigestSHA512: OLD_ALL_IN_ONE_HASH(SHA512, input, inputLen, mdBuf->bytes); 289 default: return 1; 290 } 291 sprintf(outbuf, "Legacy %s test for %s", digestName(digestSelector), input); 292 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 293 294 if(!bytesAreEqual(mdBuf, expectedBytes)) { 295 diag("Legacy FAIL: %s(\"%s\") expected %s got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf)); 296 retval = 1; 297 } else { 298 // printf("Legacy PASS: %s(\"%s\")\n", digestName(digestSelector), input); 299 } 300 301 free(mdBuf); 302 free(expectedBytes); 303 return retval; 304} 305 306static int 307rfc1321Test(char *input, char *expected) 308{ 309 CC_LONG inputLen = (CC_LONG) nullstrlen(input); 310 char outbuf[80]; 311 int retval = 0; 312 MD5_CTX ctx; 313 byteBuffer expectedBytes = hexStringToBytes(expected); 314 byteBuffer mdBuf = mallocByteBuffer(CC_MD5_DIGEST_LENGTH); 315 316 MD5Init(&ctx); 317 MD5Update(&ctx, input, inputLen); 318 MD5Final(mdBuf->bytes, &ctx); 319 320 sprintf(outbuf, "Legacy MD5-1321 test for %s", input); 321 322 ok(bytesAreEqual(mdBuf, expectedBytes), outbuf); 323 324 if(!bytesAreEqual(mdBuf, expectedBytes)) { 325 diag("Legacy FAIL: MD5-1321(\"%s\") expected %s got %s\n", input, expected, bytesToHexString(mdBuf)); 326 retval = 1; 327 } else { 328 // printf("Legacy PASS: MD5-1321(\"%s\")\n", input); 329 } 330 free(mdBuf); 331 free(expectedBytes); 332 return retval; 333} 334 335 336static int kTestTestCount = 316; 337 338int CommonDigest(int argc, char *const *argv) { 339 char *strvalue, *keyvalue; 340 plan_tests(kTestTestCount); 341 int accum = 0; 342 343 /* strvalue of NULL and strvalue of "" must end up the same */ 344 strvalue = NULL; 345 accum |= hashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773"); 346 accum |= hashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0"); 347 accum |= hashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e"); 348 accum |= hashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); 349 accum |= hashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"); 350 accum |= hashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); 351 accum |= hashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); 352 accum |= hashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); 353#if (CCDIGEST == 1) 354 accum |= newHashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773"); 355 accum |= newHashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0"); 356 accum |= newHashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e"); 357 accum |= newHashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); 358 accum |= newHashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"); 359 accum |= newHashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); 360 accum |= newHashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); 361 accum |= newHashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); 362 accum |= newHashTest(strvalue, kCCDigestRMD128, "cdf26213a150dc3ecb610f18f6b38b46"); 363 accum |= newHashTest(strvalue, kCCDigestRMD160, "9c1185a5c5e9fc54612808977ee8f548b2258d31"); 364 accum |= newHashTest(strvalue, kCCDigestRMD256, "02ba4c4e5f8ecd1877fc52d64d30e37a2d9774fb1e5d026380ae0168e3c5522d"); 365 accum |= newHashTest(strvalue, kCCDigestRMD320, "22d65d5661536cdc75c1fdf5c6de7b41b9f27325ebc61e8557177d705a0ec880151c3a32a00899b8"); 366#else 367 diag("No Testing of the new Digest Interfaces\n"); 368#endif 369 370 strvalue = ""; 371 accum |= hashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773"); 372 accum |= hashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0"); 373 accum |= hashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e"); 374 accum |= hashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); 375 accum |= hashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"); 376 accum |= hashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); 377 accum |= hashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); 378 accum |= hashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); 379#if (CCDIGEST == 1) 380 accum |= newHashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773"); 381 accum |= newHashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0"); 382 accum |= newHashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e"); 383 accum |= newHashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); 384 accum |= newHashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"); 385 accum |= newHashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); 386 accum |= newHashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); 387 accum |= newHashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); 388 accum |= newHashTest(strvalue, kCCDigestRMD128, "cdf26213a150dc3ecb610f18f6b38b46"); 389 accum |= newHashTest(strvalue, kCCDigestRMD160, "9c1185a5c5e9fc54612808977ee8f548b2258d31"); 390 accum |= newHashTest(strvalue, kCCDigestRMD256, "02ba4c4e5f8ecd1877fc52d64d30e37a2d9774fb1e5d026380ae0168e3c5522d"); 391 accum |= newHashTest(strvalue, kCCDigestRMD320, "22d65d5661536cdc75c1fdf5c6de7b41b9f27325ebc61e8557177d705a0ec880151c3a32a00899b8"); 392#if defined(TESTSKEIN) 393 394 accum |= newHashTest(strvalue, kCCDigestSkein128, "030085a5c5e9fc54612808977ee8f548"); 395 accum |= newHashTest(strvalue, kCCDigestSkein160, "030085a5c5e9fc54612808977ee8f548b2258d31"); 396 accum |= newHashTest(strvalue, kCCDigestSkein224, "030085a5c5e9fc54612808977ee8f548b2258d31009b934ca495991b"); 397 accum |= newHashTest(strvalue, kCCDigestSkein256, "0900d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); 398 accum |= newHashTest(strvalue, kCCDigestSkein384, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); 399 accum |= newHashTest(strvalue, kCCDigestSkein512, "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); 400#else 401 accum |= unHashTest(kCCDigestSkein128); 402 accum |= unHashTest(kCCDigestSkein160); 403 accum |= unHashTest(kCCDigestSkein224); 404 accum |= unHashTest(kCCDigestSkein256); 405 accum |= unHashTest(kCCDigestSkein384); 406 accum |= unHashTest(kCCDigestSkein512); 407#endif 408#else 409 diag("No Testing of the new Digest Interfaces\n"); 410#endif 411 412 strvalue = "Test vector from febooti.com"; 413 accum |= hashTest(strvalue, kCCDigestMD2, "db128d6e0d20a1192a6bd1fade401150"); 414 accum |= hashTest(strvalue, kCCDigestMD4, "6578f2664bc56e0b5b3f85ed26ecc67b"); 415 accum |= hashTest(strvalue, kCCDigestMD5, "500ab6613c6db7fbd30c62f5ff573d0f"); 416 accum |= hashTest(strvalue, kCCDigestSHA1, "a7631795f6d59cd6d14ebd0058a6394a4b93d868"); 417 accum |= hashTest(strvalue, kCCDigestSHA224, "3628b402254caa96827e3c79c0a559e4558da8ee2b65f1496578137d"); 418 accum |= hashTest(strvalue, kCCDigestSHA256, "077b18fe29036ada4890bdec192186e10678597a67880290521df70df4bac9ab"); 419 accum |= hashTest(strvalue, kCCDigestSHA384, "388bb2d487de48740f45fcb44152b0b665428c49def1aaf7c7f09a40c10aff1cd7c3fe3325193c4dd35d4eaa032f49b0"); 420 accum |= hashTest(strvalue, kCCDigestSHA512, "09fb898bc97319a243a63f6971747f8e102481fb8d5346c55cb44855adc2e0e98f304e552b0db1d4eeba8a5c8779f6a3010f0e1a2beb5b9547a13b6edca11e8a"); 421 accum |= rfc1321Test(strvalue, "500ab6613c6db7fbd30c62f5ff573d0f"); 422 423 424#if (CCDIGEST == 1) 425 accum |= newHashTest(strvalue, kCCDigestMD2, "db128d6e0d20a1192a6bd1fade401150"); 426 accum |= newHashTest(strvalue, kCCDigestMD4, "6578f2664bc56e0b5b3f85ed26ecc67b"); 427 accum |= newHashTest(strvalue, kCCDigestMD5, "500ab6613c6db7fbd30c62f5ff573d0f"); 428 accum |= newHashTest(strvalue, kCCDigestSHA1, "a7631795f6d59cd6d14ebd0058a6394a4b93d868"); 429 accum |= newHashTest(strvalue, kCCDigestSHA224, "3628b402254caa96827e3c79c0a559e4558da8ee2b65f1496578137d"); 430 accum |= newHashTest(strvalue, kCCDigestSHA256, "077b18fe29036ada4890bdec192186e10678597a67880290521df70df4bac9ab"); 431 accum |= newHashTest(strvalue, kCCDigestSHA384, "388bb2d487de48740f45fcb44152b0b665428c49def1aaf7c7f09a40c10aff1cd7c3fe3325193c4dd35d4eaa032f49b0"); 432 accum |= newHashTest(strvalue, kCCDigestSHA512, "09fb898bc97319a243a63f6971747f8e102481fb8d5346c55cb44855adc2e0e98f304e552b0db1d4eeba8a5c8779f6a3010f0e1a2beb5b9547a13b6edca11e8a"); 433#if defined(TESTSKEIN) 434 accum |= newHashTest(strvalue, kCCDigestSkein128, "03000000000000700000000000000070"); 435 accum |= newHashTest(strvalue, kCCDigestSkein160, "0300000000000070000000000000007000000000"); 436 accum |= newHashTest(strvalue, kCCDigestSkein224, "030000000000007000000000000000700000000000000070ca030210"); 437 accum |= newHashTest(strvalue, kCCDigestSkein256, "0000000000000000000000000000000000000000000000000000000000000000"); 438 accum |= newHashTest(strvalue, kCCDigestSkein384, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); 439 accum |= newHashTest(strvalue, kCCDigestSkein512, "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); 440#endif 441 442#else 443 diag("No Testing of the new Digest Interfaces\n"); 444#endif 445 446 // Test Case 1 http://www.faqs.org/rfcs/rfc4231.html 447 strvalue = "Hi There"; 448 keyvalue = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"; 449 accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA224, "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22"); 450 accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA256, "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"); 451 accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA384, "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6"); 452 accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA512, "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854"); 453 // Test Vector from http://www.faqs.org/rfcs/rfc2104.html 454 keyvalue = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"; 455 accum |= HMACTest(strvalue, keyvalue, kCCDigestMD5, "9294727a3638bb1c13f48ef8158bfc9d"); 456 457#if (CCKEYDERIVATION == 1) 458 // Test Case PBKDF2 - HMACSHA1 http://tools.ietf.org/html/draft-josefsson-pbkdf2-test-vectors-00 459 accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 1, kCCDigestSHA1, 20, "0c60c80f961f0e71f3a9b524af6012062fe037a6"); 460 accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 2, kCCDigestSHA1, 20, "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"); 461 accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 4096, kCCDigestSHA1, 20, "4b007901b765489abead49d926f721d065a429c1"); 462 463 // This crashes 464 accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 1, 0, 20, NULL); 465#else 466 diag("No Key Derivation Support Testing\n"); 467#endif 468 469 // Test from <rdar://problem/11285435> CC_SHA512_Init(),CC_SHA512_Update(),CC_SHA512_Final() gives wrong digest 470 strvalue = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"; 471 accum |= hashTest(strvalue, kCCDigestSHA512, "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"); 472 accum |= newHashTest(strvalue, kCCDigestSHA512, "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"); 473 474 return accum; 475 476} 477