/*
 *  CCCryptorTestFuncs.c
 *  CCRegressions
 *
 *
 */


#include <stdio.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"


CCCryptorStatus
CCCryptWithMode(CCOperation op, CCMode mode, CCAlgorithm alg, CCPadding padding, const void *iv, 
				const void *key, size_t keyLength, const void *tweak, size_t tweakLength,
                int numRounds, CCModeOptions options,
                const void *dataIn, size_t dataInLength, 
                void *dataOut, size_t dataOutAvailable, size_t *dataOutMoved)
#ifdef CRYPTORWITHMODE
{
    CCCryptorRef cref;
	CCCryptorStatus retval;
    size_t moved;

   	if((retval = CCCryptorCreateWithMode(op, mode, alg, padding, iv, key, keyLength, tweak, tweakLength, numRounds, options, &cref)) != kCCSuccess) {
    	return retval;
    }
    
    if((retval = CCCryptorUpdate(cref, dataIn, dataInLength, dataOut, dataOutAvailable, &moved)) != kCCSuccess) {
    	return retval;
    }
    
    dataOut += moved;
    dataOutAvailable -= moved;
    *dataOutMoved = moved;
    
    if((retval = CCCryptorFinal(cref, dataOut, dataOutAvailable, &moved)) != kCCSuccess) {
    	return retval;
    }
    
    *dataOutMoved += moved;

	CCCryptorRelease(cref);
    
    return kCCSuccess;
}
#else
{
    return kCCSuccess;
}
#endif



CCCryptorStatus 
CCMultiCrypt(CCOperation op, CCAlgorithm alg, CCOptions options, const void *key, size_t keyLength, const void *iv, const void *dataIn, size_t dataInLength,
	void *dataOut, size_t dataOutAvailable, size_t *dataOutMoved)
{
	CCCryptorRef cref;
    CCCryptorStatus retval;
    size_t p1, p2;
    size_t newmoved;
    size_t finalSize;
    
    retval = CCCryptorCreate(op, alg, options, key, keyLength, iv, &cref);
    if(retval != kCCSuccess) {
    	diag("Cryptor Create Failed\n");
    	return retval;
    }
    p1 = ( dataInLength / 16 ) * 16 - 1;
    if(p1 > 16) p1 = dataInLength;
    p2 = dataInLength - p1;
    // diag("Processing length %d  in two parts %d and %d\n", (int) dataInLength, (int) p1, (int) p2);
    
    *dataOutMoved = 0;
    
    if(p1) {
    	retval = CCCryptorUpdate(cref, dataIn, p1, dataOut, dataOutAvailable, dataOutMoved);
        if(retval) {
        	diag("P1 - Tried to move %d - failed retval = %d\n", (int) p1, (int) retval);
            return retval;
        }
        dataIn += p1;
        dataOut += *dataOutMoved;
        dataOutAvailable -= *dataOutMoved;        
    }
    if(p2) {
        
    	retval = CCCryptorUpdate(cref, dataIn, p2, dataOut, dataOutAvailable, &newmoved);
        if(retval) {
        	diag("P2 - Tried to move %d - failed\n", (int) p2);
            return retval;
        }
        dataIn += p2;
        dataOut += newmoved;        
        dataOutAvailable -= newmoved;
        *dataOutMoved += newmoved;
    }
    
    /* We've had reports that Final fails on some platforms if it's only cipher blocksize.  */
    switch(alg) {
    case kCCAlgorithmDES: /* fallthrough */
    case kCCAlgorithm3DES: finalSize = kCCBlockSizeDES; break;
    case kCCAlgorithmAES128: finalSize = kCCBlockSizeAES128; break;
    case kCCAlgorithmCAST: finalSize = kCCBlockSizeCAST; break;
    case kCCAlgorithmRC2: finalSize = kCCBlockSizeRC2; break;
    default: finalSize = dataOutAvailable;
    }
    
    retval = CCCryptorFinal(cref, dataOut, finalSize, &newmoved);
    if(retval) {
        diag("Final - failed %d\n", (int) retval);
        return retval;
    }
    retval = CCCryptorRelease(cref);
    if(retval) {
        diag("Final - release failed %d\n", (int) retval);
        return retval;
    }
    *dataOutMoved += newmoved;
    return kCCSuccess;
    
    
}

CCCryptorStatus 
CCMultiCryptWithMode(CCOperation op, CCMode mode, CCAlgorithm alg, CCPadding padding, const void *iv, 
	const void *key, size_t keyLength, const void *tweak, size_t tweakLength,
	int numRounds, CCModeOptions options,
    const void *dataIn, size_t dataInLength,
	void *dataOut, size_t dataOutAvailable, size_t *dataOutMoved)
#ifdef CRYPTORWITHMODE
{
	CCCryptorRef cref;
    CCCryptorStatus retval;
    size_t p1, p2;
    size_t newmoved;
    
   	if((retval = CCCryptorCreateWithMode(op, mode, alg, padding, iv, key, keyLength, tweak, tweakLength, numRounds, options, &cref)) != kCCSuccess) {
    	return retval;
    }
    p1 = ( dataInLength / 16 ) * 16 - 1;
    if(p1 > 16) p1 = dataInLength;
    p2 = dataInLength - p1;
    // diag("Processing length %d  in two parts %d and %d\n", (int) dataInLength, (int) p1, (int) p2);
    
    *dataOutMoved = 0;
    
    if(p1) {
    	retval = CCCryptorUpdate(cref, dataIn, p1, dataOut, dataOutAvailable, dataOutMoved);
        if(retval) {
        	diag("P1 - Tried to move %d - failed retval = %d\n", (int) p1, (int) retval);
            return retval;
        }
        dataIn += p1;
        dataOut += *dataOutMoved;
        dataOutAvailable -= *dataOutMoved;        
    }
    if(p2) {
        
    	retval = CCCryptorUpdate(cref, dataIn, p2, dataOut, dataOutAvailable, &newmoved);
        if(retval) {
        	diag("P2 - Tried to move %d - failed\n", (int) p2);
            return retval;
        }
        dataIn += p2;
        dataOut += newmoved;        
        dataOutAvailable -= newmoved;
        *dataOutMoved += newmoved;
    }
    retval = CCCryptorFinal(cref, dataOut, dataOutAvailable, &newmoved);
    if(retval) {
        diag("Final - failed %d\n", (int) retval);
        return retval;
    }
    retval = CCCryptorRelease(cref);
    if(retval) {
        diag("Final - release failed %d\n", (int) retval);
        return retval;
    }
    *dataOutMoved += newmoved;
    return kCCSuccess;
}
#else
{
    return kCCSuccess;
}
#endif


static byteBuffer
ccConditionalTextBuffer(char *inputText)
{
	byteBuffer ret;
    
    if(inputText) ret = hexStringToBytes(inputText);
    else {
    	ret = hexStringToBytes("");
        ret->bytes = NULL;
    }
    return ret;
}

int
CCCryptTestCase(char *keyStr, char *ivStr, CCAlgorithm alg, CCOptions options, char *cipherText, char *plainText)
{
    byteBuffer key, iv;
    byteBuffer pt, ct;
    
    
	CCCryptorStatus retval;
    char cipherDataOut[4096];
    char plainDataOut[4096];
    size_t dataOutMoved;
    byteBuffer bb;
            
    key = hexStringToBytes(keyStr);        
    pt = ccConditionalTextBuffer(plainText);
    ct = ccConditionalTextBuffer(cipherText);
    iv = ccConditionalTextBuffer(ivStr);
    
        
    if((retval = CCCrypt(kCCEncrypt, alg, options, key->bytes, key->len, iv->bytes, pt->bytes, pt->len, cipherDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Encrypt Failed %d\n", retval);
        return 1;
    }
    
    bb = bytesToBytes(cipherDataOut, dataOutMoved);    	

    // If ct isn't defined we're gathering data - print the ciphertext result
    if(!ct->bytes) {
    	diag("Input Length %d Result: %s\n", (int) pt->len, bytesToHexString(bb));
    } else {
        if (!bytesAreEqual(ct, bb)) {
            diag("FAIL Encrypt Output %s\nEncrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(ct));
        	return 1;
        }
    }
    
    free(bb);
    
    if((retval = CCCrypt(kCCDecrypt, alg, options, key->bytes, key->len, iv->bytes, cipherDataOut, dataOutMoved, plainDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Decrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(plainDataOut, dataOutMoved);
    
	if (!bytesAreEqual(pt, bb)) {
        diag("FAIL Decrypt Output %s\nDecrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(pt));
        return 1;
    }
    
    // if(ct->bytes && iv->bytes) diag("PASS Test for length %d\n", (int) pt->len);
    // if(ct && (iv->bytes == NULL)) diag("PASS NULL IV Test for length %d\n", (int) pt->len);

    free(pt);
    free(ct);
    free(key);
    free(iv);
	return 0;
}




int
CCMultiCryptTestCase(char *keyStr, char *ivStr, CCAlgorithm alg, CCOptions options, char *cipherText, char *plainText)
{
    byteBuffer key, iv;
    byteBuffer pt, ct;
    
    
	CCCryptorStatus retval;
    char cipherDataOut[4096];
    char plainDataOut[4096];
    size_t dataOutMoved;
    byteBuffer bb;
            
    key = hexStringToBytes(keyStr);        
    pt = ccConditionalTextBuffer(plainText);
    ct = ccConditionalTextBuffer(cipherText);
    iv = ccConditionalTextBuffer(ivStr);
    
        
    if((retval = CCMultiCrypt(kCCEncrypt, alg, options, key->bytes, key->len, iv->bytes, pt->bytes, pt->len, cipherDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Encrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(cipherDataOut, dataOutMoved);    	

    // If ct isn't defined we're gathering data - print the ciphertext result
    if(!ct->bytes) {
    	diag("Input Length %d Result: %s\n", (int) pt->len, bytesToHexString(bb));
    } else {
        if (!bytesAreEqual(ct, bb)) {
            diag("FAIL Encrypt Output %s\nEncrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(ct));
        	return 1;
        }
    }
    
    free(bb);
    
    if((retval = CCMultiCrypt(kCCDecrypt, alg, options, key->bytes, key->len, iv->bytes, cipherDataOut, dataOutMoved, plainDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Decrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(plainDataOut, dataOutMoved);
    
	if (!bytesAreEqual(pt, bb)) {
        diag("FAIL Decrypt Output %s\nDecrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(pt));
        return 1;
    }
    
    // if(ct && iv->bytes) diag("PASS Test for length %d\n", (int) pt->len);
    // if(ct && (iv->bytes == NULL)) diag("PASS NULL IV Test for length %d\n", (int) pt->len);

    free(pt);
    free(ct);
    free(key);
    free(iv);
	return 0;
}




int
CCModeTestCase(char *keyStr, char *ivStr, CCMode mode, CCAlgorithm alg, CCPadding padding, char *cipherText, char *plainText)
#ifdef CRYPTORWITHMODE
{
    byteBuffer key, iv;
    byteBuffer pt, ct;
    
	CCCryptorStatus retval;
    char cipherDataOut[4096];
    char plainDataOut[4096];
    size_t dataOutMoved;
    byteBuffer bb;
            
    key = hexStringToBytes(keyStr);        
    pt = ccConditionalTextBuffer(plainText);
    ct = ccConditionalTextBuffer(cipherText);
    iv = ccConditionalTextBuffer(ivStr);
    
   	if((retval = CCCryptWithMode(kCCEncrypt, mode, alg, padding, iv->bytes, key->bytes, key->len, NULL, 0, 0, 0,  pt->bytes, pt->len, 
            cipherDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Encrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(cipherDataOut, dataOutMoved);    	

    // If ct isn't defined we're gathering data - print the ciphertext result
    if(!ct->bytes) {
    	diag("Input Length %d Result: %s\n", (int) pt->len, bytesToHexString(bb));
    } else {
        if (!bytesAreEqual(ct, bb)) {
            diag("FAIL\nEncrypt Output %s\nEncrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(ct));
        	return 1;
        }
    }
    
    free(bb);
    
   	if((retval = CCCryptWithMode(kCCDecrypt, mode, alg, padding, iv->bytes, key->bytes, key->len, NULL, 0, 0, 0,  cipherDataOut, dataOutMoved, 
        plainDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Decrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(plainDataOut, dataOutMoved);
    
	if (!bytesAreEqual(pt, bb)) {
        diag("FAIL Decrypt Output %s\nDecrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(pt));
        return 1;
    }
    
    // if(ct->bytes && iv->bytes) diag("PASS Test for length %d\n", (int) pt->len);
    // if(ct->bytes && (iv->bytes == NULL)) diag("PASS NULL IV Test for length %d\n", (int) pt->len);

    free(pt);
    free(ct);
    free(key);
    free(iv);
	return 0;
}
#else
{
    return 0;
}
#endif




int
CCMultiModeTestCase(char *keyStr, char *ivStr, CCMode mode, CCAlgorithm alg, CCPadding padding, char *cipherText, char *plainText)
#ifdef CRYPTORWITHMODE
{
    byteBuffer key, iv;
    byteBuffer pt, ct;    
	CCCryptorStatus retval;
    char cipherDataOut[4096];
    char plainDataOut[4096];
    size_t dataOutMoved;
    byteBuffer bb;
            
    key = hexStringToBytes(keyStr);        
    pt = ccConditionalTextBuffer(plainText);
    ct = ccConditionalTextBuffer(cipherText);
    iv = ccConditionalTextBuffer(ivStr);
    
   	if((retval = CCMultiCryptWithMode(kCCEncrypt, mode, alg, padding, iv->bytes,key->bytes, key->len, NULL, 0,0, 0, pt->bytes, pt->len, 
            cipherDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Encrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(cipherDataOut, dataOutMoved);    	

    // If ct isn't defined we're gathering data - print the ciphertext result
    if(!ct->bytes) {
    	diag("Input Length %d Result: %s\n", (int) pt->len, bytesToHexString(bb));
    } else {
        if (!bytesAreEqual(ct, bb)) {
            diag("FAIL\nEncrypt Output %s\nEncrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(ct));
        	return 1;
        }
    }
    
    free(bb);
    
   	if((retval = CCMultiCryptWithMode(kCCEncrypt, mode, alg, padding, iv->bytes, key->bytes, key->len, NULL, 0, 0, 0, 
        cipherDataOut, dataOutMoved, plainDataOut, 4096, &dataOutMoved)) != kCCSuccess) {
    	diag("Decrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(plainDataOut, dataOutMoved);
    
	if (!bytesAreEqual(pt, bb)) {
        diag("FAIL Decrypt Output %s\nDecrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(pt));
        return 1;
    }
    
    // if(ct && iv->bytes) diag("PASS Test for length %d\n", (int) pt->len);
    // if(ct && (iv->bytes == NULL)) diag("PASS NULL IV Test for length %d\n", (int) pt->len);

    free(pt);
    free(ct);
    free(key);
    free(iv);
	return 0;
}
#else
{
    return kCCSuccess;
}
#endif

#ifdef CCSYMGCM

static CCCryptorStatus 
CCCryptorGCMDiscreet(
	CCOperation 	op,				/* kCCEncrypt, kCCDecrypt */
	CCAlgorithm		alg,
	const void 		*key,			/* raw key material */
	size_t 			keyLength,	
	const void 		*iv,
	size_t 			ivLen,
	const void 		*aData,
	size_t 			aDataLen,
	const void 		*dataIn,
	size_t 			dataInLength,
  	void 			*dataOut,
	const void 		*tag,
	size_t 			*tagLength)
{
    CCCryptorStatus retval;
    CCCryptorRef    cref;
    
    retval = CCCryptorCreateWithMode(op, kCCModeGCM, alg, ccNoPadding, NULL, key, keyLength, NULL, 0, 0, 0, &cref);
    if(retval != kCCSuccess) return retval;
    
    retval = CCCryptorGCMAddIV(cref, iv, ivLen);
    if(retval != kCCSuccess) {
        printf("Failed to add IV\n");
        goto out;
    }
    
    retval = CCCryptorGCMaddAAD(cref, aData, aDataLen);
    if(retval != kCCSuccess) {
        printf("Failed to add ADD\n");
        goto out;
    }


    if(kCCEncrypt == op) {
        retval = CCCryptorGCMEncrypt(cref, dataIn, dataInLength, dataOut);
        if(retval != kCCSuccess) {
            printf("Failed to Encrypt\n");
            goto out;
        }
    } else {
        retval = CCCryptorGCMDecrypt(cref, dataIn, dataInLength, dataOut);
        if(retval != kCCSuccess) {
            printf("Failed to Decrypt\n");
            goto out;
        }
    }


    retval = CCCryptorGCMFinal(cref, tag, tagLength);
    if(retval != kCCSuccess) {
        printf("Failed to Finalize and get tag\n");
        goto out;
    }
    retval = CCCryptorGCMReset(cref);
    if(retval != kCCSuccess) {
        printf("Failed to Reset\n");
    }
    
    
out:

    CCCryptorRelease(cref);
    return retval;
}


int
CCCryptorGCMTestCase(char *keyStr, char *ivStr, char *aDataStr, char *tagStr, CCAlgorithm alg, char *cipherText, char *plainText)
{
    byteBuffer key, iv;
    byteBuffer pt, ct;
    byteBuffer adata, tag;
    byteBuffer bb;
    
    
	CCCryptorStatus retval;
    char cipherDataOut[4096];
    char plainDataOut[4096];
    char tagDataOut[4096];
    size_t tagDataOutlen;
    size_t  dataLen;
    

    key = hexStringToBytes(keyStr);        
    adata = ccConditionalTextBuffer(aDataStr);        
    tag = hexStringToBytes(tagStr);        
    pt = ccConditionalTextBuffer(plainText);
    ct = ccConditionalTextBuffer(cipherText);
    iv = ccConditionalTextBuffer(ivStr);
    
    dataLen = pt->len;
    
    tagDataOutlen = tag->len;
    memset(tagDataOut, 0, 16);
    if((retval = CCCryptorGCM(kCCEncrypt, alg, key->bytes, key->len, iv->bytes, iv->len, adata->bytes, adata->len, pt->bytes, dataLen, cipherDataOut, tagDataOut, &tagDataOutlen)) != kCCSuccess) {
    	diag("Encrypt Failed\n");
        return 1;
    }
        
    bb = bytesToBytes(cipherDataOut, dataLen);    	

    // If ct isn't defined we're gathering data - print the ciphertext result
    if(!ct->bytes) {
    	diag("Input Length %d Result: %s\n", (int) dataLen, bytesToHexString(bb));
    } else {
        if (!bytesAreEqual(ct, bb)) {
            diag("FAIL Encrypt Output %s\nEncrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(ct));
        	return 1;
        }
    }
    
    free(bb);
#if NEVER    
    bb = bytesToBytes(tagDataOut, tagDataOutlen);
    if (!bytesAreEqual(tag, bb)) {
        diag("FAIL Tag on plaintext is wrong\n       got %s\n  expected %s\n", bytesToHexString(bb), bytesToHexString(tag));
        return 1;
    }
#endif
    
    tagDataOutlen = tag->len;
    memset(tagDataOut, 0, 16);
    if((retval = CCCryptorGCM(kCCDecrypt, alg, key->bytes, key->len, iv->bytes, iv->len, adata->bytes, adata->len, cipherDataOut, dataLen, plainDataOut, tagDataOut, &tagDataOutlen)) != kCCSuccess) {
    	diag("Decrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(plainDataOut, dataLen);
    
	if (!bytesAreEqual(pt, bb)) {
        diag("FAIL Decrypt Output %s\nDecrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(pt));
        return 1;
    }
    
    free(bb);
    
    bb = bytesToBytes(tagDataOut, tagDataOutlen);
    if (!bytesAreEqual(tag, bb)) {
        diag("FAIL Tag on ciphertext is wrong\n       got %s\n  expected %s\n", bytesToHexString(bb), bytesToHexString(tag));
        return 1;
    }
    
    free(bb);
    free(pt);
    free(ct);
    free(key);
    free(iv);
    // diag("Pass One-Shot GCM Test\n");
	return 0;
}

int
CCCryptorGCMDiscreetTestCase(char *keyStr, char *ivStr, char *aDataStr, char *tagStr, CCAlgorithm alg, char *cipherText, char *plainText)
{
    byteBuffer key, iv;
    byteBuffer pt, ct;
    byteBuffer adata, tag;
    byteBuffer bb;
    
    
	CCCryptorStatus retval;
    char cipherDataOut[4096];
    char plainDataOut[4096];
    char tagDataOut[4096];
    size_t tagDataOutlen;
    size_t  dataLen;
    

    key = hexStringToBytes(keyStr);        
    adata = ccConditionalTextBuffer(aDataStr);        
    tag = hexStringToBytes(tagStr);        
    pt = ccConditionalTextBuffer(plainText);
    ct = ccConditionalTextBuffer(cipherText);
    iv = ccConditionalTextBuffer(ivStr);
    
    dataLen = pt->len;
    
    tagDataOutlen = tag->len;
    memset(tagDataOut, 0, 4096);
    if((retval = CCCryptorGCMDiscreet(kCCEncrypt, alg, key->bytes, key->len, iv->bytes, iv->len, adata->bytes, adata->len, pt->bytes, dataLen, cipherDataOut, tagDataOut, &tagDataOutlen)) != kCCSuccess) {
    	diag("Encrypt Failed\n");
        return 1;
    }
        
    bb = bytesToBytes(cipherDataOut, dataLen);    	

    // If ct isn't defined we're gathering data - print the ciphertext result
    if(!ct->bytes) {
    	diag("Input Length %d Result: %s\n", (int) dataLen, bytesToHexString(bb));
    } else {
        if (!bytesAreEqual(ct, bb)) {
            diag("FAIL Encrypt Output %s\nEncrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(ct));
        	return 1;
        }
    }
    
    free(bb);

#ifdef NEVER
    bb = bytesToBytes(tagDataOut, tagDataOutlen);
    if (!bytesAreEqual(tag, bb)) {
        diag("FAIL Tag on plaintext is wrong\n       got %s\n  expected %s\n", bytesToHexString(bb), bytesToHexString(tag));
        return 1;
    }
#endif
    
    tagDataOutlen = tag->len;
    memset(tagDataOut, 0, 4096);
    if((retval = CCCryptorGCMDiscreet(kCCDecrypt, alg, key->bytes, key->len, iv->bytes, iv->len, adata->bytes, adata->len, cipherDataOut, dataLen, plainDataOut, tagDataOut, &tagDataOutlen)) != kCCSuccess) {
    	diag("Decrypt Failed\n");
        return 1;
    }
    
    bb = bytesToBytes(plainDataOut, dataLen);
    
	if (!bytesAreEqual(pt, bb)) {
        diag("FAIL Decrypt Output %s\nDecrypt Expect %s\n", bytesToHexString(bb), bytesToHexString(pt));
        return 1;
    }
    
    free(bb);
    
    bb = bytesToBytes(tagDataOut, tagDataOutlen);
    if (!bytesAreEqual(tag, bb)) {
        diag("FAIL Tag on ciphertext is wrong\n       got %s\n  expected %s\n", bytesToHexString(bb), bytesToHexString(tag));
        return 1;
    }
    
    free(bb);
    free(pt);
    free(ct);
    free(key);
    free(iv);
    // diag("Pass Discreet GCM Test\n");

	return 0;
}

#endif

/*
 *  CCCryptorTestFuncs.h
 *  CCRegressions
 *
 *
 */

#include "capabilities.h"
#include <CommonCrypto/CommonCryptor.h>
#ifdef CRYPTORWITHMODE
#include <CommonCrypto/CommonCryptorSPI.h>
#else
typedef uint32_t CCMode;
typedef uint32_t CCPadding;
typedef uint32_t CCModeOptions;
#endif

/* This is a CCCrypt with the Updates split into two parts */

CCCryptorStatus 
CCMultiCrypt(CCOperation op, CCAlgorithm alg, CCOptions options, const void *key, size_t keyLength, const void *iv, const void *dataIn, size_t dataInLength,
	void *dataOut, size_t dataOutAvailable, size_t *dataOutMoved);
    
    
/* This is a CCCrypt allowing mode specification */

CCCryptorStatus
CCCryptWithMode(CCOperation op, CCMode mode, CCAlgorithm alg, CCPadding padding, const void *iv, 
				const void *key, size_t keyLength, const void *tweak, size_t tweakLength,
                int numRounds, CCModeOptions options,
                const void *dataIn, size_t dataInLength, 
                void *dataOut, size_t dataOutAvailable, size_t *dataOutMoved);

CCCryptorStatus 
CCMultiCryptWithMode(CCOperation op, CCMode mode, CCAlgorithm alg, CCPadding padding, const void *iv, 
	const void *key, size_t keyLength, const void *tweak, size_t tweakLength,
	int numRounds, CCModeOptions options,
    const void *dataIn, size_t dataInLength,
	void *dataOut, size_t dataOutAvailable, size_t *dataOutMoved);

/* This is a Test Case "doer" using CCCrypt */
int
CCCryptTestCase(char *keyStr, char *ivStr, CCAlgorithm alg, CCOptions options, char *cipherText, char *plainText);

/* This is a Test Case "doer" using CCMultiCrypt */
int
CCMultiCryptTestCase(char *keyStr, char *ivStr, CCAlgorithm alg, CCOptions options, char *cipherText, char *plainText);

/* This is a Test Case "doer" using CCCryptWithMode */
int
CCModeTestCase(char *keyStr, char *ivStr, CCMode mode, CCAlgorithm alg, CCPadding padding, char *cipherText, char *plainText);

/* This is a Test Case "doer" using CCMultiCryptWithMode */
int
CCMultiModeTestCase(char *keyStr, char *ivStr, CCMode mode, CCAlgorithm alg, CCPadding padding, char *cipherText, char *plainText);
/* This is a Test Case "doer" using CCCryptorGCM */
int
CCCryptorGCMTestCase(char *keyStr, char *ivStr, char *aDataStr, char *tagStr, CCAlgorithm alg, char *cipherText, char *plainText);
int
CCCryptorGCMDiscreetTestCase(char *keyStr, char *ivStr, char *aDataStr, char *tagStr, CCAlgorithm alg, char *cipherText, char *plainText);

//
//  CNEncoding.c
//  CCRegressions
//
#include <stdio.h>
#include "testbyteBuffer.h"
#include "capabilities.h"
#include "testmore.h"

#if (CNENCODER == 0)
entryPoint(CommonBaseEncoding,"Base XX Encoding")
#else

#include <CommonCrypto/CommonBaseXX.h>

static int kTestTestCount = 358;

#define BUFSIZ 1024

static int
doWithEncoders(CNEncoderRef encoder, CNEncoderRef decoder, char *input, char *expected)
{
    CNStatus retval;
    char outBuf[BUFSIZ], secondBuf[BUFSIZ];
    size_t outLen, outAvailable, secondLen, secondAvailable;
    
    outAvailable = BUFSIZ;
    outLen = 0;
    retval = CNEncoderUpdate(encoder, input, strlen(input), outBuf, &outAvailable);
    
    ok(retval == kCNSuccess, "encoded");
    
    outLen = outAvailable;
    outAvailable = BUFSIZ - outLen;
    
    retval = CNEncoderFinal(encoder, &outBuf[outLen], &outAvailable);
    
    ok(retval == kCNSuccess, "finalized");
    
    outLen += outAvailable;
    
    if(expected) {
        ok(strncmp(expected, outBuf, strlen(expected)) == 0, "output matches");
        if(strncmp(expected, outBuf, strlen(expected))) {
            printf("Encoding %s\n%s\n%s\n", input, expected, outBuf);
        }
    }
    
    retval = CNEncoderRelease(&encoder);
    
    ok(retval == kCNSuccess, "released");
    
    
    secondAvailable = BUFSIZ;
    secondLen = 0;
    retval = CNEncoderUpdate(decoder, outBuf, outLen, secondBuf, &secondAvailable);
    
    ok(retval == kCNSuccess, "encoded");
    
    
    secondLen = secondAvailable;
    secondAvailable = BUFSIZ - secondLen;
    
    retval = CNEncoderFinal(decoder, &secondBuf[secondLen], &secondLen);
    
    ok(retval == kCNSuccess, "finalized");
    
    secondLen += secondAvailable;
    
    ok(strncmp(input, secondBuf, strlen(input)) == 0, "output matches");
    
    retval = CNEncoderRelease(&decoder);
    ok(retval == kCNSuccess, "encoder Released");
    
    return 0;
}


static int
doEncoder(CNEncodings encodingStrat, char *input, char *expected)
{
    CNStatus retval;
    CNEncoderRef encoder, decoder;
        
    retval = CNEncoderCreate(encodingStrat, kCNEncode, &encoder);
        
    ok(retval == kCNSuccess, "got an encoder");
    
    retval = CNEncoderCreate(encodingStrat, kCNDecode, &decoder);
    
    ok(retval == kCNSuccess, "got a decoder");
    

    doWithEncoders(encoder, decoder, input, expected);
    
    return 0;
}


static int
doCustomEncoder(const char *name,
                const uint8_t baseNum,
                const char *charMap,
                const uint8_t padChar, char *input, char *expected)
{
    CNStatus retval;
    CNEncoderRef encoder, decoder;
    
    retval = CNEncoderCreateCustom(name, baseNum, charMap, padChar, kCNEncode, &encoder);
    
    ok(retval == kCNSuccess, "got an encoder");
        
    retval = CNEncoderCreateCustom(name, baseNum, charMap, padChar, kCNDecode, &decoder);
    
    ok(retval == kCNSuccess, "got a decoder");
    
    doWithEncoders(encoder, decoder, input, expected);
    
    return 0;
}

static int
doOneShotStyle(CNEncodings encodingStrat, char *input, char *expected)
{
    CNStatus retval;
    char outBuf[BUFSIZ], secondBuf[BUFSIZ];
    size_t outLen, outAvailable, secondLen, secondAvailable;
    
    outAvailable = BUFSIZ;
    retval = CNEncode(encodingStrat, kCNEncode, input, strlen(input), outBuf, &outAvailable);
    
    outLen = outAvailable;
    
    if(expected) {
        ok(strncmp(expected, outBuf, strlen(expected)) == 0, "output matches");
        if(strncmp(expected, outBuf, strlen(expected))) {
            printf("Encoding %s\n%s\n%s\n", input, expected, outBuf);
        }
    }
        
    
    secondAvailable = BUFSIZ;
    retval = CNEncode(encodingStrat, kCNDecode, outBuf, outLen, secondBuf, &secondAvailable);

    secondLen = secondAvailable;
    
    ok(strncmp(input, secondBuf, strlen(input)) == 0, "output matches");
    if(strncmp(input, secondBuf, strlen(input))) {
        printf("input:  %s\n", input);
        printf("result: %s\n", secondBuf);
    }
    
    return 0;    
}

    

int CommonBaseEncoding(int argc, char *const *argv) {
    int accum = 0;
    
    plan_tests(kTestTestCount);
    
    // diag("Base64\n");
    
	doEncoder(kCNEncodingBase64, "", ""); 
	doEncoder(kCNEncodingBase64, "f", "Zg=="); 
	doEncoder(kCNEncodingBase64, "fo", "Zm8="); 
	doEncoder(kCNEncodingBase64, "foo", "Zm9v"); 
	doEncoder(kCNEncodingBase64, "foob", "Zm9vYg=="); 
	doEncoder(kCNEncodingBase64, "fooba", "Zm9vYmE="); 
	doEncoder(kCNEncodingBase64, "foobar", "Zm9vYmFy"); 
    
    //diag("Base32\n");

	doEncoder(kCNEncodingBase32, "", ""); 
	doEncoder(kCNEncodingBase32, "f", "MY======"); 
	doEncoder(kCNEncodingBase32, "fo", "MZXQ===="); 
	doEncoder(kCNEncodingBase32, "foo", "MZXW6==="); 
	doEncoder(kCNEncodingBase32, "foob", "MZXW6YQ="); 
	doEncoder(kCNEncodingBase32, "fooba", "MZXW6YTB"); 
	doEncoder(kCNEncodingBase32, "foobar", "MZXW6YTBOI======");
    
    //diag("Base32HEX\n");

	doEncoder(kCNEncodingBase32HEX, "", ""); 
	doEncoder(kCNEncodingBase32HEX, "f", "CO======"); 
	doEncoder(kCNEncodingBase32HEX, "fo", "CPNG===="); 
	doEncoder(kCNEncodingBase32HEX, "foo", "CPNMU==="); 
	doEncoder(kCNEncodingBase32HEX, "foob", "CPNMUOG="); 
	doEncoder(kCNEncodingBase32HEX, "fooba", "CPNMUOJ1"); 
	doEncoder(kCNEncodingBase32HEX, "foobar", "CPNMUOJ1E8======"); 
    
    //diag("Base16\n");

	doEncoder(kCNEncodingBase16, "", ""); 
	doEncoder(kCNEncodingBase16, "f", "66"); 
	doEncoder(kCNEncodingBase16, "fo", "666F"); 
	doEncoder(kCNEncodingBase16, "foo", "666F6F"); 
	doEncoder(kCNEncodingBase16, "foob", "666F6F62"); 
	doEncoder(kCNEncodingBase16, "fooba", "666F6F6261"); 
	doEncoder(kCNEncodingBase16, "foobar", "666F6F626172"); 
    
    //diag("Base64 Long\n");
    accum |= doEncoder(kCNEncodingBase64, 
    "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.",
                       "");
<<<<<<< HEAD
    //diag("Custom\n");
=======
    
    diag("Base64 - One-Shot\n");
    
	doOneShotStyle(kCNEncodingBase64, "", ""); 
	doOneShotStyle(kCNEncodingBase64, "f", "Zg=="); 
	doOneShotStyle(kCNEncodingBase64, "fo", "Zm8="); 
	doOneShotStyle(kCNEncodingBase64, "foo", "Zm9v"); 
	doOneShotStyle(kCNEncodingBase64, "foob", "Zm9vYg=="); 
	doOneShotStyle(kCNEncodingBase64, "fooba", "Zm9vYmE="); 
	doOneShotStyle(kCNEncodingBase64, "foobar", "Zm9vYmFy"); 
    
    diag("Base32 - One-Shot\n");
    
	doOneShotStyle(kCNEncodingBase32, "", ""); 
	doOneShotStyle(kCNEncodingBase32, "f", "MY======"); 
	doOneShotStyle(kCNEncodingBase32, "fo", "MZXQ===="); 
	doOneShotStyle(kCNEncodingBase32, "foo", "MZXW6==="); 
	doOneShotStyle(kCNEncodingBase32, "foob", "MZXW6YQ="); 
	doOneShotStyle(kCNEncodingBase32, "fooba", "MZXW6YTB"); 
	doOneShotStyle(kCNEncodingBase32, "foobar", "MZXW6YTBOI======");
    
    diag("Base32HEX - One-Shot\n");
    
	doOneShotStyle(kCNEncodingBase32HEX, "", ""); 
	doOneShotStyle(kCNEncodingBase32HEX, "f", "CO======"); 
	doOneShotStyle(kCNEncodingBase32HEX, "fo", "CPNG===="); 
	doOneShotStyle(kCNEncodingBase32HEX, "foo", "CPNMU==="); 
	doOneShotStyle(kCNEncodingBase32HEX, "foob", "CPNMUOG="); 
	doOneShotStyle(kCNEncodingBase32HEX, "fooba", "CPNMUOJ1"); 
	doOneShotStyle(kCNEncodingBase32HEX, "foobar", "CPNMUOJ1E8======"); 
    
    diag("Base16 - One-Shot\n");
    
	doOneShotStyle(kCNEncodingBase16, "", ""); 
	doOneShotStyle(kCNEncodingBase16, "f", "66"); 
	doOneShotStyle(kCNEncodingBase16, "fo", "666F"); 
	doOneShotStyle(kCNEncodingBase16, "foo", "666F6F"); 
	doOneShotStyle(kCNEncodingBase16, "foob", "666F6F62"); 
	doOneShotStyle(kCNEncodingBase16, "fooba", "666F6F6261"); 
	doOneShotStyle(kCNEncodingBase16, "foobar", "666F6F626172"); 
    
    diag("Base64 Long - One-Shot\n");
    accum |= doOneShotStyle(kCNEncodingBase64, 
                       "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.",
                       "");

    
    
    
    diag("Custom\n");
    accum |= doCustomEncoder("Custom64", 64, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/", '*',
                       "Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.",
                       "");
    
    return 0;
}

#endif

#include <stdio.h>
#include "testbyteBuffer.h"
#include "capabilities.h"
#include "testmore.h"
#include <string.h>
#include <CommonCrypto/CommonDigest.h>

#if (CCBIGDIGEST == 0)
entryPoint(CommonBigDigest,"CommonCrypto CCDigest Large Size test")
#else
#include <CommonCrypto/CommonDigestSPI.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>


static void DigestInChunks(CCDigestAlgorithm algorithm, size_t chunksize, const uint8_t *bytesToDigest, size_t numbytes, uint8_t *outbuf)
{
    CCDigestRef d = CCDigestCreate(algorithm);
    while(numbytes) {
        size_t n = (numbytes < chunksize) ? numbytes: chunksize;
        CCDigestUpdate(d, bytesToDigest, n);
        numbytes -= n; bytesToDigest += n;
    }
    if(CCDigestFinal(d, outbuf)) return;
    CCDigestDestroy(d);
}

/*
 * Compute the digest of a whole file
 */

static int
checksum_file(char *filename, CCDigestAlgorithm algorithm)
{
    struct stat st;
    size_t digestsize = CCDigestGetOutputSize(algorithm);
    uint8_t mdwhole[digestsize];
    uint8_t mdchunk[digestsize];
    size_t blocksz = 0x40000000L; // 1 GB
    off_t filesize;
    u_char *buf;
    int fd; 
    
    fd = open(filename, O_RDONLY);
    if (fd < 0) {
        perror(filename);
        return -1; 
    }   
    if (fstat(fd, &st) < 0) {
        perror(filename);
        (void) close(fd);
        return -1; 
    }   
    
    filesize = st.st_size;
    buf = (u_char *) mmap(NULL, filesize,
                          PROT_READ, MAP_PRIVATE | MAP_NOCACHE, fd, 0); 
    if (buf == (u_char *) -1) {
        perror("mmap");
        close(fd);
        return -1; 
    }   
    (void) madvise(buf, filesize, MADV_SEQUENTIAL);
	printf("File is mapped\n");
    
	/*
	 * First do it in one big chunk
	 */
    
    CCDigest(algorithm, buf, filesize, mdwhole);
    
	/*
	 * Now do it in several 1GB chunks
	 */
    
    DigestInChunks(algorithm, blocksz, buf, filesize, mdchunk);
    
    (void) munmap(buf, filesize);
    (void) close(fd);
    
    int cmpval = memcmp(mdchunk, mdwhole, digestsize);
    ok(cmpval == 0, "Results are the same for both digests");
    
    return 0;
}


static const int kTestTestCount = 1000;

int CommonBigDigest(int argc, char *const *argv)
{
    
	plan_tests(kTestTestCount);
    
    char *testpath = "/Volumes/Data/Users/murf/Downloads/Zin_12A130_AppleInternal_038-2423-191.dmg";
    checksum_file(testpath, kCCDigestSHA1);

    return 0;
}


#endif

#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"
#include "CommonRandomSPI.h"




#if (CCBIGNUM == 0)
entryPoint(CommonBigNum,"Big Number Arithmetic")
#else

#include <CommonCrypto/CommonBigNum.h>
static int kTestTestCount = 7;



#define STRESSSIZE 5000

static int testCreateFree()
{
    CCStatus status;
    CCBigNumRef stress[STRESSSIZE];
    for(size_t i=0; i<STRESSSIZE; i++) stress[i] = NULL;
    byteBuffer bb = hexStringToBytes("0102030405060708091011121314151617181920");
    for(int i=0; i<100; i++) {
        for(int j=0; j<100; j++) {
            CCBigNumRef r = CCBigNumCreateRandom(&status, 31, 31, 0);
            ok(status == kCCSuccess, "Created Random Number");
            size_t ri = CCBigNumGetI(&status, r);
            ok(status == kCCSuccess, "translated to int");
            
            ri %= STRESSSIZE;

            if(stress[ri] == NULL) {
                int sel = ri % 3;
                switch(sel) {
                    case 0: /* printf("(%lu) BigNum\n", ri); */ stress[ri] = CCCreateBigNum(&status); break;
                    case 1: /* printf("(%lu) FromHex\n", ri); */ stress[ri] = CCBigNumFromHexString(&status, "0003"); break;
                    case 2: /* printf("(%lu) FromData\n", ri); */ stress[ri] = CCBigNumFromData(&status, bb->bytes, bb->len); break;
                }
                ok(status == kCCSuccess, "BigNum Created");
            } else {
                /* printf("(%lu) Freeing\n", ri); */
                CCBigNumClear(stress[ri]);
                CCBigNumFree(stress[ri]);
                stress[ri] = NULL;
            }
            CCBigNumFree(r);
        }
    }
    return 0;
}

static int testHexString()
{
    CCStatus status;
    char *hexstring = "1002030405060708090021222324252627282920";
    CCBigNumRef num1 = CCBigNumFromHexString(&status, hexstring);
    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);
    CCBigNumFree(num1);

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

static int testI()
{
    CCStatus status;
    uint32_t I=0x10203040;
    char *hexstring = "10203040";
    byteBuffer bb = hexStringToBytes(hexstring);
    CCBigNumRef num1 = CCCreateBigNum(&status);
    char *output;
    
    ok(status == 0, "BigNum Created");
    status = CCBigNumSetI(num1, I);
    ok(status == 0, "BigNum Set to I");
    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);
    
    uint32_t outI = CCBigNumGetI(&status, num1);
    ok(status == 0, "Value retrieved 2");
    
    ok(outI == I, "input == output");
    free(bb);
    CCBigNumFree(num1);
    
    return 0;
    
}


static int testCompare()
{
    CCStatus status;
    char *lowstring = "030405060708090021222324252627282920";
    char *midstring = "1002030405060708090021222324252627282920";
    char *histring  = "1002030405060708090f21222324252627282920";
    CCBigNumRef low = CCBigNumFromHexString(&status, lowstring);
    ok(status == 0, "BigNum Created");
    CCBigNumRef mid = CCBigNumFromHexString(&status, midstring);
    ok(status == 0, "BigNum Created");
    CCBigNumRef midsame = CCBigNumFromHexString(&status, midstring);
    ok(status == 0, "BigNum Created");
    CCBigNumRef hi = CCBigNumFromHexString(&status, histring);
    ok(status == 0, "BigNum Created");
    CCBigNumRef iVal = CCCreateBigNum(&status);
    ok(status == 0, "BigNum Created");
    status = CCBigNumSetI(iVal, 67);

    ok(CCBigNumCompare(mid, low) == 1, "mid > low");
    ok(CCBigNumCompare(mid, hi) == -1, "mid < hi");
    ok(CCBigNumCompare(mid, midsame) == 0, "mid == midsame");
    ok(CCBigNumCompareI(iVal, 67) == 0, "iVal equality is correct");
    ok(CCBigNumCompareI(iVal, 66) > 0, "iVal greater is correct");
    ok(CCBigNumCompareI(iVal, 68) < 0, "iVal less than is correct");

    CCBigNumFree(low);
    CCBigNumFree(mid);
    CCBigNumFree(midsame);
    CCBigNumFree(hi);
    CCBigNumFree(iVal);

    return 0;
    
}

static int testBitCount()
{
    CCStatus status;
    char *hexstring = "1002030405060708090021222324252627282920";
    CCBigNumRef num1 = CCBigNumFromHexString(&status, hexstring);
    ok(status == 0, "BigNum Created");
    
    int bits = CCBigNumBitCount(num1);
    ok(bits == 157, "bit count is correct");

    CCBigNumFree(num1);
    return 0;
}

static int testAddSub()
{
    CCStatus status;
    char *hex1 = "1002030405060708090021222324252627282920";
    char *hex2 = "1002030405060708090021222324252627282920";
    char *result = "200406080a0c0e101200424446484a4c4e505240";
    CCBigNumRef num1 = CCBigNumFromHexString(&status, hex1);
    CCBigNumRef num2 = CCBigNumFromHexString(&status, hex2);
    CCBigNumRef output = CCCreateBigNum(&status);
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, result);
    
    status = CCBigNumAdd(output, num1, num2);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");

    status = CCBigNumSub(output, num1, num2);
    ok(status == 0, "operation completed");
    CCBigNumSetI(resultExpected, 0);
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");
    
    CCBigNumFree(num1);
    CCBigNumFree(num2);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    return 0;
}

static int testAddSubI()
{
    CCStatus status;
    char *hex1 = "1002030405060708090021222324252627282920";
    char *result = "1002030405060708090021222324252627282921";
    CCBigNumRef num1 = CCBigNumFromHexString(&status, hex1);
    CCBigNumRef output = CCCreateBigNum(&status);
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, result);
    
    status = CCBigNumAddI(output, num1, 1);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");
    
    status = CCBigNumSubI(output, output, 1);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, num1) == 0, "expected operation result");
    
    CCBigNumFree(num1);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    return 0;
}


static int testShift()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef n = CCBigNumFromHexString(&status, "1002030405060708090021222324252627282920");
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, "200406080a0c0e101200424446484a4c4e505");
    CCBigNumRef output = CCCreateBigNum(&status);
    status = CCBigNumRightShift(output, n, 11);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");

    // Shift n left by 14
    CCBigNumRef resultExpected2 = CCBigNumFromHexString(&status, "40080c1014181c20240084888c9094989ca0a480000");
    status = CCBigNumLeftShift(output, n, 14);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected2) == 0, "expected operation result");

    
    CCBigNumFree(n);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    CCBigNumFree(resultExpected2);
    return 0;
}

static int testModExp()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    CCBigNumRef b = CCBigNumFromHexString(&status, "010001");
    CCBigNumRef c = CCBigNumFromHexString(&status, "354c912b09ee7abff5b3d94ed52a9e8dcae582e094daa375c495f970710af73efcc4f9776010511f654c7408a6d5d351ab1d94a0fede757d782b54ddcf6fe8d714870b78b0e67a9754cb03a5cf63bbda1c71791902ea4527fb0cd76437391e5422c704ffb6d6018261171d8cee98adcf0243f1fd520fb3761afe94a2f4d99f94");
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, "0fb978a4f4fccdb14c7268918b784c4f6d5281c0d6ff43e60e88e97f97f2617608de2488c84eb99a3f467013c860536ec74f4968abeccbc1b026ee5873e40bdd292f8f7416a93df619288b49ba21d3e09aa796cb35a340b1abfda4e3b6cd92df2de64967e6a59f787586929c4d2920da20caeb384594d7f2b7e999dab0d6a1ac");
    CCBigNumRef output = CCCreateBigNum(&status);
    
    status = CCBigNumModExp(output, a, b, c);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");

    CCBigNumFree(a);
    CCBigNumFree(b);
    CCBigNumFree(c);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    return 0;
}

static int testMod()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    CCBigNumRef c = CCBigNumFromHexString(&status, "354c912b09ee7abff5b3d94ed52a9e8dcae582e094daa375c495f970710af73efcc4f9776010511f654c7408a6d5d351ab1d94a0fede757d782b54ddcf6fe8d714870b78b0e67a9754cb03a5cf63bbda1c71791902ea4527fb0cd76437391e5422c704ffb6d6018261171d8cee98adcf0243f1fd520fb3761afe94a2f4d99f94");
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, "2983308b3538c60b245899a58b98f08c2e74c53950b30de70314f29af2df858d72df6651a38ceb4f1612231227604c1150c4cc412968c97afa545cbe18ee04a1d102bfa6a5bf7498996a41e70b4c7991f3c9e87984321915b87f8ce5c1aeca2b6015b6384f8a59bae351d662f52f1634c3257434fb8eed85d93fb1ecaf344d7e");
    CCBigNumRef output = CCCreateBigNum(&status);
    
    status = CCBigNumMod(output, a, c);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");
    
    CCBigNumFree(a);
    CCBigNumFree(c);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    return 0;
}


static int testModI()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    uint32_t c=63;
    uint32_t resultExpected = 23;
    uint32_t output;
    
    status = CCBigNumModI(&output, a, c);
    ok(status == 0, "operation completed");
    ok(resultExpected == output, "expected operation result");
    
    CCBigNumFree(a);
    return 0;
}


static int testMul()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    CCBigNumRef c = CCBigNumFromHexString(&status, "354c912b09ee7abff5b3d94ed52a9e8dcae582e094daa375c495f970710af73efcc4f9776010511f654c7408a6d5d351ab1d94a0fede757d782b54ddcf6fe8d714870b78b0e67a9754cb03a5cf63bbda1c71791902ea4527fb0cd76437391e5422c704ffb6d6018261171d8cee98adcf0243f1fd520fb3761afe94a2f4d99f94");
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, "29eef49086721db0707b81175570af0db1517307f313564ff3a07f695514e92f525efea63ab5de4830c06b365f5c21cba747b96c6cb315d5b3dfa6642324e0a30f0a999acd196c1c78b99bff4d53e1e1e5d02b521a964a286279129e9bfbb51738743617a73f896bfd21e7c4c24e8f72a4a995781b0b4fa1b37a2320b935b0c5e130f27a65135ac4b7247db58e7f752550d92e08b177a84d5d0364cd8c74d4e2bb086d1cd9bc4c541e86ecf66940be30b73675a63921f9fd1fdfa6db57bd4b13304ac0ac84d64c262d5802a1363ee1d519f88b8ca0997a77f7ece081042d88814da526c44f1323c7ac5b7eeedccda0e28bc65bc415bba767d34f161ab34f9788");
    CCBigNumRef output = CCCreateBigNum(&status);
    
    status = CCBigNumMul(output, a, c);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");
    
    CCBigNumFree(a);
    CCBigNumFree(c);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    return 0;
}

static int testMulI()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    uint32_t c = 63;
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, "3190d01f086e095c7657953ef0bb1a412e3a2e28e8c17b19cbe4e0dc253a1a674fe2665b392bb9cca437e84bdadc8fbb8e3544fee55b0652e552c07a8a48320a9c9760a21d644633475b07e945e4739af1fe769d5eaf493adcbfdeb1876f2f24ca524688a58f0b323f9f3493667d4ec8d0b261410f7dc3f22264a0858de289e246");
    CCBigNumRef output = CCCreateBigNum(&status);
    
    status = CCBigNumMulI(output, a, c);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");
    
    CCBigNumFree(a);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    return 0;
}

static int testPrime()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "09c75b");
    ok(CCBigNumIsPrime(&status, a), "prime number");
    CCBigNumRef b = CCBigNumFromHexString(&status, "09c75c");
    ok(!CCBigNumIsPrime(&status, b), "not prime number");

    return 0;
}


static int testDiv()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    CCBigNumRef c = CCBigNumFromHexString(&status, "354c912b09ee7abff5b3d94ed52a9e8dcae582e094daa375c495f970710af73efcc4f9776010511f654c7408a6d5d351ab1d94a0fede757d782b54ddcf6fe8d714870b78b0e67a9754cb03a5cf63bbda1c71791902ea4527fb0cd76437391e5422c704ffb6d6018261171d8cee98adcf0243f1fd520fb3761afe94a2f4d99f94");
    CCBigNumRef resultExpected = CCBigNumFromHexString(&status, "03");
    CCBigNumRef c2 = CCBigNumFromHexString(&status, "43"); // dec 67
    CCBigNumRef resultExpected2 = CCBigNumFromHexString(&status, "30190c6ded9da99f49e63e76ef8ba736d1f1fbaac2b0786cf88f03904dd9e4210da7b80d5121e11dea7fe13c3482557f99574b04cfc3dc2ad6a5d1097089039e578b6f4c9708551a690684fa61c8850b87e8acd70e8d970eb9b5086018ae5ceec10e08e33675949951d00b3ba487e8fc9b35cceffc985d96f6fb16e2c25456f");
    CCBigNumRef output = CCCreateBigNum(&status);
    
    status = CCBigNumDiv(output, NULL, a, c);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected) == 0, "expected operation result");
    
    status = CCBigNumDiv(output, NULL, a, c2);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected2) == 0, "expected operation result");

    CCBigNumFree(a);
    CCBigNumFree(c);
    CCBigNumFree(c2);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected);
    CCBigNumFree(resultExpected2);
    return 0;
}


static int testMulMod()
{
    CCStatus status;
    
    // Shift n right by 11
    CCBigNumRef a = CCBigNumFromHexString(&status, "c968e40c5304364b057425920b18cc358f254ddb0f42f84850d6deec46006b4a692e52b7c3bddead45f77f2c1be1c606521d8a24260429f362d65b57873dbf270e97e210b872e45e97cb4cd87977ad20491e53c48cf0e88da9a61312675a2527c86ac537740c5e4206972f09c0f91fa1c9f14a2cf1be07e82a3b6fd58dc12c3a");
    CCBigNumRef c = CCBigNumFromHexString(&status, "354c912b09ee7abff5b3d94ed52a9e8dcae582e094daa375c495f970710af73efcc4f9776010511f654c7408a6d5d351ab1d94a0fede757d782b54ddcf6fe8d714870b78b0e67a9754cb03a5cf63bbda1c71791902ea4527fb0cd76437391e5422c704ffb6d6018261171d8cee98adcf0243f1fd520fb3761afe94a2f4d99f94");
    CCBigNumRef mod1 = CCBigNumFromHexString(&status, "912b09ee7abff5b3d94ed52a9e8dcae582e094daa375c495f970710af73efcc4f9776010511f654c7408a6d5d351ab1d94a0fede757d782b54ddcf6fe8d714870b78b0e67a9754cb03a5cf63bbda1c71791902ea4527fb0cd76437391e5422c704ffb6d6018261171d8cee98adcf0243f1fd520fb3761afe94a2f4d99f94");
    CCBigNumRef mod2 = CCBigNumFromHexString(&status, "43"); // dec 67
    CCBigNumRef resultExpected1 = CCBigNumFromHexString(&status, "57c1dfcd53105f1f653539172a789fc97067101320d12b93dd400eaad0bbb9d8d9857beeeae28c1ad0614075f1d59bb12556f78d85e4af9d2283fa5d3c192a03a59932dd537d4c1a9d74a8a2d647f266cc4fe9365c5c9b8ac4d5afc960002850243b2175eb09842d1f1cfd59bdd5c2564cb056586d2186aae39583061a88");
    CCBigNumRef resultExpected2 = CCBigNumFromHexString(&status, "3d");
    CCBigNumRef output = CCCreateBigNum(&status);
    
    status = CCBigNumMulMod(output, a, c, mod1);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected1) == 0, "expected operation result");
    
    status = CCBigNumMulMod(output, a, c, mod2);
    ok(status == 0, "operation completed");
    ok(CCBigNumCompare(output, resultExpected2) == 0, "expected operation result");
 
    CCBigNumFree(a);
    CCBigNumFree(c);
    CCBigNumFree(output);
    CCBigNumFree(resultExpected1);
    CCBigNumFree(resultExpected2);
    CCBigNumFree(mod1);
    CCBigNumFree(mod2);
    return 0;
}




int CommonBigNum(int argc, char *const *argv) {

    
	plan_tests(kTestTestCount);

    for(int i=0; i<10; i++) {
        testCreateFree();
        testHexString();
        testData();
        testI();
        testCompare();
        testBitCount();
        testAddSub();
        testAddSubI();
        testShift();
        testMod();
        testModI();
        testModExp();
        testMul();
        testMulI();
        testPrime();
        testDiv();
        testMulMod();
    }

    return 0;
}
#endif /* CCBigNum */

//
//  CCCMACtests.c
//  CCRegressions
//

#include <stdio.h>
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCCMAC == 0)
entryPoint(CommonCMac,"Common CMac")
#else

#include <CommonCrypto/CommonCMACSPI.h>

static int
CMACTest(char *input, char *keystr, char *expected)
{
    byteBuffer mdBuf;
    byteBuffer inputBytes, expectedBytes, keyBytes;
    char *digestName;
    char outbuf[160];
    int retval = 0;
    
    inputBytes = hexStringToBytes(input);
    expectedBytes = hexStringToBytes(expected);
    keyBytes = hexStringToBytes(keystr);
    mdBuf = mallocByteBuffer(CC_CMACAES_DIGEST_LENGTH); digestName = "CMAC-AES"; 
    CCAESCmac(keyBytes->bytes, inputBytes->bytes, inputBytes->len, mdBuf->bytes);
    
	sprintf(outbuf, "Hmac-%s test for %s", digestName, input);
    
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("HMAC FAIL: HMAC-%s(\"%s\")\n expected %s\n      got %s\n", digestName, input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // diag("HMAC PASS: HMAC-%s(\"%s\")\n", digestName, input);
    }
    
    free(mdBuf);
    free(expectedBytes);
    free(keyBytes);
    free(inputBytes);
    return retval;
}

static int kTestTestCount = 4;

int CommonCMac (int argc, char *const *argv) {
	char *strvalue, *keyvalue;
	plan_tests(kTestTestCount);
    int accum = 0;
    
    strvalue = "";
    keyvalue = "2b7e151628aed2a6abf7158809cf4f3c";
	accum |= CMACTest(strvalue, keyvalue, "bb1d6929e95937287fa37d129b756746");   
    strvalue = "6bc1bee22e409f96e93d7e117393172a";
	accum |= CMACTest(strvalue, keyvalue, "070a16b46b4d4144f79bdd9dd04a287c");   
    strvalue = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411";
	accum |= CMACTest(strvalue, keyvalue, "dfa66747de9ae63030ca32611497c827");   
    strvalue = "6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710";
	accum |= CMACTest(strvalue, keyvalue, "51f0bebf7e3b9d92fc49741779363cfe");  
    
    return accum;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include <stdint.h>
#include <CommonCrypto/CommonCryptor.h>
#include <CommonCrypto/CommonCryptorSPI.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "capabilities.h"
#include "testmore.h"

#if (CCPADCTS == 0)
entryPoint(CommonCryptoCTSPadding,"CommonCrypto CTS Padding Testing")

#else

static int kTestTestCount = 9;

int CommonCryptoCTSPadding(int argc, char *const *argv)
{
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    CCMode mode;
    CCAlgorithm alg;
    CCPadding padding;
    int retval, accum = 0;
    char *test;
    
	keyStr 	   = "636869636b656e207465726979616b69";
	iv         = "0f0e0d0c0b0a09080706050403020100";
    mode 	   = kCCModeCBC;
    alg		= kCCAlgorithmAES128;
    padding = ccCBCCTS1;
    
	plan_tests(kTestTestCount);
    
    test = "CTS1 Test - Length 64";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee2dc88b70f6ae0243d2dbcd6822a1058604b1c432a7a71395b36d820e2c3de4ee";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    test = "CTS1 Test - Length 63";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee2dc88b70f6ae0243d2dbcd6822a105950b6576660739916d058623d688e27e";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    test = "CTS1 Test - Length 57";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee2dc88b70f6ae0243d2db751002ef7a0f9d915d15346571eee7aa";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    
    padding = ccCBCCTS2;
    
    test = "CTS2 Test - Length 64";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee2dc88b70f6ae0243d2dbcd6822a1058604b1c432a7a71395b36d820e2c3de4ee";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    test = "CTS2 Test - Length 63";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee950b6576660739916d058623d688e27e2dc88b70f6ae0243d2dbcd6822a105";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    test = "CTS2 Test - Length 57";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee751002ef7a0f9d915d15346571eee7aa2dc88b70f6ae0243d2db";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    padding = ccCBCCTS3;
    
    test = "CTS3 Test - Length 64";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee04b1c432a7a71395b36d820e2c3de4ee2dc88b70f6ae0243d2dbcd6822a10586";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    test = "CTS3 Test - Length 63";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee950b6576660739916d058623d688e27e2dc88b70f6ae0243d2dbcd6822a105";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    test = "CTS3 Test - Length 57";
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "e22abba9d2a201b18dc2f57e04aba21a16e0ed6358164c59ca64d204f33247ee751002ef7a0f9d915d15346571eee7aa2dc88b70f6ae0243d2db";
    diag(test);
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, test);
    accum += retval;
    
    
    return accum != 0;
}
#endif

//
//  CommonCryptoReset.c
//  CommonCrypto
//
//  Created by Richard Murphy on 2/10/12.
//  Copyright (c) 2012 McKenzie-Murphy. All rights reserved.
//

#include "capabilities.h"
#include <stdio.h>
#include <string.h>
#include <CommonCrypto/CommonCryptor.h>
#include <CommonCrypto/CommonCryptorSPI.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"





#if (CCRESET == 0)
entryPoint(CommonCryptoReset,"CommonCrypto Reset Testing")
#else




static int kTestTestCount = 13;

int CommonCryptoReset(int argc, char *const *argv)
{
    CCCryptorRef cref;
	CCCryptorStatus retval;
    size_t moved;
    uint8_t key[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
    uint8_t plain[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
    uint8_t nulliv[16];
    uint8_t cipher1[16], cipher2[16], cipher3[16], cipher4[16], cipher5[16], unused[16];
    
	plan_tests(kTestTestCount);

    bzero(nulliv, 16);
    
   	retval = CCCryptorCreateWithMode(kCCEncrypt, kCCModeCBC, kCCAlgorithmAES128, 
                                     ccNoPadding, NULL, key, 16, NULL, 0, 0, 0, &cref);

    ok(retval == kCCSuccess, "cryptor created");
    
    retval = CCCryptorUpdate(cref, plain, 16, cipher1, 16, &moved);
    
    ok((retval == kCCSuccess && moved == 16), "first update");

    retval = CCCryptorUpdate(cref, plain, 16, cipher2, 16, &moved);
    
    ok((retval == kCCSuccess && moved == 16), "second (chained) update");
    
    ok(memcmp(cipher1, cipher2, 16) != 0, "chained crypts shouldn't be the same even with the same data");
    
    retval = CCCryptorReset(cref, NULL);
    
    ok(retval == kCCSuccess, "cryptor NULL reset");

    retval = CCCryptorUpdate(cref, plain, 16, cipher3, 16, &moved);
    
    ok((retval == kCCSuccess && moved == 16), "third update - NULL Reset");
    
    ok(memcmp(cipher1, cipher3, 16) == 0, "reset crypt should be the same as the start");

    retval = CCCryptorReset(cref, nulliv);
   
    ok(retval == kCCSuccess, "cryptor zero iv reset");

    retval = CCCryptorUpdate(cref, plain, 16, cipher4, 16, &moved);
    
    ok((retval == kCCSuccess && moved == 16), "fourth update - zero iv Reset");
    
    ok(memcmp(cipher1, cipher4, 16) == 0, "reset crypt should be the same as the start");
    
    retval = CCCryptorUpdate(cref, plain, 16, cipher5, 16, &moved);
    
    ok((retval == kCCSuccess && moved == 16), "fifth (chained) update");
    
    ok(memcmp(cipher2, cipher5, 16) == 0, "reset crypt should be the same as the second");

    retval = CCCryptorFinal(cref, unused, 16, &moved);
        
    ok((retval == kCCSuccess && moved == 0), "Final - no work");

	CCCryptorRelease(cref);
    
    return kCCSuccess;

}

#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 *  CBCTest.c
 *  CommonCrypto
 */

#include <stdio.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMCBC == 0)
entryPoint(CommonCryptoSymCBC,"CommonCrypto Symmetric CBC Testing")
#else


static int kTestTestCount = 28;

int CommonCryptoSymCBC(int argc, char *const *argv) {
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    CCAlgorithm alg;
    CCOptions options;
	int retval;
    int accum = 0;

	keyStr 	   = "000102030405060708090a0b0c0d0e0f";
	iv         = "0f0e0d0c0b0a09080706050403020100";
    alg		   = kCCAlgorithmAES128;
    options    = kCCOptionPKCS7Padding;
    
	plan_tests(kTestTestCount);
    
    accum = (int) genRandomSize(1,10);
	// 1
	plainText  = "0a";
	cipherText = "a385b047a4108a8748bf96b435738213";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 1 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 1 byte Multiple Updates");
    accum |= retval;

	// 15
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "324a44cf3395b14214861084019f9257";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 15 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 15 byte Multiple Updates");
    accum |= retval;

	// 16
    plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "16d67a52c1e8384f7ed887c2011605346544febcf84574c334f1145d17567047";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 16 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 16 byte Multiple Updates");
    accum |= retval;

	// 17
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "16d67a52c1e8384f7ed887c2011605348b72cecb00bbc00f328af6bb69085b02";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 17 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 17 byte Multiple Updates");
    accum |= retval;

	// 31
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "16d67a52c1e8384f7ed887c2011605347175cf878a75bc1947ae79c6c6835030";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 31 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 31 byte Multiple Updates");
    accum |= retval;

	// 32
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "16d67a52c1e8384f7ed887c20116053486869f3b83f3b3a83531e4169e97b7244a49199daa033fa88f07dd4be52ae78e";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 32 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 32 byte Multiple Updates");
    accum |= retval;

	// 33
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "16d67a52c1e8384f7ed887c20116053486869f3b83f3b3a83531e4169e97b724d0080fb874dd556fa86b314acc4f597b";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 33 byte CCCrypt");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 33 byte Multiple Updates");
    accum |= retval;
    
    iv = NULL;
	// 1
	plainText  = "0a";
	cipherText = "27cae51ac763b250945fd805c937119b";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 1 byte CCCrypt NULL IV");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 1 byte Multiple Updates NULL IV");
    accum |= retval;

	// 15
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "feb9c3a005dcbd1e2630af742e988e81";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 15 byte CCCrypt NULL IV");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 15 byte Multiple Updates NULL IV");
    accum |= retval;

	// 16
    plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "d307b25d3abaf87c0053e8188152992a8b002a94911ee1e157d815a026cfadeb";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 16 byte CCCrypt NULL IV");
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 16 byte Multiple Updates NULL IV");
    accum |= retval;

	// 17
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "d307b25d3abaf87c0053e8188152992ab8fe4130b613e93617b2eda2e0c5c678";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 17 byte CCCrypt NULL IV");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 17 byte Multiple Updates NULL IV");
    accum |= retval;

	// 31
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "d307b25d3abaf87c0053e8188152992a4157ad665141a79481f463357707f759";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 31 byte CCCrypt NULL IV");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 31 byte Multiple Updates NULL IV");
    accum |= retval;

	// 32
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "d307b25d3abaf87c0053e8188152992a923832530aa268661a6c1fa3c69d6a23dc6d5c0d7fa8127cfd601cae71b4c14f";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 32 byte CCCrypt NULL IV");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 32 byte Multiple Updates NULL IV");
    accum |= retval;

	// 33
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "d307b25d3abaf87c0053e8188152992a923832530aa268661a6c1fa3c69d6a2382178b537aa2946f7a4124ee33744edd";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 33 byte CCCrypt NULL IV");
    accum |= retval;
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    ok(retval == 0, "CBC with Padding 33 byte Multiple Updates NULL IV");
    accum |= retval;
    
    return accum != 0;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMCFB == 0)
entryPoint(CommonCryptoSymCFB,"CommonCrypto Symmetric CFB Testing")
#else
static int kTestTestCount = 5;

int CommonCryptoSymCFB(int argc, char *const *argv)
{
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    CCMode mode;
    CCAlgorithm alg;
    CCPadding padding;
    int retval, accum = 0;
    
	keyStr 	   = "00000000000000000000000000000000";
    mode 	   = kCCModeCFB;
    alg		= kCCAlgorithmAES128;
    padding = ccNoPadding;
    
	plan_tests(kTestTestCount);
    
	plainText  = "00000000000000000000000000000000";
	iv         = "80000000000000000000000000000000";
	cipherText = "3ad78e726c1ec02b7ebfe92b23d9ec34";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "CFB Test 1");
    accum += retval;
    
	plainText  = "00000000000000000000000000000000";
	iv         = "c0000000000000000000000000000000";
	cipherText = "aae5939c8efdf2f04e60b9fe7117b2c2";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "CFB Test 2");
    accum += retval;
    
	plainText  = "00000000000000000000000000000000";
	iv         = "ffffffffffffffffffffffc000000000";
	cipherText = "90684a2ac55fe1ec2b8ebd5622520b73";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "CFB Test 3");
    accum += retval;
    
	keyStr 	   = "f36f40aeb3e20c19440081919df4ecb9";
	plainText  = "5552ee4fbf25859cdfecf34742d640855c55a00a1c6aa571c322b4ddf561b6e110de0f9dbe6fd42ac687383928fc48f6680ed9332aa6bec2ffdb3e227fbac55f9847d93325bf5071c220c0a3dfeb38f214292d47b4acb7b0a597fe056f21eecb";
	iv         = "cf75d0cae8dbce85e0bc0e58eb4e82c0";
	cipherText = "d579c0e622047e0efef9ddacc94be36450d09366e38ea9e4ed3c2e39923f580fdc436a874e34fb39330f8a8a7bf1f68d8a93644a2b9d1fed260eb6e7c8ac874d616ec02b57d08f043aae552fc52bf11eb4a4ed5918ff81738b3ea3ce244c9cd1";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "CFB Test 4");
    accum += retval;
    
	keyStr 	   = "02f5f980a3c6af2984c9eed684f5224f";
	plainText  = "cb9056b3c195cef43da2634271f2f34e556868ac41d0ea35bb6854aa8e9fe49a1c1c3685f4027341a773c69dd8530f45934edce5e01c95919703f665759ec26870deb6b6484ebcdf5f9b628aca538a5ea8ed6322b20a982214fac7d57c8234be70dcbf90e40013950c2221506f7ccd623d4de6aae2225cb0db54ad44c8d2a162c3203759f1a0df2c5611e939ee553e18f9774ec696ec4903931992f88416711d";
	iv         = "7844c96a2c65e9c334573b9894d91046";
	cipherText = "227d8e80650e60c1c9e9ab2f8fe8bc24185725f1f1b8e326b73c04501e91995d5a7be17d0c74ce1cd2d5a3d917738dea486fb523297aea2badc6f8766ffdfcc6e8efd640a8d5d1f55d1e4fe4f03bb9f66956eaa9864ee760d1ad3e5faaae6da36476c55d1f25d7c064b9c518ce5b3f42ecdb1c3ef57c7b3fa3ef188218d0d0c417056935bcc76a90ff277f9e698ff9a599ebaa6c2723288c9f0817694e400ce6";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "CFB Test 5");
    accum += retval;
    
    keyStr 	   = "e0000000000000000000000000000000";
    iv         = NULL;
    plainText  = "00000000000000000000000000000000";
    cipherText = "72a1da770f5d7ac4c9ef94d822affd97";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "CFB Test NULLIV");
    accum += retval;

    
    return accum != 0;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include <CommonCrypto/CommonCryptor.h>
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMCTR == 0)
entryPoint(CommonCryptoSymCTR,"CommonCrypto Symmetric CTR Testing")
#else
static int kTestTestCount = 10;

static CCCryptorStatus doCrypt(char *in, char *out, CCCryptorRef cryptor) {
    byteBuffer inbb = hexStringToBytes(in);
    byteBuffer outbb = hexStringToBytes(out);
    byteBuffer buf = mallocByteBuffer(64);
    CCCryptorStatus retval = CCCryptorUpdate(cryptor, inbb->bytes, inbb->len, buf->bytes, buf->len, &buf->len);
    if(!retval) {
        ok(bytesAreEqual(outbb, buf), "crypt results are equal");
    }
    return retval;
}

int CommonCryptoSymCTR(int argc, char *const *argv)
{
    CCCryptorStatus retval;
    CCCryptorRef cryptor;
    
	plan_tests(kTestTestCount);
    
    byteBuffer key = hexStringToBytes("2b7e151628aed2a6abf7158809cf4f3c");
    byteBuffer counter = hexStringToBytes("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff");
    
    retval = CCCryptorCreateWithMode(kCCEncrypt, kCCModeCTR, kCCAlgorithmAES128, 
                                     ccNoPadding, counter->bytes, key->bytes, key->len, 
                                     NULL, 0, 0, kCCModeOptionCTR_LE, &cryptor);

    
    ok(retval == kCCUnimplemented, "CTR Mode Encrypt unavailable for kCCModeOptionCTR_LE");

    retval = CCCryptorCreateWithMode(kCCEncrypt, kCCModeCTR, kCCAlgorithmAES128, 
                                     ccNoPadding, counter->bytes, key->bytes, key->len, 
                                     NULL, 0, 0, kCCModeOptionCTR_BE, &cryptor);
                                     
    ok(retval == kCCSuccess, "CTR Mode Encrypt");

    retval = doCrypt("6bc1bee22e409f96e93d7e117393172a",
                     "874d6191b620e3261bef6864990db6ce",
                     cryptor);
   
    
    ok(retval == kCCSuccess, "CTR Mode Encrypt");

    retval = doCrypt("ae2d8a571e03ac9c9eb76fac45af8e51",
                     "9806f66b7970fdff8617187bb9fffdff",
                     cryptor);
    
    
    ok(retval == kCCSuccess, "CTR Mode Encrypt");

    retval = doCrypt("30c81c46a35ce411e5fbc1191a0a52ef",
                     "5ae4df3edbd5d35e5b4f09020db03eab",
                     cryptor);
    
    ok(retval == kCCSuccess, "CTR Mode Encrypt");

    retval = doCrypt("f69f2445df4f9b17ad2b417be66c3710",
                     "1e031dda2fbe03d1792170a0f3009cee",
                     cryptor);
    
    ok(retval == kCCSuccess, "CTR Mode Encrypt");
    

    return 0;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 *  CCGCMTest.c
 *  CommonCrypto
 */

#include "capabilities.h"
#include <stdio.h>
#include <CommonCrypto/CommonCryptor.h>
#include <CommonCrypto/CommonCryptorSPI.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"

#if (CCSYMGCM == 0)
entryPoint(CommonCryptoSymGCM,"CommonCrypto Symmetric GCM Testing")
#else




static int kTestTestCount = 7;

int CommonCryptoSymGCM(int argc, char *const *argv) {
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    char *adata;
    char *tag;
    CCAlgorithm alg;
	int retval, accum = 0;

    alg		   = kCCAlgorithmAES128;
    
	plan_tests(kTestTestCount);
    
    /* testcase #1 */

    keyStr =     "00000000000000000000000000000000";
    adata =      "";
    iv =         "000000000000000000000000";
    plainText =  "";
    cipherText = "";
    tag =        "58e2fccefa7e3061367f1d57a4e7455a";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    
    ok(retval == 0, "AES-GCM Testcase 1");
    accum += retval;
    
    /* testcase #2 */

    keyStr =     "00000000000000000000000000000000";
    adata =      "";
    iv =         "000000000000000000000000";
    plainText =  "00000000000000000000000000000000";
    cipherText = "0388dace60b6a392f328c2b971b2fe78";
    tag =        "ab6e47d42cec13bdf53a67b21257bddf";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    ok(retval == 0, "AES-GCM Testcase 2");
    accum += retval;

    /* testcase #3 */

    keyStr =     "feffe9928665731c6d6a8f9467308308";
    adata =      "";
    iv =         "cafebabefacedbaddecaf888";
    plainText =  "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b391aafd255";
    cipherText = "42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091473f5985";
    tag =        "4d5c2af327cd64a62cf35abd2ba6fab4";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    ok(retval == 0, "AES-GCM Testcase 3");
    accum += retval;

    /* testcase #4 */

    keyStr =     "feffe9928665731c6d6a8f9467308308";
    adata =      "feedfacedeadbeeffeedfacedeadbeefabaddad2";
    iv =         "cafebabefacedbaddecaf888";
    plainText =  "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39";
    cipherText = "42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091";
    tag =        "5bc94fbc3221a5db94fae95ae7121a47";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    ok(retval == 0, "AES-GCM Testcase 4");
    accum += retval;

    /* testcase #5 */

    keyStr =     "feffe9928665731c6d6a8f9467308308";
    adata =      "feedfacedeadbeeffeedfacedeadbeefabaddad2";
    iv =         "cafebabefacedbad";
    plainText =  "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39";
    cipherText = "61353b4c2806934a777ff51fa22a4755699b2a714fcdc6f83766e5f97b6c742373806900e49f24b22b097544d4896b424989b5e1ebac0f07c23f4598";
    tag =        "3612d2e79e3b0785561be14aaca2fccb";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    ok(retval == 0, "AES-GCM Testcase 5");
    accum += retval;

    /* testcase #6 */

    keyStr =     "feffe9928665731c6d6a8f9467308308";
    adata = "feedfacedeadbeeffeedfacedeadbeefabaddad2";
    iv = "9313225df88406e555909c5aff5269aa6a7a9538534f7da1e4c303d2a318a728c3c0c95156809539fcf0e2429a6b525416aedbf5a0de6a57a637b39b";
    plainText = "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39";
    cipherText = "8ce24998625615b603a033aca13fb894be9112a5c3a211a8ba262a3cca7e2ca701e4a9a4fba43c90ccdcb281d48c7c6fd62875d2aca417034c34aee5";
    tag = "619cc5aefffe0bfa462af43c1699d050";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    ok(retval == 0, "AES-GCM Testcase 6");
    accum += retval;

    /* testcase #46 from BG (catchestheLTCbugofv1.15) */
    keyStr = "00000000000000000000000000000000";
    adata =  "688e1aa984de926dc7b4c47f44";
    iv =     "b72138b5a05ff5070e8cd94183f761d8";
    plainText =  "a2aab3ad8b17acdda288426cd7c429b7ca86b7aca05809c70ce82db25711cb5302eb2743b036f3d750d6cf0dc0acb92950d546db308f93b4ff244afa9dc72bcd758d2c";
    cipherText = "cbc8d2f15481a4cc7dd1e19aaa83de5678483ec359ae7dec2ab8d534e0906f4b4663faff58a8b2d733b845eef7c9b331e9e10eb2612c995feb1ac15a6286cce8b297a8";
    tag =    "8d2d2a9372626f6bee8580276a6366bf";

    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    ok(retval == 0, "AES-GCM Testcase 7");
    accum += retval;

    /* testcase #8 - #1 with NULL IV and AAD */
    
    keyStr =     "00000000000000000000000000000000";
    adata =      "";
    iv =         "";
    plainText =  "";
    cipherText = "";
    tag =        "66e94bd4ef8a2c3b884cfa59ca342b2e";
    
    retval = CCCryptorGCMTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);
    retval = CCCryptorGCMDiscreetTestCase(keyStr, iv, adata, tag, alg, cipherText, plainText);


    return accum != 0;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdio.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMOFB == 0)
entryPoint(CommonCryptoSymOFB,"CommonCrypto Symmetric OFB Testing")
#else
static int kTestTestCount = 5;

int CommonCryptoSymOFB(int argc, char *const *argv)
{
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    CCMode mode;
    CCAlgorithm alg;
    CCPadding padding;
    int retval, accum = 0;
    
	keyStr 	   = "000102030405060708090a0b0c0d0e0f";
	iv         = "0f0e0d0c0b0a09080706050403020100";
    mode 	   = kCCModeOFB;
    alg		= kCCAlgorithmAES128;
    padding = ccNoPadding;
    
	plan_tests(kTestTestCount);
    
	// 1
	plainText  = "0a";
	cipherText = "2a";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "OFB Mode single byte");
    accum += retval;
    
	// 15
	plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "2aa3f398be4651e20e15f6d666a493a";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "OFB Mode 15 byte");
    accum += retval;
    
	// 16
    plainText  = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a";
	cipherText = "2aa3f398be4651e20e15f6d666a49360a";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "OFB Mode single byte");
    accum += retval;
    
	// from OFBVarTxt256e KAT test 1
	keyStr 	   = "0000000000000000000000000000000000000000000000000000000000000000";
	iv         = "80000000000000000000000000000000";
    mode 	   = kCCModeOFB;
    alg		= kCCAlgorithmAES128;
    padding = ccNoPadding;
    plainText  = "00000000000000000000000000000000";
	cipherText = "ddc6bf790c15760d8d9aeb6f9a75fd4e";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
	ok(retval == 0, "OFB Mode OFBVarTxt256e KAT test 1");
    accum += retval;
    
	// from OFBVarTxt256e KAT test 13
	keyStr 	   = "0000000000000000000000000000000000000000000000000000000000000000";
	iv         = "fffc0000000000000000000000000000";
    mode 	   = kCCModeOFB;
    alg		= kCCAlgorithmAES128;
    padding = ccNoPadding;
    plainText  = "00000000000000000000000000000000";
	cipherText = "dc8f0e4915fd81ba70a331310882f6da";
    retval = CCModeTestCase(keyStr, iv, mode, alg, padding, cipherText, plainText);
    ok(retval == 0, "OFB Mode OFBVarTxt256e KAT test 13");
    accum += retval;
    
    return accum != 0;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 *  CCSymOffset.c
 *  CommonCrypto
 */

#include <stdio.h>
#include <CommonCrypto/CommonCryptor.h>
#include <CommonCrypto/CommonCryptorSPI.h>
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMOFFSET == 0)
entryPoint(CommonCryptoSymOffset,"CommonCrypto Symmetric Unaligned Testing")
#else



#define ILIKEEMDISBIG 4096
#define ALITTLEONTHESIDE 5


static int kTestTestCount = ALITTLEONTHESIDE;


int CommonCryptoSymOffset(int argc, char *const *argv) {
    int accum = 0;
    uint8_t iLikeBigBuffs[ILIKEEMDISBIG];
    uint8_t andICannotLie[ILIKEEMDISBIG];
    uint8_t iLikeEmRoundandBig[ILIKEEMDISBIG];
    int i;
    size_t moved;
    CCCryptorStatus retval;
    byteBuffer key = hexStringToBytes("010203040506070809000a0b0c0d0e0f");
    
    plan_tests(kTestTestCount);

    
    for(i=0; i<ALITTLEONTHESIDE; i++) {
        retval = CCCrypt(kCCEncrypt, kCCAlgorithmAES128, 0, key->bytes, key->len, NULL, iLikeBigBuffs+i, ILIKEEMDISBIG-16, andICannotLie+i, ILIKEEMDISBIG, &moved);
        retval = CCCrypt(kCCDecrypt, kCCAlgorithmAES128, 0, key->bytes, key->len, NULL, andICannotLie+i, moved, iLikeEmRoundandBig+i, ILIKEEMDISBIG, &moved);
        if(moved != (ILIKEEMDISBIG-16))
            retval = 99;
        else if(memcmp(iLikeBigBuffs+i, iLikeEmRoundandBig+i, moved))
            retval = 999;
        ok(retval == 0, "Encrypt/Decrypt Cycle");
        accum += retval;
    }
    
    return accum != 0;
}
#endif

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 *  CCRC2KAT.c
 *  CCRegressions
 *
 */

#include <stdio.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMRC2 == 0)
entryPoint(CommonCryptoSymRC2,"Common Crypto RC2 Test")
#else


#ifdef WEIRDCASE
static int kTestTestCount = 12;
#else
static int kTestTestCount = 8;
#endif


int CommonCryptoSymRC2(int argc, char *const *argv) {
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    CCAlgorithm alg;
    CCOptions options;
	int retval;
    int rkeylen, ekeylenBits;
    char printString[128];

    alg = kCCAlgorithmRC2;
    iv = NULL;
    options = 0;
	plan_tests(kTestTestCount);

    rkeylen = 8;
    ekeylenBits = 63;
    keyStr =    "0000000000000000";
    plainText = "0000000000000000";
    cipherText = "ebb773f993278eff";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);

    rkeylen = 8;
    ekeylenBits = 64;
    keyStr =    "ffffffffffffffff";
    plainText = "ffffffffffffffff";
    cipherText = "278b27e42e2f0d49";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);

    rkeylen = 8;
    ekeylenBits = 64;
    keyStr =    "3000000000000000";
    plainText = "1000000000000001";
    cipherText = "30649edf9be7d2c2";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);

#ifdef WEIRDCASE
    rkeylen = 1;
    ekeylenBits = 64;
    keyStr =    "88";
    plainText = "0000000000000000";
    cipherText = "61a8a244adacccf0";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);

    rkeylen = 7;
    ekeylenBits = 64;
    keyStr = "88bca90e90875a";
    plainText = "0000000000000000";
    cipherText = "6ccf4308974c267f";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    
    rkeylen = 16;
    ekeylenBits = 64;
    keyStr = "88bca90e90875a7f0f79c384627bafb2";
    plainText = "0000000000000000";
    cipherText = "1a807d272bbe5db1";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
#endif

    rkeylen = 16;
    ekeylenBits = 128;
    keyStr = "88bca90e90875a7f0f79c384627bafb2";
    plainText = "0000000000000000";
    cipherText = "2269552ab0f85ca6";
    retval = CCCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) One-Shot", rkeylen, ekeylenBits);
    ok(retval == 0, printString);
    retval = CCMultiCryptTestCase(keyStr, iv, alg, options, cipherText, plainText);
    sprintf(printString, "RC2 %d byte Key (effective %d bits) Multi", rkeylen, ekeylenBits);
    ok(retval == 0, printString);

    
    return 0;
}
#endif

/* Copyright 2006 Apple Computer, Inc.
 *
 * ccSymTest.c - test CommonCrypto symmetric encrypt/decrypt.
 */
#include "testmore.h"
#include "capabilities.h"
#if (CCSYMREGRESSION == 0)
entryPoint(CommonCryptoSymRegression,"CommonCrypto Base Behavior Regression Tests")
#else



#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <CommonCrypto/CommonCryptor.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>

// #include <CoreServices/../Frameworks/CarbonCore.framework/Headers/MacErrors.h>

/*
 * Defaults.
 */
#define LOOPS_DEF		500
#define MIN_DATA_SIZE	8
#define MAX_DATA_SIZE	10000						/* bytes */
#define MAX_KEY_SIZE	kCCKeySizeMaxRC4			/* bytes */
#define MAX_BLOCK_SIZE	kCCBlockSizeAES128			/* bytes */
#define LOOP_NOTIFY		250

/*
 * Enumerate algs our own way to allow iteration.
 */
typedef enum {
	ALG_AES_128 = 1,	/* 128 bit block, 128 bit key */
	ALG_AES_192,		/* 128 bit block, 192 bit key */
	ALG_AES_256,		/* 128 bit block, 256 bit key */
	ALG_DES,
	ALG_3DES,
	ALG_CAST,
	ALG_RC4,
	/* these aren't in CommonCrypto (yet?) */
	ALG_RC2,
	ALG_RC5,
	ALG_BFISH,
	ALG_ASC,
	ALG_NULL					/* normally not used */
} SymAlg;
#define ALG_FIRST			ALG_AES_128
#define ALG_LAST			ALG_RC4


#define LOG_SIZE			0
#if		LOG_SIZE
#define logSize(s)	diag s
#else
#define logSize(s)
#endif




static void
appGetRandomBytes(void *keyBytes, size_t keySizeInBytes)
{
	int fd;
    
    if((fd = open("/dev/random", O_RDONLY)) < 0) {
    	diag("Can't open Random\n");
        exit(0);
    }
    if(read(fd, keyBytes, keySizeInBytes) != keySizeInBytes) {
		diag("Can't read Random\n");
        exit(0);
    }
    close(fd);
}

/* min <= return <= max */
static unsigned 
genRand(unsigned min, unsigned max)
{
	unsigned i;
	if(min == max) {
		return min;
	}
	appGetRandomBytes(&i, 4);
	return (min + (i % (max - min + 1)));
}	


static void printCCError(const char *str, CCCryptorStatus crtn)
{
	const char *errStr;
	char unknownStr[200];
	
	switch(crtn) {
		case kCCSuccess: errStr = "kCCSuccess"; break;
		case kCCParamError: errStr = "kCCParamError"; break;
		case kCCBufferTooSmall: errStr = "kCCBufferTooSmall"; break;
		case kCCMemoryFailure: errStr = "kCCMemoryFailure"; break;
		case kCCAlignmentError: errStr = "kCCAlignmentError"; break;
		case kCCDecodeError: errStr = "kCCDecodeError"; break;
		case kCCUnimplemented: errStr = "kCCUnimplemented"; break;
		default:
			sprintf(unknownStr, "Unknown(%ld)\n", (long)crtn);
			errStr = unknownStr;
			break;
	}
	diag("***%s returned %s\n", str, errStr);
}

/* max context size */
#define CC_MAX_CTX_SIZE	kCCContextSizeRC4

/* 
 * We write a marker at end of expected output and at end of caller-allocated 
 * CCCryptorRef, and check at the end to make sure they weren't written 
 */
#define MARKER_LENGTH	8
#define MARKER_BYTE		0x7e

/* 
 * Test harness for CCCryptor with lots of options. 
 */
static CCCryptorStatus doCCCrypt(
	bool forEncrypt,
	CCAlgorithm encrAlg,			
	bool doCbc,
	bool doPadding,
	const void *keyBytes, size_t keyLen,
	const void *iv,
	bool randUpdates,
	bool inPlace,								/* !doPadding only */
	size_t ctxSize,								/* if nonzero, we allocate ctx */
	bool askOutSize,
	const uint8_t *inText, size_t inTextLen,
	uint8_t **outText, size_t *outTextLen)		/* both returned, WE malloc */
{
	CCCryptorRef	cryptor = NULL;
	CCCryptorStatus crtn;
	CCOperation		op = forEncrypt ? kCCEncrypt : kCCDecrypt;
	CCOptions		options = 0;
	uint8_t			*outBuf = NULL;			/* mallocd output buffer */
	uint8_t			*outp;					/* running ptr into outBuf */
	const uint8_t		*inp;					/* running ptr into inText */
	size_t			outLen = 0;					/* bytes remaining in outBuf */
	size_t			toMove;					/* bytes remaining in inText */
	size_t			thisMoveOut;			/* output from CCCryptUpdate()/CCCryptFinal() */
	size_t			outBytes;				/* total bytes actually produced in outBuf */
	char			ctx[CC_MAX_CTX_SIZE];	/* for CCCryptorCreateFromData() */
	uint8_t			*textMarker = NULL;		/* 8 bytes of marker here after expected end of 
											 * output */
	char			*ctxMarker = NULL;		/* ditto for caller-provided context */
	unsigned		dex;
	size_t			askedOutSize;			/* from the lib */
	size_t			thisOutLen;				/* dataOutAvailable we use */
	

	if(0) diag("%s %s %s keylen %d %s %s %s %s %s input length %ld\n", 
    	forEncrypt ? "Encrypting": "Decrypting", 
    	doCbc ? "CBC": "ECB", 
    	doPadding ? "Padding ON": "Padding OFF",
        (int) keyLen,
        iv ? "IV Provided": "No IV Provided",
		randUpdates ? "Random Updates": "Non-Random Updates", 
		inPlace ? "In Place": "Separate Buffers", 
    	ctxSize ? "We Allocate": "CC Allocated", 
    	askOutSize ? "Ask OutSize": "Don't Ask OutSize", 
		inTextLen);
         
	if(ctxSize > CC_MAX_CTX_SIZE) {
		diag("***HEY! Adjust CC_MAX_CTX_SIZE!\n");
		exit(1);
	}
	if(!doCbc) {
		options |= kCCOptionECBMode;
	}
	if(doPadding) {
		options |= kCCOptionPKCS7Padding;
	}
	
	/* just hack this one */
	outLen = inTextLen;
	if(forEncrypt) {
		outLen += MAX_BLOCK_SIZE;
	}
	
	outBuf = (uint8_t *)malloc(outLen + MARKER_LENGTH);
	memset(outBuf, 0xEE, outLen + MARKER_LENGTH);
	
	/* library should not touch this memory */
	textMarker = outBuf + outLen;
	memset(textMarker, MARKER_BYTE, MARKER_LENGTH);
	
	/* subsequent errors to errOut: */

	if(inPlace) {
		memmove(outBuf, inText, inTextLen);
		inp = outBuf;
	}
	else {
		inp = inText;
	}

	if(!randUpdates) {
		/* one shot */
		if(askOutSize) {
			crtn = CCCrypt(op, encrAlg, options,
				keyBytes, keyLen, iv,
				inp, inTextLen,
				outBuf, 0, &askedOutSize);
			if(crtn != kCCBufferTooSmall) {
				diag("***Did not get kCCBufferTooSmall as expected\n");
				diag("   alg %d inTextLen %lu cbc %d padding %d keyLen %lu\n",
					(int)encrAlg, (unsigned long)inTextLen, (int)doCbc, (int)doPadding,
					(unsigned long)keyLen);
				printCCError("CCCrypt", crtn);
				crtn = -1;
				goto errOut;
			}
			outLen = askedOutSize;
		}
		crtn = CCCrypt(op, encrAlg, options,
			keyBytes, keyLen, iv,
			inp, inTextLen,
			outBuf, outLen, &outLen);
		if(crtn) {
			printCCError("CCCrypt", crtn);
			goto errOut;
		}
		*outText = outBuf;
		*outTextLen = outLen;
		goto errOut;
	}
	
	/* random multi updates */
	if(ctxSize) {
		size_t ctxSizeCreated;
		
		if(askOutSize) {
			crtn = CCCryptorCreateFromData(op, encrAlg, options,
				keyBytes, keyLen, iv,
				ctx, 0 /* ctxSize */,
				&cryptor, &askedOutSize);
			if(crtn != kCCBufferTooSmall) {
				diag("***Did not get kCCBufferTooSmall as expected\n");
				printCCError("CCCryptorCreateFromData", crtn);
				crtn = -1;
				goto errOut;
			}
			ctxSize = askedOutSize;
		}
		crtn = CCCryptorCreateFromData(op, encrAlg, options,
			keyBytes, keyLen, iv,
			ctx, ctxSize, &cryptor, &ctxSizeCreated);
		if(crtn) {
			printCCError("CCCryptorCreateFromData", crtn);
			return crtn;
		}
		ctxMarker = ctx + ctxSizeCreated;
		memset(ctxMarker, MARKER_BYTE, MARKER_LENGTH);
	}
	else {
		crtn = CCCryptorCreate(op, encrAlg, options,
			keyBytes, keyLen, iv,
			&cryptor);
		if(crtn) {
			printCCError("CCCryptorCreate", crtn);
			return crtn;
		}
	}
	
	toMove = inTextLen;		/* total to go */
	outp = outBuf;
	outBytes = 0;			/* bytes actually produced in outBuf */
	
	while(toMove) {
		size_t thisMoveIn;			/* input to CCryptUpdate() */
		
		thisMoveIn = (size_t) genRand(1, (unsigned int) toMove);
		logSize(("###ptext segment len %lu\n", (unsigned long)thisMoveIn)); 
		if(askOutSize) {
			thisOutLen = CCCryptorGetOutputLength(cryptor, thisMoveIn, false);
		}
		else {
			thisOutLen = outLen;
		}
		crtn = CCCryptorUpdate(cryptor, inp, thisMoveIn,
			outp, thisOutLen, &thisMoveOut);
		if(crtn) {
			printCCError("CCCryptorUpdate", crtn);
			goto errOut;
		}
		inp			+= thisMoveIn;
		toMove		-= thisMoveIn;
		outp		+= thisMoveOut;
		outLen   	-= thisMoveOut;
		outBytes	+= thisMoveOut;
	}
	
	if(doPadding) {
		/* Final is not needed if padding is disabled */
		if(askOutSize) {
			thisOutLen = CCCryptorGetOutputLength(cryptor, 0, true);
		}
		else {
			thisOutLen = outLen;
		}
		crtn = CCCryptorFinal(cryptor, outp, thisOutLen, &thisMoveOut);
	}
	else {
		thisMoveOut = 0;
		crtn = kCCSuccess;
	}
	
	if(crtn) {
		printCCError("CCCryptorFinal", crtn);
		goto errOut;
	}
	
	outBytes += thisMoveOut;
	*outText = outBuf;
	*outTextLen = outBytes;
	crtn = kCCSuccess;

	for(dex=0; dex<MARKER_LENGTH; dex++) {
		if(textMarker[dex] != MARKER_BYTE) {
			diag("***lib scribbled on our textMarker memory (op=%s)!\n",
				forEncrypt ? "encrypt" : "decrypt");
			crtn = (CCCryptorStatus)-1;
		}
	}
	if(ctxSize) {
		for(dex=0; dex<MARKER_LENGTH; dex++) {
			if(ctxMarker[dex] != MARKER_BYTE) {
				diag("***lib scribbled on our ctxMarker memory (op=%s)!\n",
					forEncrypt ? "encrypt" : "decrypt");
				crtn = (CCCryptorStatus)-1;
			}
		}
	}
	
errOut:
	if(crtn) {
		if(outBuf) {
			free(outBuf);
		}
	}
	if(cryptor) {
		CCCryptorRelease(cryptor);
	}
	return crtn;
}

static int doTest(const uint8_t *ptext,
	size_t ptextLen,
	CCAlgorithm encrAlg,			
	bool doCbc,
	bool doPadding,
	bool nullIV,			/* if CBC, use NULL IV */
	uint32_t keySizeInBytes,
	bool stagedEncr,
	bool stagedDecr,
	bool inPlace,	
	size_t ctxSize,		
	bool askOutSize,
	bool quiet)
{
	uint8_t			keyBytes[MAX_KEY_SIZE];
	uint8_t			iv[MAX_BLOCK_SIZE];
	uint8_t			*ivPtrEncrypt;
	uint8_t			*ivPtrDecrypt;
	uint8_t			*ctext = NULL;		/* mallocd by doCCCrypt */
	size_t			ctextLen = 0;
	uint8_t			*rptext = NULL;		/* mallocd by doCCCrypt */
	size_t			rptextLen;
	CCCryptorStatus	crtn;
	int				rtn = 0;
	
	/* random key */
	appGetRandomBytes(keyBytes, keySizeInBytes);
	
	/* random IV if needed */
	if(doCbc) {
		if(nullIV) {
			memset(iv, 0, MAX_BLOCK_SIZE);
			
			/* flip a coin, give one side NULL, the other size zeroes */
			if(genRand(1,2) == 1) {
				ivPtrEncrypt = NULL;
				ivPtrDecrypt = iv;
			}
			else {
				ivPtrEncrypt = iv;
				ivPtrDecrypt = NULL;
			}
		}
		else {
			appGetRandomBytes(iv, MAX_BLOCK_SIZE);
			ivPtrEncrypt = iv;
			ivPtrDecrypt = iv;
		}
	}	
	else {
		ivPtrEncrypt = NULL;
		ivPtrDecrypt = NULL;
	}

	crtn = doCCCrypt(true, encrAlg, doCbc, doPadding,
		keyBytes, keySizeInBytes, ivPtrEncrypt,
		stagedEncr, inPlace, ctxSize, askOutSize,
		ptext, ptextLen,
		&ctext, &ctextLen);
    
    ok(crtn == 0, "doCCCrypt");
	if(crtn) {
        diag("Test Failure Encrypt encrAlg = %d dodCbc = %d doPadding %d\n", encrAlg, doCbc, doPadding);
	}
	
	logSize(("###ctext len %lu\n", ctextLen)); 
	crtn = doCCCrypt(false, encrAlg, doCbc, doPadding,
		keyBytes, keySizeInBytes, ivPtrDecrypt,
		stagedDecr, inPlace, ctxSize, askOutSize,
		ctext, ctextLen,
		&rptext, &rptextLen);
    ok(crtn == 0, "doCCCrypt");
	if(crtn) {
        diag("Test Failure Encrypt encrAlg = %d dodCbc = %d doPadding %d\n", encrAlg, doCbc, doPadding);
	}

	logSize(("###rptext len %lu\n", rptextLen)); 
	
	/* compare ptext, rptext */
	if(ptextLen != rptextLen) {
		diag("Ptext length mismatch: expect %lu, got %lu\n", ptextLen, rptextLen);
	}
	if(memcmp(ptext, rptext, ptextLen)) {
		diag("***data miscompare\n");
	}
abort:
	if(ctext) {
		free(ctext);
	}
	if(rptext) {
		free(rptext);
	}
	return rtn;
}

static bool isBitSet(unsigned bit, unsigned word) 
{
	if(bit > 31) {
		diag("We don't have that many bits\n");
		exit(1);
	}
	unsigned mask = 1 << bit;
	return (word & mask) ? true : false;
}


static int kTestTestCount = 1;


int CommonCryptoSymRegression(int argc, char *const *argv)
{
	unsigned			loop;
	uint8_t				*ptext;
	size_t				ptextLen;
	bool				stagedEncr = false;
	bool				stagedDecr = false;
	bool				doPadding;
	bool				doCbc = false;
	bool				nullIV;
	const char			*algStr;
	CCAlgorithm			encrAlg;	
	int					i;
	int					currAlg;		// ALG_xxx
	uint32_t				minKeySizeInBytes;
	uint32_t				maxKeySizeInBytes;
	uint32_t				keySizeInBytes = 0;
	int					rtn = 0;
	uint32_t				blockSize;		// for noPadding case
	size_t				ctxSize;		// always set per alg
	size_t				ctxSizeUsed;	// passed to doTest
	bool				askOutSize;		// inquire output size each op
	
	/*
	 * User-spec'd params
	 */
	bool		keySizeSpec = false;		// false: use rand key size
	SymAlg		minAlg = ALG_FIRST;
	SymAlg		maxAlg = ALG_LAST;
	unsigned	loops = LOOPS_DEF;
	bool		verbose = false;
	size_t		minPtextSize = MIN_DATA_SIZE;
	size_t		maxPtextSize = MAX_DATA_SIZE;
	bool		quiet = true;
	unsigned	pauseInterval = 0;
	bool		paddingSpec = false;		// true: user calls doPadding, const
	bool		cbcSpec = false;			// ditto for doCbc
	bool		stagedSpec = false;			// ditto for stagedEncr and stagedDecr
	bool		inPlace = false;			// en/decrypt in place for ECB
	bool		allocCtxSpec = false;		// use allocCtx
	bool		allocCtx = false;			// allocate context ourself

	plan_tests(kTestTestCount);
	

	ptext = (uint8_t *)malloc(maxPtextSize);
	if(ptext == NULL) {
		diag("Insufficient heap space\n");
		exit(1);
	}
	/* ptext length set in test loop */
	
	if(!quiet) diag("Starting ccSymTest; args: ");
	for(i=1; i<argc; i++) {
		if(!quiet) diag("%s ", argv[i]);
	}
	if(!quiet) diag("\n");
	
	if(pauseInterval) {
		fpurge(stdin);
		diag("Top of test; hit CR to proceed: ");
		getchar();
	}

	for(currAlg=minAlg; currAlg<=maxAlg; currAlg++) {
		switch(currAlg) {
			case ALG_DES:
				encrAlg = kCCAlgorithmDES;
				blockSize = kCCBlockSizeDES;
				minKeySizeInBytes = kCCKeySizeDES;
				maxKeySizeInBytes = minKeySizeInBytes;
				ctxSize = kCCContextSizeDES;
				algStr = "DES";
                diag("Running DES Tests");
				break;
			case ALG_3DES:
				encrAlg = kCCAlgorithm3DES;
				blockSize = kCCBlockSize3DES;
				minKeySizeInBytes = kCCKeySize3DES;
				maxKeySizeInBytes = minKeySizeInBytes;
				ctxSize = kCCContextSize3DES;
				
				algStr = "3DES";
                diag("Running 3DES Tests");
				break;
			case ALG_AES_128:
				encrAlg = kCCAlgorithmAES128;
				blockSize = kCCBlockSizeAES128;
				minKeySizeInBytes = kCCKeySizeAES128;
				maxKeySizeInBytes = minKeySizeInBytes;
				ctxSize = kCCContextSizeAES128;
				algStr = "AES128";
                diag("Running AES (128 bit key) Tests");
				break;
			case ALG_AES_192:
				encrAlg = kCCAlgorithmAES128;
				blockSize = kCCBlockSizeAES128;
				minKeySizeInBytes = kCCKeySizeAES192;
				maxKeySizeInBytes = minKeySizeInBytes;
				ctxSize = kCCContextSizeAES128;
				algStr = "AES192";
                diag("Running AES (192 bit key) Tests");
				break;
			case ALG_AES_256:
				encrAlg = kCCAlgorithmAES128;
				blockSize = kCCBlockSizeAES128;
				minKeySizeInBytes = kCCKeySizeAES256;
				maxKeySizeInBytes = minKeySizeInBytes;
				ctxSize = kCCContextSizeAES128;
				algStr = "AES256";
                diag("Running AES (256 bit key) Tests");
				break;
			case ALG_CAST:
				encrAlg = kCCAlgorithmCAST;
				blockSize = kCCBlockSizeCAST;
				minKeySizeInBytes = kCCKeySizeMinCAST;
				maxKeySizeInBytes = kCCKeySizeMaxCAST;
				ctxSize = kCCContextSizeCAST;
				algStr = "CAST";
                diag("Running CAST Tests");
				break;
			case ALG_RC4:
				encrAlg = kCCAlgorithmRC4;
				blockSize = 0;
				minKeySizeInBytes = kCCKeySizeMinRC4;
				maxKeySizeInBytes = kCCKeySizeMaxRC4;
				ctxSize = kCCContextSizeRC4;
				algStr = "RC4";
                diag("Running RC4 Tests");
				break;
			default:
				diag("***BRRZAP!\n");
				exit(1);
		}
		if(!quiet || verbose) {
			diag("Testing alg %s\n", algStr);
		}
		for(loop=1; ; loop++) {
			ptextLen = (size_t) genRand((unsigned int) minPtextSize, (unsigned int) maxPtextSize);
			appGetRandomBytes(ptext, ptextLen);
			
			/* per-loop settings */
			if(!keySizeSpec) {
				if(minKeySizeInBytes == maxKeySizeInBytes) {
					keySizeInBytes = minKeySizeInBytes;
				}
				else {
					keySizeInBytes = genRand(minKeySizeInBytes, maxKeySizeInBytes);
				}
			}
			if(blockSize == 0) {
				/* stream cipher */
				doCbc = false;
				doPadding = false;
			}
			else {
				if(!cbcSpec) {
					doCbc = isBitSet(0, loop);
				}
				if(!paddingSpec) {
					doPadding = isBitSet(1, loop);
				}
			}
			if(!doPadding && (blockSize != 0)) {
				/* align plaintext */
				ptextLen = (ptextLen / blockSize) * blockSize;
				if(ptextLen == 0) {
					ptextLen = blockSize;
				}
			}
			if(!stagedSpec) {
				stagedEncr = isBitSet(2, loop);
				stagedDecr = isBitSet(3, loop);
			}
			if(doCbc) {
				nullIV = isBitSet(4, loop);
			}
			else {
				nullIV = false;
			}
			inPlace = isBitSet(5, loop);
			if(allocCtxSpec) {
				ctxSizeUsed = allocCtx ? ctxSize : 0;
			}
			else if(isBitSet(6, loop)) {
				ctxSizeUsed = ctxSize;
			}
			else {
				ctxSizeUsed = 0;
			}
			askOutSize = isBitSet(7, loop);
			if(!quiet) {
			   	if(verbose || ((loop % LOOP_NOTIFY) == 0)) {
					diag("..loop %3d ptextLen %lu keyLen %d cbc=%d padding=%d stagedEncr=%d "
							"stagedDecr=%d\n",
						loop, (unsigned long)ptextLen, (int)keySizeInBytes, 
						(int)doCbc, (int)doPadding,
					 	(int)stagedEncr, (int)stagedDecr);
					diag("           nullIV %d inPlace %d ctxSize %d askOutSize %d\n",
						(int)nullIV, (int)inPlace, (int)ctxSizeUsed, (int)askOutSize);
				}
			}
			
			if(doTest(ptext, ptextLen,
					encrAlg, doCbc, doPadding, nullIV,
					keySizeInBytes,
					stagedEncr,	stagedDecr, inPlace, ctxSizeUsed, askOutSize,
					quiet)) {
				rtn = 1;
				break;
			}
			if(pauseInterval && ((loop % pauseInterval) == 0)) {
				char c;
				fpurge(stdin);
				diag("Hit CR to proceed, q to abort: ");
				c = getchar();
				if(c == 'q') {
					goto testDone;
				}
			}
			if(loops && (loop == loops)) {
				break;
			}
		}	/* main loop */
		if(rtn) {
			break;
		}
		
	}	/* for algs */
	
testDone:

    ok(rtn == 0, "ccSymTest");

	if(pauseInterval) {
		fpurge(stdin);
		diag("ModuleDetach/Unload complete; hit CR to exit: ");
		getchar();
	}
	if((rtn == 0) && !quiet) {
		diag("%s test complete\n", argv[0]);
	}
	free(ptext);
	return rtn;
}
#endif

#include <stdio.h>
#include <CommonCrypto/CommonCryptor.h>
#include "CCCryptorTestFuncs.h"
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMZEROLEN == 0)
entryPoint(CommonCryptoSymZeroLength,"CommonCrypto Symmetric Zero-Length Testing")
#else

static int kTestTestCount = 4;


int CommonCryptoSymZeroLength (int argc, char *const *argv) 
{
	char *keyStr;
	char *iv;
	char *plainText;
	char *cipherText;
    int retval, accum = 0;

	plan_tests(kTestTestCount);

	/* Two Test cases - "" and NULL WITH an IV */
        
	keyStr 	   = "000102030405060708090a0b0c0d0e0f";
	iv         = "0f0e0d0c0b0a09080706050403020100";

	// 1
	plainText  = "";
	cipherText = "efddc425a6fa0c5f25e444092eb0f503";
    retval = CCCryptTestCase(keyStr, iv, kCCAlgorithmAES128, kCCOptionPKCS7Padding, cipherText, plainText);
    ok(retval == 0, "CBC Zero Length String, IV defined");
    accum += retval;
    

	// 1
	plainText  = NULL;
	cipherText = "efddc425a6fa0c5f25e444092eb0f503";
    retval = CCCryptTestCase(keyStr, iv, kCCAlgorithmAES128, kCCOptionPKCS7Padding, cipherText, plainText);
    ok(retval == 0, "CBC NULL String, IV defined");
    accum += retval;
    
	/* Two more Test cases - "" and NULL WITH IV=NULL */
        
	keyStr 	   = "000102030405060708090a0b0c0d0e0f";
	iv         = NULL;

	// 1
	plainText  = "";
	cipherText = "954f64f2e4e86e9eee82d20216684899";
    retval = CCCryptTestCase(keyStr, iv, kCCAlgorithmAES128, kCCOptionPKCS7Padding, cipherText, plainText);
    ok(retval == 0, "CBC Zero Length String, IV NULL");
    accum += retval;
    

	// 1
	plainText  = NULL;
	cipherText = "954f64f2e4e86e9eee82d20216684899";
    retval = CCCryptTestCase(keyStr, iv, kCCAlgorithmAES128, kCCOptionPKCS7Padding, cipherText, plainText);
    //retval = 0;
    ok(retval == 0, "CBC NULL String, IV NULL");
    accum += retval;

    return accum != 0;
}
#endif

//
//  CommonCryptoSymmetricWrap.c
//  CCRegressions
//
//  Created by Richard Murphy on 1/13/12.
//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
//

#include <stdio.h>
#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCSYMWRAP == 0)
entryPoint(CommonSymmetricWrap,"Symmetric Wrap")
#else

#include <CommonCrypto/CommonSymmetricKeywrap.h>


static int
wrapTest(char *kekstr, char *keystr, char *wrapped_keystr)
{
    byteBuffer kek, key, wrapped_key, bb;    
        
    kek = hexStringToBytes(kekstr);
    key = hexStringToBytes(keystr);
    if(wrapped_keystr) wrapped_key = hexStringToBytes(wrapped_keystr);
    else wrapped_key = hexStringToBytes("0x00");
	const uint8_t *iv =  CCrfc3394_iv;
	const size_t ivLen = CCrfc3394_ivLen;
	size_t wrapped_size = CCSymmetricWrappedSize(kCCWRAPAES, key->len);
	uint8_t wrapped[wrapped_size];
    
    // printf("Wrapped Size %lu\n", wrapped_size);

    ok(CCSymmetricKeyWrap(kCCWRAPAES, iv , ivLen, kek->bytes, kek->len, key->bytes, key->len, wrapped, &wrapped_size) == 0, "function is successful");
    if(wrapped_keystr) {
        bb = bytesToBytes(wrapped, wrapped_size);
        if(!strcmp(wrapped_keystr, "")) printByteBuffer(bb, "Result: ");
        ok(bytesAreEqual(bb, wrapped_key), "Equal to expected wrapping");
        // printByteBuffer(bb, "Result: ");
        // printByteBuffer(wrapped_key, "Expected: ");
        free(bb);
    }
        
	size_t unwrapped_size = CCSymmetricUnwrappedSize(kCCWRAPAES, wrapped_size);
	uint8_t unwrapped[unwrapped_size];
    
    ok(CCSymmetricKeyUnwrap(kCCWRAPAES, iv, ivLen, kek->bytes, kek->len, wrapped, wrapped_size, unwrapped, &unwrapped_size) == 0, "function is successful");
    bb = bytesToBytes(unwrapped, unwrapped_size);
    ok(bytesAreEqual(bb, key), "Equal to original key");
    free(bb);
    free(kek);
    free(key);
    free(wrapped_key);

    return 0;
}





static int kTestTestCount = 35;

int
CommonSymmetricWrap(int argc, char *const *argv)
{
    char *kek, *key, *wrapped_key;
    int accum = 0;
	plan_tests(kTestTestCount);
    
    diag("Test 1");
    kek = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
    key = "00112233445566778899aabbccddeeff000102030405060708090a0b0c0d0e0f";
    wrapped_key = "28C9F404C4B810F4CBCCB35CFB87F8263F5786E2D80ED326CBC7F0E71A99F43BFB988B9B7A02DD21";
    accum |= wrapTest(kek, key, wrapped_key);
    
    diag("Test 2");
    kek = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
    key = "00112233445566778899aabbccddeeff00010203040506070";
    wrapped_key = "a8f9bc1612c68b3ff6e6f4fbe30e71e4769c8b80a32cb8958cd5d17d6b254da1";
    accum |= wrapTest(kek, key, wrapped_key);

    diag("Test 3");
    byteBuffer keybuf = mallocByteBuffer(2048);
    for(int i=0; i<2048; i++) keybuf->bytes[i] = i%256;
    key = bytesToHexString(keybuf);
    accum |= wrapTest(kek, key, NULL);
    
    diag("Test Vectors from RFC 3394");
    diag("4.1 Wrap 128 bits of Key Data with a 128-bit KEK");
    kek = "000102030405060708090A0B0C0D0E0F";
    key = "00112233445566778899AABBCCDDEEFF";
    wrapped_key = "1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5";
    accum |= wrapTest(kek, key, wrapped_key);

    diag("4.2 Wrap 128 bits of Key Data with a 192-bit KEK");
    kek = "000102030405060708090A0B0C0D0E0F1011121314151617";
    key = "00112233445566778899AABBCCDDEEFF";
    wrapped_key = "96778B25AE6CA435F92B5B97C050AED2468AB8A17AD84E5D";
    accum |= wrapTest(kek, key, wrapped_key);

    diag("4.3 Wrap 128 bits of Key Data with a 256-bit KEK");
    kek = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F";
    key = "00112233445566778899AABBCCDDEEFF";
    wrapped_key = "64E8C3F9CE0F5BA263E9777905818A2A93C8191E7D6E8AE7";
    accum |= wrapTest(kek, key, wrapped_key);

    diag("4.4 Wrap 192 bits of Key Data with a 192-bit KEK");
    kek = "000102030405060708090A0B0C0D0E0F1011121314151617";
    key = "00112233445566778899AABBCCDDEEFF0001020304050607";
    wrapped_key = "031D33264E15D33268F24EC260743EDCE1C6C7DDEE725A936BA814915C6762D2";
    accum |= wrapTest(kek, key, wrapped_key);

    diag("4.5 Wrap 192 bits of Key Data with a 256-bit KEK");
    kek = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F";
    key = "00112233445566778899AABBCCDDEEFF0001020304050607";
    wrapped_key = "A8F9BC1612C68B3FF6E6F4FBE30E71E4769C8B80A32CB8958CD5D17D6B254DA1";
    accum |= wrapTest(kek, key, wrapped_key);

    diag("4.6 Wrap 256 bits of Key Data with a 256-bit KEK");
    kek = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F";
    key = "00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F";
    wrapped_key = "28C9F404C4B810F4CBCCB35CFB87F8263F5786E2D80ED326CBC7F0E71A99F43BFB988B9B7A02DD21";
    accum |= wrapTest(kek, key, wrapped_key);
    
    return 0;
}
#endif

#include <Availability.h>
#include "capabilities.h"
#include "testmore.h"
#include "testbyteBuffer.h"

#if (CCDH == 0)
entryPoint(CommonDH,"Diffie-Hellman Key Agreement")
#else

#include "CommonDH.h"
static int kTestTestCount = 2;

int CommonDH(int argc, char *const *argv) {
    CCDHRef dh1, dh2;

    plan_tests(kTestTestCount);
    
    
    dh1 = CCDHCreate(kCCDHRFC2409Group2);
    ok(dh1 == NULL, "kCCDHRFC2409Group2 isn't implemented in corecrypto");

    dh1 = CCDHCreate(kCCDHRFC3526Group5);
    ok(dh1 != NULL, "got a DH ref");
    
    dh2 = CCDHCreate(kCCDHRFC3526Group5);
    ok(dh2 != NULL, "got a DH ref");
    
    diag("CCDHRefs Created\n");

    uint8_t pubkey1[4096], pubkey2[4096];
    size_t len1 = 4096, len2 = 4096;
    int ret1 = CCDHGenerateKey(dh1, pubkey1, &len1);
    int ret2 = CCDHGenerateKey(dh2, pubkey2, &len2);

    ok(ret1 != -1 && ret2 != -1, "pubkeys generated");

    diag("Pubkeys Created\n");
    
    uint8_t sharedkey1[4096], sharedkey2[4096];
    size_t slen1 = 4096, slen2 = 4096;

    int sret1 = CCDHComputeKey(sharedkey1, &slen1, pubkey2, len2, dh1);
    int sret2 = CCDHComputeKey(sharedkey2, &slen2, pubkey1, len1, dh2);
    
    ok(sret1 != -1 && sret2 != -1, "shared keys generated");

    ok(slen1 == slen2, "shared key lengths are equal");
    
    ok(memcmp(sharedkey1, sharedkey2, slen1) == 0, "shared keys are equal");
    
    
    
    CCDHRelease(dh1);
    ok(1, "Didn't crash");


    return 0;
}

#endif

#include <stdio.h>
#include "testbyteBuffer.h"
#include "capabilities.h"
#include "testmore.h"
#include <string.h>

#define COMMON_DIGEST_FOR_RFC_1321
#include <CommonCrypto/CommonCryptor.h>
#include <CommonCrypto/CommonDigest.h>
#include <CommonCrypto/CommonHMAC.h>

#ifdef CCDIGEST
#include <CommonCrypto/CommonDigestSPI.h>
#endif

#ifdef CCKEYDERIVATION
#include <CommonCrypto/CommonKeyDerivation.h>
#endif

static char *digestName(CCDigestAlgorithm digestSelector) {
    switch(digestSelector) {
        default: return "None";
        case  kCCDigestMD2: return "MD2";
        case  kCCDigestMD4: return "MD4";
        case  kCCDigestMD5: return "MD5";
        case  kCCDigestRMD128: return "RMD128";
        case  kCCDigestRMD160: return "RMD160";
        case  kCCDigestRMD256: return "RMD256";
        case  kCCDigestRMD320: return "RMD320";
        case  kCCDigestSHA1: return "SHA1";
        case  kCCDigestSHA224: return "SHA224";
        case  kCCDigestSHA256: return "SHA256";
        case  kCCDigestSHA384: return "SHA384";
        case  kCCDigestSHA512: return "SHA512";
        case  kCCDigestSkein128: return "Skein128";
        case  kCCDigestSkein160: return "Skein160";
        case  kCCDigestSkein224: return "Skein224";
        case  kCCDigestSkein256: return "Skein256";
        case  kCCDigestSkein384: return "Skein384";
        case  kCCDigestSkein512: return "Skein512";
    }
}

static size_t nullstrlen(const char *s) {
    if(!s) return 0;
    return strlen(s);
}

#define MAX_DIGEST_SIZE CC_SHA512_DIGEST_LENGTH

#if (CCKEYDERIVATION == 1)
static int
PBKDF2Test(char *password, uint8_t *salt, size_t saltlen, int rounds, CCDigestAlgorithm PRF, int dklen, char *expected)
{
    byteBuffer derivedKey;
    byteBuffer expectedBytes;
    char outbuf[80];
    int retval = 0;
    
    if(expected) expectedBytes = hexStringToBytes(expected);
    derivedKey = mallocByteBuffer(dklen);
    switch(PRF) {
        case 0: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), (uint8_t *) salt, saltlen, 0, rounds, derivedKey->bytes, derivedKey->len); break;
        case kCCDigestSHA1: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA1, rounds, derivedKey->bytes, derivedKey->len); break;
        case kCCDigestSHA224: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA224, rounds, derivedKey->bytes, derivedKey->len); break;
        case kCCDigestSHA256: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA256, rounds, derivedKey->bytes, derivedKey->len); break;
        case kCCDigestSHA384: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA384, rounds, derivedKey->bytes, derivedKey->len); break;
        case kCCDigestSHA512: CCKeyDerivationPBKDF(kCCPBKDF2, password, strlen(password), salt, saltlen, kCCPRFHmacAlgSHA512, rounds, derivedKey->bytes, derivedKey->len); break;
        default: return 1;
    }
	sprintf(outbuf, "PBKDF2-HMAC-%s test for %s", digestName(PRF), password);
    
    if(expected) {
        ok(bytesAreEqual(derivedKey, expectedBytes), outbuf);
        
        if(!bytesAreEqual(derivedKey, expectedBytes)) {
            diag("KEYDERIVE FAIL: PBKDF2-HMAC-%s(\"%s\")\n expected %s\n      got %s\n", digestName(PRF), password, expected, bytesToHexString(derivedKey));
            retval = 1;
        } else {
            //printf("KEYDERIVE PASS: PBKDF2-HMAC-%s(\"%s\")\n", digestName(PRF), password);
        }
        free(expectedBytes);
    }
    free(derivedKey);
    return retval;
}
#endif

static byteBuffer mallocDigestBuffer(CCDigestAlgorithm digestSelector) {
    size_t len;
    switch(digestSelector) {
        default: len = CCDigestGetOutputSize(digestSelector); break;
        case kCCDigestMD2: len = CC_MD2_DIGEST_LENGTH; break;
        case kCCDigestMD4: len = CC_MD4_DIGEST_LENGTH; break;
        case kCCDigestMD5: len = CC_MD5_DIGEST_LENGTH; break;
        case kCCDigestSHA1: len = CC_SHA1_DIGEST_LENGTH; break;
        case kCCDigestSHA224: len = CC_SHA224_DIGEST_LENGTH; break;
        case kCCDigestSHA256: len = CC_SHA256_DIGEST_LENGTH; break;
        case kCCDigestSHA384: len = CC_SHA384_DIGEST_LENGTH; break;
        case kCCDigestSHA512: len = CC_SHA512_DIGEST_LENGTH; break;
    }
    return mallocByteBuffer(len);
}

static void
OneShotHmac(CCHmacAlgorithm hmacAlg, uint8_t *key, size_t keylen, const char *data, size_t datalen, uint8_t *output)
{
    CCHmacContext ctx;
    
    CCHmacInit(&ctx, hmacAlg, key, keylen);
    CCHmacUpdate(&ctx, data, datalen);
    CCHmacFinal(&ctx, output);    
}

static int
HMACTest(const char *input, char *keystr, CCDigestAlgorithm digestSelector, char *expected)
{
    CCHmacAlgorithm hmacAlg;
    size_t inputLen = nullstrlen(input);
    char outbuf[80];
    int retval = 0;
    
    byteBuffer expectedBytes = hexStringToBytes(expected);
    byteBuffer keyBytes = hexStringToBytes(keystr);
    byteBuffer mdBuf = mallocDigestBuffer(digestSelector);
    switch(digestSelector) {
        case kCCDigestMD5: hmacAlg = kCCHmacAlgMD5; break;
        case kCCDigestSHA1: hmacAlg = kCCHmacAlgSHA1; break;
        case kCCDigestSHA224: hmacAlg = kCCHmacAlgSHA224; break;
        case kCCDigestSHA256: hmacAlg = kCCHmacAlgSHA256; break;
        case kCCDigestSHA384: hmacAlg = kCCHmacAlgSHA384; break;
        case kCCDigestSHA512: hmacAlg = kCCHmacAlgSHA512; break;
        default: return 1;
    }
    CCHmac(hmacAlg, keyBytes->bytes, keyBytes->len, input, inputLen, mdBuf->bytes);
    sprintf(outbuf, "Hmac-%s test for %s", digestName(digestSelector), input);
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("HMAC FAIL: HMAC-%s(\"%s\")\n expected %s\n      got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // printf("HMAC PASS: HMAC-%s(\"%s\")\n", digestName(digestSelector), input);
    }
    OneShotHmac(hmacAlg, keyBytes->bytes, keyBytes->len, input, inputLen, mdBuf->bytes);
    sprintf(outbuf, "Hmac-%s test for %s", digestName(digestSelector), input);
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("HMAC FAIL: HMAC-%s(\"%s\")\n expected %s\n      got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        //printf("HMAC PASS: HMAC-%s(\"%s\")\n", digestName(digestSelector), input);
    }
    free(mdBuf);
    free(expectedBytes);
    free(keyBytes);
	return retval;
}

#if (CCDIGEST == 1)

static void OneShotDigest(CCDigestAlgorithm algorithm, const uint8_t *bytesToDigest, size_t numbytes, uint8_t *outbuf)
{
    CCDigestRef d;
    *outbuf = 0;
    if((d = CCDigestCreate(algorithm)) == NULL) return;
    
    size_t fromAlg = CCDigestGetOutputSize(algorithm);
    size_t fromRef = CCDigestGetOutputSizeFromRef(d);
    size_t fromOldRoutine = CCDigestOutputSize(d);
    
    ok(fromAlg == fromRef, "Size is the same from ref or alg");
    ok(fromAlg == fromOldRoutine, "Size is the same from ref or alg");
    if(CCDigestUpdate(d, bytesToDigest, numbytes)) return;
    if(CCDigestFinal(d, outbuf)) return;
    
    uint8_t dupBuf[fromRef];
    CCDigestReset(d);
    if(CCDigestUpdate(d, bytesToDigest, numbytes)) return;
    if(CCDigestFinal(d, dupBuf)) return;
    ok(memcmp(outbuf, dupBuf, fromRef) == 0, "result should be the same from recycled context");

    CCDigestDestroy(d);

}


static int
newHashTest(char *input, CCDigestAlgorithm digestSelector, char *expected)
{
    size_t inputLen = nullstrlen(input);
    char outbuf[4096];
    int retval = 0;
    
    byteBuffer expectedBytes = hexStringToBytes(expected);
    byteBuffer mdBuf = mallocByteBuffer(CCDigestGetOutputSize(digestSelector));

    CCDigest(digestSelector, (const uint8_t *) input, inputLen, mdBuf->bytes);
    sprintf(outbuf, "new interface %s test for %s", digestName(digestSelector), input);
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("Digestor FAIL: %s(\"%s\")\nexpected %s\ngot      %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // printf("Digestor PASS: %s(\"%s\")\n", digestName(digestSelector), input);
    }

    printf("Digest is %s\n", digestName(digestSelector));
    OneShotDigest(digestSelector, (const uint8_t *) input, inputLen, mdBuf->bytes);
    sprintf(outbuf, "composite interface %s test for %s", digestName(digestSelector), input);
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("Digestor FAIL: %s(\"%s\")\nexpected %s\ngot      %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // printf("Digestor PASS: %s(\"%s\")\n", digestName(digestSelector), input);
    }
 
    free(mdBuf);
    free(expectedBytes);
	return retval;
}

static int
unHashTest(CCDigestAlgorithm digestSelector)
{
    char *buf[128];
    int retval;
    CCDigestRef retref;
    
    retval = CCDigest(digestSelector, (const uint8_t *) buf, 128, (uint8_t *) buf);
    ok(retval == kCCUnimplemented, "Unsupported Digest returns kCCUnimplemented");
    retref = CCDigestCreate(digestSelector);
    ok(retref == NULL, "Unsupported Digest returns NULL");
    return 0;
}
#endif

#define CC_SHA224_CTX CC_SHA256_CTX
#define CC_SHA384_CTX CC_SHA512_CTX
#define OLD_ALL_IN_ONE_HASH(name,input,len,out) \
{ \
    CC_##name##_CTX ctx; \
    ok(CC_##name##_Init(&ctx) == 1, "Old Hash init should result in 1\n"); \
    ok(CC_##name##_Update(&ctx, input, len) == 1, "Old Hash update should result in 1\n"); \
    ok(CC_##name##_Final(out, &ctx) == 1, "Old Hash final should result in 1\n"); \
} \
break


static int
hashTest(char *input, CCDigestAlgorithm digestSelector, char *expected)
{
    CC_LONG inputLen = (CC_LONG) nullstrlen(input);
    char outbuf[4096];
    int retval = 0;
    byteBuffer mdBuf = mallocDigestBuffer(digestSelector);
    byteBuffer expectedBytes = hexStringToBytes(expected);
    
    switch(digestSelector) {
        case kCCDigestMD2:		CC_MD2(input, inputLen, mdBuf->bytes); break;
        case kCCDigestMD4:		CC_MD4(input, inputLen, mdBuf->bytes); break;
        case kCCDigestMD5:		CC_MD5(input, inputLen, mdBuf->bytes); break;
        case kCCDigestSHA1:	CC_SHA1(input, inputLen, mdBuf->bytes); break;
        case kCCDigestSHA224:	CC_SHA224(input, inputLen, mdBuf->bytes); break;
        case kCCDigestSHA256:	CC_SHA256(input, inputLen, mdBuf->bytes); break;
        case kCCDigestSHA384:	CC_SHA384(input, inputLen, mdBuf->bytes); break;
        case kCCDigestSHA512:	CC_SHA512(input, inputLen, mdBuf->bytes); break;
        default: return 1;
    }
    sprintf(outbuf, "Legacy %s test for %s", digestName(digestSelector), input);
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);

    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("Legacy FAIL: %s(\"%s\") expected %s got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // printf("Legacy PASS: %s(\"%s\")\n", digestName(digestSelector), input);
    }
    
    switch(digestSelector) {
        case kCCDigestMD2:		OLD_ALL_IN_ONE_HASH(MD2, input, inputLen, mdBuf->bytes);
        case kCCDigestMD4:		OLD_ALL_IN_ONE_HASH(MD4, input, inputLen, mdBuf->bytes);
        case kCCDigestMD5:		OLD_ALL_IN_ONE_HASH(MD5, input, inputLen, mdBuf->bytes);
        case kCCDigestSHA1:	OLD_ALL_IN_ONE_HASH(SHA1, input, inputLen, mdBuf->bytes);
        case kCCDigestSHA224:	OLD_ALL_IN_ONE_HASH(SHA224, input, inputLen, mdBuf->bytes);
        case kCCDigestSHA256:	OLD_ALL_IN_ONE_HASH(SHA256, input, inputLen, mdBuf->bytes);
        case kCCDigestSHA384:	OLD_ALL_IN_ONE_HASH(SHA384, input, inputLen, mdBuf->bytes);
        case kCCDigestSHA512:	OLD_ALL_IN_ONE_HASH(SHA512, input, inputLen, mdBuf->bytes);
        default: return 1;
    }
    sprintf(outbuf, "Legacy %s test for %s", digestName(digestSelector), input);
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("Legacy FAIL: %s(\"%s\") expected %s got %s\n", digestName(digestSelector), input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // printf("Legacy PASS: %s(\"%s\")\n", digestName(digestSelector), input);
    }

   free(mdBuf);
   free(expectedBytes);
   return retval;
}

static int
rfc1321Test(char *input, char *expected)
{
    CC_LONG inputLen = (CC_LONG) nullstrlen(input);
    char outbuf[80];
    int retval = 0;
    MD5_CTX ctx;
    byteBuffer expectedBytes = hexStringToBytes(expected);
    byteBuffer mdBuf = mallocByteBuffer(CC_MD5_DIGEST_LENGTH); 
    
    MD5Init(&ctx);
    MD5Update(&ctx, input, inputLen);
    MD5Final(mdBuf->bytes, &ctx);
    
    sprintf(outbuf, "Legacy MD5-1321 test for %s", input);
    
    ok(bytesAreEqual(mdBuf, expectedBytes), outbuf);
    
    if(!bytesAreEqual(mdBuf, expectedBytes)) {
        diag("Legacy FAIL: MD5-1321(\"%s\") expected %s got %s\n", input, expected, bytesToHexString(mdBuf));
        retval = 1;
    } else {
        // printf("Legacy PASS: MD5-1321(\"%s\")\n", input);
    }
    free(mdBuf);
    free(expectedBytes);
    return retval;
}


static int kTestTestCount = 250;

int CommonDigest(int argc, char *const *argv) {
	char *strvalue, *keyvalue;
	plan_tests(kTestTestCount);
    int accum = 0;
    
	/* strvalue of NULL and strvalue of "" must end up the same */
    strvalue = NULL;
    accum |= hashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773");
    accum |= hashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0");
    accum |= hashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e");
    accum |= hashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709");
    accum |= hashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f");
    accum |= hashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
    accum |= hashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b");
    accum |= hashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
#if (CCDIGEST == 1)
    accum |= newHashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773");
    accum |= newHashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0");
    accum |= newHashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e");
    accum |= newHashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709");
    accum |= newHashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f");
    accum |= newHashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
    accum |= newHashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b");
    accum |= newHashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
    accum |= newHashTest(strvalue, kCCDigestRMD128, "cdf26213a150dc3ecb610f18f6b38b46");
    accum |= newHashTest(strvalue, kCCDigestRMD160, "9c1185a5c5e9fc54612808977ee8f548b2258d31");
    accum |= newHashTest(strvalue, kCCDigestRMD256, "02ba4c4e5f8ecd1877fc52d64d30e37a2d9774fb1e5d026380ae0168e3c5522d");
    accum |= newHashTest(strvalue, kCCDigestRMD320, "22d65d5661536cdc75c1fdf5c6de7b41b9f27325ebc61e8557177d705a0ec880151c3a32a00899b8");
#else
    diag("No Testing of the new Digest Interfaces\n");
#endif

    strvalue = "";
    accum |= hashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773");
    accum |= hashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0");
    accum |= hashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e");
    accum |= hashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709");
    accum |= hashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f");
    accum |= hashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
    accum |= hashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b");
    accum |= hashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
#if (CCDIGEST == 1)
    accum |= newHashTest(strvalue, kCCDigestMD2, "8350e5a3e24c153df2275c9f80692773");
    accum |= newHashTest(strvalue, kCCDigestMD4, "31d6cfe0d16ae931b73c59d7e0c089c0");
    accum |= newHashTest(strvalue, kCCDigestMD5, "d41d8cd98f00b204e9800998ecf8427e");
    accum |= newHashTest(strvalue, kCCDigestSHA1, "da39a3ee5e6b4b0d3255bfef95601890afd80709");
    accum |= newHashTest(strvalue, kCCDigestSHA224, "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f");
    accum |= newHashTest(strvalue, kCCDigestSHA256, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
    accum |= newHashTest(strvalue, kCCDigestSHA384, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b");
    accum |= newHashTest(strvalue, kCCDigestSHA512, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
    accum |= newHashTest(strvalue, kCCDigestRMD128, "cdf26213a150dc3ecb610f18f6b38b46");
    accum |= newHashTest(strvalue, kCCDigestRMD160, "9c1185a5c5e9fc54612808977ee8f548b2258d31");
    accum |= newHashTest(strvalue, kCCDigestRMD256, "02ba4c4e5f8ecd1877fc52d64d30e37a2d9774fb1e5d026380ae0168e3c5522d");
    accum |= newHashTest(strvalue, kCCDigestRMD320, "22d65d5661536cdc75c1fdf5c6de7b41b9f27325ebc61e8557177d705a0ec880151c3a32a00899b8");
#if defined(TESTSKEIN)

    accum |= newHashTest(strvalue, kCCDigestSkein128, "030085a5c5e9fc54612808977ee8f548");
    accum |= newHashTest(strvalue, kCCDigestSkein160, "030085a5c5e9fc54612808977ee8f548b2258d31");
    accum |= newHashTest(strvalue, kCCDigestSkein224, "030085a5c5e9fc54612808977ee8f548b2258d31009b934ca495991b");
    accum |= newHashTest(strvalue, kCCDigestSkein256, "0900d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
    accum |= newHashTest(strvalue, kCCDigestSkein384, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
    accum |= newHashTest(strvalue, kCCDigestSkein512, "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
#else
    accum |= unHashTest(kCCDigestSkein128);
    accum |= unHashTest(kCCDigestSkein160);
    accum |= unHashTest(kCCDigestSkein224);
    accum |= unHashTest(kCCDigestSkein256);
    accum |= unHashTest(kCCDigestSkein384);
    accum |= unHashTest(kCCDigestSkein512);
#endif
#else
    diag("No Testing of the new Digest Interfaces\n");
#endif

    strvalue = "Test vector from febooti.com";
    accum |= hashTest(strvalue, kCCDigestMD2, "db128d6e0d20a1192a6bd1fade401150");
    accum |= hashTest(strvalue, kCCDigestMD4, "6578f2664bc56e0b5b3f85ed26ecc67b");
    accum |= hashTest(strvalue, kCCDigestMD5, "500ab6613c6db7fbd30c62f5ff573d0f");
    accum |= hashTest(strvalue, kCCDigestSHA1, "a7631795f6d59cd6d14ebd0058a6394a4b93d868");
    accum |= hashTest(strvalue, kCCDigestSHA224, "3628b402254caa96827e3c79c0a559e4558da8ee2b65f1496578137d");
    accum |= hashTest(strvalue, kCCDigestSHA256, "077b18fe29036ada4890bdec192186e10678597a67880290521df70df4bac9ab");
    accum |= hashTest(strvalue, kCCDigestSHA384, "388bb2d487de48740f45fcb44152b0b665428c49def1aaf7c7f09a40c10aff1cd7c3fe3325193c4dd35d4eaa032f49b0");
    accum |= hashTest(strvalue, kCCDigestSHA512, "09fb898bc97319a243a63f6971747f8e102481fb8d5346c55cb44855adc2e0e98f304e552b0db1d4eeba8a5c8779f6a3010f0e1a2beb5b9547a13b6edca11e8a");
    accum |= rfc1321Test(strvalue, "500ab6613c6db7fbd30c62f5ff573d0f");


#if (CCDIGEST == 1)
    accum |= newHashTest(strvalue, kCCDigestMD2, "db128d6e0d20a1192a6bd1fade401150");
    accum |= newHashTest(strvalue, kCCDigestMD4, "6578f2664bc56e0b5b3f85ed26ecc67b");
    accum |= newHashTest(strvalue, kCCDigestMD5, "500ab6613c6db7fbd30c62f5ff573d0f");
    accum |= newHashTest(strvalue, kCCDigestSHA1, "a7631795f6d59cd6d14ebd0058a6394a4b93d868");
    accum |= newHashTest(strvalue, kCCDigestSHA224, "3628b402254caa96827e3c79c0a559e4558da8ee2b65f1496578137d");
    accum |= newHashTest(strvalue, kCCDigestSHA256, "077b18fe29036ada4890bdec192186e10678597a67880290521df70df4bac9ab");
    accum |= newHashTest(strvalue, kCCDigestSHA384, "388bb2d487de48740f45fcb44152b0b665428c49def1aaf7c7f09a40c10aff1cd7c3fe3325193c4dd35d4eaa032f49b0");
    accum |= newHashTest(strvalue, kCCDigestSHA512, "09fb898bc97319a243a63f6971747f8e102481fb8d5346c55cb44855adc2e0e98f304e552b0db1d4eeba8a5c8779f6a3010f0e1a2beb5b9547a13b6edca11e8a");
#if defined(TESTSKEIN)
    accum |= newHashTest(strvalue, kCCDigestSkein128, "03000000000000700000000000000070");
    accum |= newHashTest(strvalue, kCCDigestSkein160, "0300000000000070000000000000007000000000");
    accum |= newHashTest(strvalue, kCCDigestSkein224, "030000000000007000000000000000700000000000000070ca030210");
    accum |= newHashTest(strvalue, kCCDigestSkein256, "0000000000000000000000000000000000000000000000000000000000000000");
    accum |= newHashTest(strvalue, kCCDigestSkein384, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
    accum |= newHashTest(strvalue, kCCDigestSkein512, "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
#endif

#else
    diag("No Testing of the new Digest Interfaces\n");
#endif

	// Test Case 1 http://www.faqs.org/rfcs/rfc4231.html
    strvalue = "Hi There";
    keyvalue = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b";
	accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA224, "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22");   
	accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA256, "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");   
	accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA384, "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6");   
	accum |= HMACTest(strvalue, keyvalue, kCCDigestSHA512, "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854");
    // Test Vector from http://www.faqs.org/rfcs/rfc2104.html
    keyvalue = "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b";
    accum |= HMACTest(strvalue, keyvalue, kCCDigestMD5, "9294727a3638bb1c13f48ef8158bfc9d");   
    
#if (CCKEYDERIVATION == 1)
    // Test Case PBKDF2 - HMACSHA1 http://tools.ietf.org/html/draft-josefsson-pbkdf2-test-vectors-00
    accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 1, kCCDigestSHA1, 20, "0c60c80f961f0e71f3a9b524af6012062fe037a6");
    accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 2, kCCDigestSHA1, 20, "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957");
    accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 4096, kCCDigestSHA1, 20, "4b007901b765489abead49d926f721d065a429c1");
    
    // This crashes
    accum |= PBKDF2Test("password", (uint8_t *) "salt", 4, 1, 0, 20, NULL);
#else
    diag("No Key Derivation Support Testing\n");
#endif
    
    // Test from <rdar://problem/11285435> CC_SHA512_Init(),CC_SHA512_Update(),CC_SHA512_Final() gives wrong digest
    strvalue = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
    accum |= hashTest(strvalue, kCCDigestSHA512, "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909");
    accum |= newHashTest(strvalue, kCCDigestSHA512, "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909");

    return accum;

}

#include <Availability.h>
#include "capabilities.h"
#include "testmore.h"
#include "testbyteBuffer.h"

#if (CCEC == 0)
entryPoint(CommonEC,"Elliptic Curve Cryptography")
#else

#include <CommonCrypto/CommonECCryptor.h>

static int kTestTestCount = 18;

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;
}
#endif /* CCEC */

/* 
 * ccHmacClone - test CommonCrypto's clone context for HMAC.  
 *
 * Written 3/30/2006 by Doug Mitchell. 
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <string.h>
#include <CommonCrypto/CommonHMAC.h>
#include "testmore.h"
#include "testbyteBuffer.h"
#include "capabilities.h"

#if (CCHMACCLONE == 0)
entryPoint(CommonHMacClone,"Common HMac Cloning")
#else

/*
 * Defaults.
 */
#define LOOPS_DEF		200

#define MIN_DATA_SIZE	8
#define MAX_DATA_SIZE	10000			/* bytes */
#define MIN_KEY_SIZE	1
#define MAX_KEY_SIZE	256				/* bytes */
#define LOOP_NOTIFY		20

/*
 * Enumerate algs our own way to allow iteration.
 */
typedef enum {
	ALG_MD5 = 1,
	ALG_SHA1,
	ALG_SHA224,
	ALG_SHA256,
	ALG_SHA384,
	ALG_SHA512,
} HmacAlg;
#define ALG_FIRST			ALG_MD5
#define ALG_LAST			ALG_SHA512

#define LOG_SIZE			0
#if		LOG_SIZE
#define logSize(s)	diag(s)
#else
#define logSize(s)
#endif

/* 
 * Given an initialized CCHmacContext, feed it some data and get the result.
 */
static void hmacRun(
	CCHmacContext *ctx,
	bool randomUpdates,
	const unsigned char *ptext,
	size_t ptextLen,
	void *dataOut)
{
	while(ptextLen) {
		size_t thisMoveIn;			/* input to CCryptUpdate() */
		
		if(randomUpdates) {
			thisMoveIn = genRandomSize(1, ptextLen);
		}
		else {
			thisMoveIn = ptextLen;
		}
		logSize(("###ptext segment (1) len %lu\n", (unsigned long)thisMoveIn)); 
		CCHmacUpdate(ctx, ptext, thisMoveIn);
		ptext	 += thisMoveIn;
		ptextLen -= thisMoveIn;
	}
	CCHmacFinal(ctx, dataOut);
}


#define MAX_HMAC_SIZE	CC_SHA512_DIGEST_LENGTH

static int doHMacCloneTest(const uint8_t *ptext,
	size_t ptextLen,
	CCHmacAlgorithm hmacAlg,			
	uint32_t keySizeInBytes,
	bool stagedOrig,
	bool stagedClone,
	bool quiet,
	bool verbose)
{
	uint8_t			*keyBytes;
	uint8_t			hmacOrig[MAX_HMAC_SIZE];
	uint8_t			hmacClone[MAX_HMAC_SIZE];
	int				rtn = 1;
	CCHmacContext	ctxOrig;
	CCHmacContext	ctxClone;
	unsigned		die;		/* 0..3 indicates when to clone */
	unsigned		loopNum = 0;
	size_t			hmacLen;
	bool			didClone = false;
	
	switch(hmacAlg) {
		case kCCHmacAlgSHA1:
            if(verbose) diag("hmac-sha1\n");
			hmacLen = CC_SHA1_DIGEST_LENGTH;
			break;
		case kCCHmacAlgMD5:
            if(verbose) diag("hmac-md5\n");
			hmacLen = CC_MD5_DIGEST_LENGTH;
			break;
		case kCCHmacAlgSHA224:
            if(verbose) diag("hmac-sha224\n");
			hmacLen = CC_SHA224_DIGEST_LENGTH;
			break;
		case kCCHmacAlgSHA256:
            if(verbose) diag("hmac-sha256\n");
			hmacLen = CC_SHA256_DIGEST_LENGTH;
			break;
		case kCCHmacAlgSHA384:
            if(verbose) diag("hmac-sha384\n");
			hmacLen = CC_SHA384_DIGEST_LENGTH;
			break;
		case kCCHmacAlgSHA512:
            if(verbose) diag("hmac-sha512\n");
			hmacLen = CC_SHA512_DIGEST_LENGTH;
			break;
		default:
			if(verbose) diag("***BRRRZAP!\n");
			return 0;
	}
	
	/* random key */
    byteBuffer keyBuffer = genRandomByteBuffer(keySizeInBytes, keySizeInBytes);
    keyBytes = keyBuffer->bytes;
	
	/* cook up first context */
	CCHmacInit(&ctxOrig, hmacAlg, keyBytes, keySizeInBytes);
	
	/* roll the dice */
	die = (unsigned) genRandomSize(0, 3);
	
	/* 
	 * In this loop we do updates to the ctxOrig up until we
	 * clone it, then we use hmacRun to finish both of them.
	 */
	while(ptextLen) {
		if((die == loopNum) || !stagedOrig) {
			/* make the clone now */
			if(verbose) {
				diag("   ...cloning at loop %u\n", loopNum);
			}
			ctxClone = ctxOrig;
			didClone = true;
            if(memcmp(&ctxClone, &ctxOrig, CC_HMAC_CONTEXT_SIZE * sizeof(uint32_t))) {
                if(verbose) diag("*** context miscompare\n");
            } else {
                if(verbose) diag("*** context clone worked\n");
            }
			
			/* do all of the clone's updates and final here */
			hmacRun(&ctxClone, stagedClone, ptext, ptextLen, hmacClone);
			
			/* now do all remaining updates and final for original */
			hmacRun(&ctxOrig, stagedOrig, ptext, ptextLen, hmacOrig);
			
			/* we're all done, time to check the HMAC values */
			break;
		}	/* making clone */
		
		/* feed some data into cryptorOrig */
		size_t thisMove;
		if(stagedOrig) {
			thisMove = genRandomSize(1, ptextLen);
		}
		else {
			thisMove = ptextLen;
		}
		logSize(("###ptext segment (2) len %lu\n", (unsigned long)thisMove)); 
		CCHmacUpdate(&ctxOrig, ptext, thisMove);
		ptext += thisMove;
		ptextLen -= thisMove;
		loopNum++;
	}
		
	/* 
	 * It's possible to get here without cloning or doing any finals,
	 * if we ran thru multiple updates and finished ptextLen for cryptorOrig
	 * before we hit the cloning spot.
	 */
	if(!didClone) {
		if(verbose) {
			diag("...ctxOrig finished before we cloned; skipping test\n");
		}
		return 1;
	}
	if(memcmp(hmacOrig, hmacClone, hmacLen)) {
		diag("***data miscompare\n");
		rtn = 0;
	} else {
        if(verbose) diag("*** clone worked\n");
        rtn = 1;
    }
    if(keyBuffer) free(keyBuffer);
    
	return rtn;
}

static bool isBitSet(unsigned bit, unsigned word) 
{
	if(bit > 31) {
		diag("We don't have that many bits\n");
		return -1;
	}
	unsigned mask = 1 << bit;
	return (word & mask) ? true : false;
}


static int kTestTestCount = 1200;


int CommonHMacClone(int argc, char *const *argv)
{
	unsigned			loop;
	uint8_t				*ptext;
	size_t				ptextLen;
	bool				stagedOrig;
	bool				stagedClone;
	const char			*algStr;
	CCHmacAlgorithm		hmacAlg;	
	int					currAlg;		// ALG_xxx
	uint32_t				keySizeInBytes;
	int					rtn = 0;
	
	/*
	 * User-spec'd params
	 */
	bool		keySizeSpec = false;		// false: use rand key size
	HmacAlg		minAlg = ALG_FIRST;
	HmacAlg		maxAlg = ALG_LAST;
	unsigned	loops = LOOPS_DEF;
	bool		verbose = false;
	size_t		minPtextSize = MIN_DATA_SIZE;
	size_t		maxPtextSize = MAX_DATA_SIZE;
	bool		quiet = true;
	bool		stagedSpec = false;		// true means caller fixed stagedOrig and stagedClone
	
	/* ptext length set in test loop */
	plan_tests(kTestTestCount);
	
	for(currAlg=minAlg; currAlg<=maxAlg; currAlg++) {
		/* when zero, set size randomly or per user setting */
		switch(currAlg) {
			case ALG_MD5:
				hmacAlg = kCCHmacAlgMD5;
				algStr = "HMACMD5";
				break;
			case ALG_SHA1:
				hmacAlg = kCCHmacAlgSHA1;
				algStr = "HMACSHA1";
				break;
			case ALG_SHA224:
				hmacAlg = kCCHmacAlgSHA224;
				algStr = "HMACSHA224";
				break;
			case ALG_SHA256:
				hmacAlg = kCCHmacAlgSHA256;
				algStr = "HMACSHA256";
				break;
			case ALG_SHA384:
				hmacAlg = kCCHmacAlgSHA384;
				algStr = "HMACSHA384";
				break;
			case ALG_SHA512:
				hmacAlg = kCCHmacAlgSHA512;
				algStr = "HMACSHA512";
				break;
			default:
				diag("***BRRZAP!\n");
				return -1;
		}
		if(verbose) {
			diag("Testing alg %s\n", algStr);
		}
		for(loop=0; loop < loops; loop++) {
            byteBuffer bb =  genRandomByteBuffer(minPtextSize, maxPtextSize);
            ptextLen = bb->len; ptext = bb->bytes;
			if(!keySizeSpec) {
				keySizeInBytes = (uint32_t)genRandomSize(MIN_KEY_SIZE, MAX_KEY_SIZE);
			}
			
			/* per-loop settings */
			if(!stagedSpec) {
				stagedOrig = isBitSet(1, loop);
				stagedClone = isBitSet(2, loop);
			}
			
			if(!quiet) {
			   	if(verbose || ((loop % LOOP_NOTIFY) == 0)) {
					diag("..loop %d ptextLen %4lu keySize %3lu stagedOrig=%d "
						"stagedClone=%d\n", 
						loop, (unsigned long)ptextLen, (unsigned long)keySizeInBytes,
						(int)stagedOrig, (int)stagedClone);
				}
			}
			
			ok(doHMacCloneTest(ptext, ptextLen, hmacAlg, keySizeInBytes, stagedOrig, stagedClone, quiet, verbose), "HMacClone Test");
			if(loops && (loop == loops)) {
				break;
			}
            free(bb);
		}	/* main loop */
		
	}	/* for algs */
	
testDone:
	if((rtn != 0) && verbose) {
		diag("%s test complete\n", argv[0]);
	}
	return rtn;
}

#endif

#include "testbyteBuffer.h"
#include "testmore.h"
#include "capabilities.h"

#if (CCRSA == 0)
entryPoint(CommonRSA,"RSA Cryptography")
#else

#include <CommonCrypto/CommonRSACryptor.h>
static int kTestTestCount = 18;

static bool
RSAVerifyTest(byteBuffer modulus, byteBuffer exponent, byteBuffer message, byteBuffer signature, CCDigestAlgorithm digestSelector, int verbose, CCAsymetricPadding padding)
{
    CCRSACryptorRef CAVPubKey;
	CCCryptorStatus retval;
    byteBuffer digestValue = mallocByteBuffer(1024);
    byteBuffer decodedSignature = mallocByteBuffer(1024);

    retval = CCRSACryptorCreateFromData(ccRSAKeyPublic, modulus->bytes, modulus->len, exponent->bytes, exponent->len,
                                        NULL, 0, NULL, 0, &CAVPubKey);

    ok(retval == 0, "Build a CAVS test public key using CCRSACryptorCreateFromData");

    CCDigest(digestSelector, message->bytes, message->len, digestValue->bytes);
    digestValue->len = CCDigestGetOutputSize(digestSelector);

    if(verbose) {
        retval = CCRSACryptorCrypt(CAVPubKey, signature->bytes, 128, decodedSignature->bytes, &decodedSignature->len);
        printf("retval = %d\n", retval);
        printf("Decoded Signature %s\n", bytesToHexString(decodedSignature));
        printf("Digest of message %s\n\n\n", bytesToHexString(digestValue));
    }
    // ccOAEPPadding  ccPKCS1Padding ccX931Padding
    retval = CCRSACryptorVerify(CAVPubKey, padding, digestValue->bytes, digestValue->len, digestSelector, 0, signature->bytes, signature->len);
    printf("CCRSACryptorVerify returned %d\n", retval);
    free(digestValue);
    free(decodedSignature);
    return retval == kCCSuccess;
}


static void 
RSAX931BuildTest(uint32_t e, 
                 char *xp1str, char *xp2str, char *xpstr, 
                 char *xq1str, char *xq2str, char *xqstr,
                 char *pstr, char *qstr, char *mstr, char *dstr,
                 CCRSACryptorRef *retpublicKey, CCRSACryptorRef *retprivateKey)
{
    byteBuffer xp1, xp2, xp, xq1, xq2, xq, p, q, m, d;
    int verbose = 1;
    CCRSACryptorRef publicKey, privateKey;

    xp1 = hexStringToBytes(xp1str);
    xp2 = hexStringToBytes(xp2str);
    xp = hexStringToBytes(xpstr);
    xq1 = hexStringToBytes(xq1str);
    xq2 = hexStringToBytes(xq2str);
    xq = hexStringToBytes(xqstr);
    p = hexStringToBytes(pstr);
    q = hexStringToBytes(qstr);
    m = hexStringToBytes(mstr);
    d = hexStringToBytes(dstr);
    
    uint8_t modulus[1024], exponent[1024], pval[1024], qval[1024];
    size_t modulusLength, exponentLength, pLength, qLength;
    
    modulusLength = exponentLength = pLength = qLength = 1024;

    CCRSACryptorCreatePairFromData(e, 
                                   xp1->bytes, xp1->len, xp2->bytes, xp2->len, xp->bytes, xp->len, 
                                   xq1->bytes, xq1->len, xq2->bytes, xq2->len, xq->bytes, xq->len,
                                   &publicKey, &privateKey,
                                   pval, &pLength, qval, &qLength, modulus, &modulusLength, exponent, &exponentLength);
    /*
    retval = CCRSAGetKeyComponents(privateKey, modulus, &modulusLength, exponent, &exponentLength,
                                   pval, &pLength, qval, &qLength);
    ok(retval == 0, "got private key components");
     */
    
    byteBuffer retP = bytesToBytes(pval, pLength);
    byteBuffer retQ = bytesToBytes(qval, qLength);
    byteBuffer retD = bytesToBytes(exponent, exponentLength);
    byteBuffer retM = bytesToBytes(modulus, modulusLength);
    
    if(bytesAreEqual(retP, q) && bytesAreEqual(retQ, p)) {
        byteBuffer tmp = p;
        p = q;
        q = tmp;
        printf("Swapped P and Q\n");
    }
    
    ok(bytesAreEqual(retP, p), "p is built correctly");
    ok(bytesAreEqual(retQ, q), "q is built correctly");
    ok(bytesAreEqual(retD, d), "n is built correctly");
    ok(bytesAreEqual(retM, m), "d is built correctly");
    
    if(verbose) {
        if(!bytesAreEqual(retP, p)) printf("P\nreturned: %s\nexpected: %s\n\n", bytesToHexString(retP), bytesToHexString(p));
        else printf("P is correct\n");
        if(!bytesAreEqual(retQ, q)) printf("Q\nreturned: %s\nexpected: %s\n\n", bytesToHexString(retQ), bytesToHexString(q));
        else printf("Q is correct\n");
        if(!bytesAreEqual(retD, d)) printf("D\nreturned: %s\nexpected: %s\n\n", bytesToHexString(retD), bytesToHexString(d));
        else printf("D is correct\n");
        if(!bytesAreEqual(retM, m)) printf("M\nreturned: %s\nexpected: %s\n\n", bytesToHexString(retM), bytesToHexString(m));
        else printf("M is correct\n");
    }
    *retpublicKey = publicKey;
    *retprivateKey = privateKey;
}

int CommonRSA (int argc, char *const *argv) {
	CCCryptorStatus retval;
    size_t keysize;
    CCRSACryptorRef publicKey, privateKey;
    byteBuffer keydata, dekeydata, 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;
    char inputpadded[128], outputpadded[128];
    int accum = 0;
    int debug = 0;
    // int verbose = 1;

    
	plan_tests(kTestTestCount);
    
    keysize = 1024;
    
    if(debug) printf("Keygen\n");
    retval = CCRSACryptorGeneratePair(keysize, 65537, &publicKey, &privateKey);
    
    ok(retval == 0, "Generate an RSA Key Pair");
    accum += retval;
    
    if(debug) printf("Encrypt/Decrypt\n");
    keydata = hexStringToBytes("000102030405060708090a0b0c0d0e0f");
        
    retval = CCRSACryptorEncrypt(publicKey, ccPKCS1Padding, keydata->bytes, keydata->len, encryptedKey, &encryptedKeyLen,
                        "murf", 4, kCCDigestSHA1);
    
    ok(retval == 0, "Wrap Key Data with RSA Encryption - ccPKCS1Padding");
    accum += retval;
    
    retval = CCRSACryptorDecrypt(privateKey, ccPKCS1Padding, encryptedKey, encryptedKeyLen,
                        decryptedKey, &decryptedKeyLen,"murf", 4, kCCDigestSHA1);
    
    ok(retval == 0, "Unwrap Key Data with RSA Encryption - ccPKCS1Padding");
    accum += retval;

	dekeydata = bytesToBytes(decryptedKey, decryptedKeyLen);
    
	ok(bytesAreEqual(dekeydata, keydata), "Round Trip ccPKCS1Padding");
    accum += !bytesAreEqual(dekeydata, keydata);

    if(debug) printf("Encrypt/Decrypt 2\n");
    
    encryptedKeyLen = 8192;
    decryptedKeyLen = 8192;
    
    retval = CCRSACryptorEncrypt(publicKey, ccOAEPPadding, keydata->bytes, keydata->len, encryptedKey, &encryptedKeyLen,
                                 "murf", 4, kCCDigestSHA1);

    ok(retval == 0, "Wrap Key Data with RSA Encryption - ccOAEPPadding");
    accum += retval;
    
    
    retval = CCRSACryptorDecrypt(privateKey, ccOAEPPadding, encryptedKey, encryptedKeyLen,
                                 decryptedKey, &decryptedKeyLen,"murf", 4, kCCDigestSHA1);
    
    ok(retval == 0, "Unwrap Key Data with RSA Encryption - ccOAEPPadding");
    accum += retval;
    
	dekeydata = bytesToBytes(decryptedKey, decryptedKeyLen);
    
	ok(bytesAreEqual(dekeydata, keydata), "Round Trip ccOAEPPadding");
        
    if(debug) printf("Sign/Verify\n");
    hash = hexStringToBytes("000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f");

    retval = CCRSACryptorSign(privateKey, ccPKCS1Padding, 
                     hash->bytes, CCDigestGetOutputSize(kCCDigestSHA256),
                     kCCDigestSHA256, 16,
                     signature, &signatureLen);

    ok(retval == 0, "RSA Signing");
    accum += retval;
    
    retval = CCRSACryptorVerify(publicKey, ccPKCS1Padding,
                       hash->bytes, CCDigestGetOutputSize(kCCDigestSHA256), 
                       kCCDigestSHA256, 16,
                       signature, signatureLen);
    ok(retval == 0, "RSA Verifying");
    accum += retval;
    signatureLen = 8192;
    retval = CCRSACryptorSign(privateKey, ccOAEPPadding, 
                              hash->bytes, CCDigestGetOutputSize(kCCDigestSHA1),
                              kCCDigestSHA1, 16,
                              signature, &signatureLen);
    
    ok(retval == 0, "RSA Signing OAEP");
    accum += retval;
    
    retval = CCRSACryptorVerify(publicKey, ccOAEPPadding,
                                hash->bytes, CCDigestGetOutputSize(kCCDigestSHA1), 
                                kCCDigestSHA1, 16,
                                signature, signatureLen);
    ok(retval == 0, "RSA Verifying OAEP");
    accum += retval;

#ifdef NEVER
    memset(signature, 5, 8192);

    retval = CCRSACryptorSign(privateKey, ccX931Padding, 
                              hash->bytes, CCDigestGetOutputSize(kCCDigestSHA1),
                              kCCDigestSHA1, 16,
                              signature, &signatureLen);
    
    //diag("Signature retval = %d\n", retval);
    
    ok(retval == 0, "RSA Signing");
    accum += retval;
    
    retval = CCRSACryptorVerify(publicKey, ccX931Padding,
                                hash->bytes, CCDigestGetOutputSize(kCCDigestSHA1), 
                                kCCDigestSHA1, 16,
                                signature, signatureLen);
    ok(retval == 0, "RSA Verifying");
    accum += retval;

	retval = CCRSACryptorExport(publicKey, importexport, &importexportLen);
    
    ok(retval == 0, "RSA Export Public Key");
    accum += retval;

    retval = CCRSACryptorImport(importexport, importexportLen, &publicKey2);
    
    ok(retval == 0, "RSA Import Public Key");
    accum += retval;
                      
	importexportLen = 8192;
	retval = CCRSACryptorExport(privateKey, importexport, &importexportLen);
    
    ok(retval == 0, "RSA Export Private Key");
    accum += retval;
    
    retval = CCRSACryptorImport(importexport, importexportLen, &privateKey2);
    
    ok(retval == 0, "RSA Import Private Key");
    accum += retval;
#endif

    if(debug) printf("Starting to build key from data\n");
    uint32_t e = 3;
    char *xp1, *xp2, *xp, *xq1, *xq2, *xq, *p, *q, *m, *d;
    xp1 = "1eaa9ade4a0da46dd40824d814";
    xp2 = "17379044dc2c6105423da807f8";
    xp = "fd3f368d01a95944bc1578f8ae58a9b6c17f529da1599a8bcd361df6efede4176924944e30cbe5c2ddea5648019d2086b95c68588380b8725003b047db88f92a";
    xq1 = "1da08feb13d9fba526190d3756";
    xq2 = "10d93d84466d213a3e776c61f6";
    xq = "f67b5f051126a8956171561b62f572090cde4b09b13f73ee28a90bea2bfb4001fe7b16bd51266524684520e77941dddc56b892ae4bd09dd44acc08bf45dd0a58";
    
    
    p = "fd3f368d01a95944bc1578f8ae58a9b6c17f529da1599a8bcd361df6efede4176924944e30d114d4c767d573d1149e005267e6fe36c51d86968cf6f65afcb973";
    q = "f67b5f051126a8956171561b62f572090cde4b09b13f73ee28a90bea2bfb4001fe7b16bd5129f06dc6e1f8b4f739c7eb1eb8dcacca3b41cd484fc0c693367037";
    m = "f3d4c9ca2dca5d4b893919ae7bee0d174d1e7bd2190287f79a7db6f21366108e8b0aa37cc972989ff3730d629620076555884da0e895d4e426449c60e36fad1d0208dd4ade1c45fc90da5e76c9c89fd95d13ce76a97530ee83ea3cfbe96cf28f85c4756797cd0123683194b7b2fcd185c3ea984cb0ef90580f95d57a44b027b5";
    d = "28a376f707a1ba3741898447bf525783e22fbf4daed5c153ef14f3d3033bad6d172c7094cc3dc41aa8932ce5c3b0013b8e4162457c18f8d0b10b6f657b3d478482626149773760b0688ded3b1ebf16044273b2cd3924b068c2572dd9cceb4d13afb0cc64ae4da9facefbf66d271d11ef0dcc4e1af2a7dd80b2c984f4e3bf7fad";

    
    RSAX931BuildTest(e, xp1, xp2, xp, xq1, xq2, xq, p, q, m, d, &publicKey,  &privateKey);

    e = 0x010001;
    xp1 = "155e67ddb99eefb13e4b77a7f0";
    xp2 = "17044df236c14e8ec333e92506";
    xp = "d4f2b30f4f062ad2d05fc742e91bc20ca3ee8a2d126aff592c7de19edb3b884550ddd6f99b0a6b2b785617b46c0995bc112176dbae9a5b7f0bec678e84d6f44c";
    p = "d4f2b30f4f062ad2d05fc742e91bc20ca3ee8a2d126aff592c7de19edb3b884550ddd6f99b13e5dd56ffb2ac1867030f385597e712f65ac8dd1de502857c1a41";
    xq1 = "1e2923b103c935e3788ebd10e4";
    xq2 = "11a2ccec655a8b362b5ec5fcc4";
    xq = "f7c6a68cff2467f300b82591e5123b1d1256546d999a37f4b18fe4896464df6987e7cc80efee3ce4e2f5c7a3cc085bbe33e4d375ed59cbc591f2b3302bd823bc";
    q = "f7c6a68cff2467f300b82591e5123b1d1256546d999a37f4b18fe4896464df6987e7cc80efeeb4c59165f7d1aec9be2b34889dbe221147e7ceefb5c9bd5cb945";
    m = "ce1b6904ec27f4a8f420414860704f4797a202ed16a9a35f63a16511a31675ccb046b02b192ef121b328385922f5faa032113332d42f84c70d4323133e216b0f339ebaf672f6214d0d7c13bea301174485ec44f44fae0e8a7f8d3c81ced5df77723331816158c3added7dc55f1436a7e5f14730be22cf3bebab1b62915c80c85";
    d = "18d16522721b5793169e61ae08eacd291641ac6f8718933313c8a5e66b487393dbb00f5b89334556e4ff5555aa678b2fca07972e2a2db4a3d15d81b639f7852ffe71657918d0280ff1be2f8f5d90b3e68195ab35e5069a3053540958bc6d58489fecf8baab0981f4af7b4db43550bcf01114e5ecdcb18f228db1c617b5d09781";
    RSAX931BuildTest(e, xp1, xp2, xp, xq1, xq2, xq, p, q, m, d, &publicKey,  &privateKey);

#ifdef NEVER
    e = 3;
    xp1 = "1c36bd0874761109bb0575ee16";
    xp2 = "1777c33935db08546dd66b6d96";
    xp = "d040fa5fe5e32eab84bac6cab4c512dae938cbbe4a29f972b78b149b0b5f6a639e29c0830fa13ca140ac83dda18a1ea7b25122d3c39a10effe7afad4a8b4e77ba42c7912399fcd4f1592a3059188bff536788fe6807e0df8e3d1e7350cf5dd69";
    p = "d040fa5fe5e32eab84bac6cab4c512dae938cbbe4a29f972b78b149b0b5f6a639e29c0830fa13ca140ac83dda18a1ea7b25122d3c39a10effe7afad4a8b4e77ba42c791239acf889977037a0efe181d54b93279b7e46a2fdcf674039fb11e89b";
    xq1 = "14c70e475b12870bc6efd3b944";
    xq2 = "1432548a4959eed65b858cd316";
    xq = "e4d222daf062a01a3a9ddfc82a229613403b772ff05fa9fab1fc77de51744af98b65d47bdb2e8f5091af66002550b1d3ca446738450f8f670045f8465a952a8942079c1e048228c86291bb0ae7665146782021262c49143b5ea37ce400240372";
    q = "e4d222daf062a01a3a9ddfc82a229613403b772ff05fa9fab1fc77de51744af98b65d47bdb2e8f5091af66002550b1d3ca446738450f8f670045f8465a952a8942079c1e04937b7eb94b8d322faefd691b6fa2b0ef4a2333ed791afe8ac3ac41";
    m = "ba24d0a5878c01f6ad9140b6271b42309887a6815d5ef1bc3415a381b7b511a42b8d2b8d9df59faa0b69456ff908e24b4ccb835420404ce449c9ce4ca65dc4ae4eb6bb8403b809d530ef4b37e5b211c13a03e2a69afb8c748b90c97d52023ae9a24c1f1f4b3b87685eaa649f54e41b6439e29700543f0747f09658ed392f96ee568a50ad7b5441c88ad37c581526ff296b1c6cc87e352d4f921960b6b630f8f546f1077a7586b839ee07717de84e0a19cd52eceb358ff2c69387b13a83e5335b";
    d = "1f0622c641420053c7983573b12f35b2c4169bc03a3a7d9f5e039b404948d846074231ecefa8eff1ac918b92a9817b0c8ccc95e35ab562260c4c4d0cc664f61d0d1e7496009eac4e32d28c8950f302f589ab507119d49768c1ed76ea3855b47bfcded5a6137e49706fe2f50213aa1313ad67b8adaef390a46bd7ccbdfa0f5042dcd4749d181613a3c9694314626207c7a7c125ca139742296de412449dd1267d6574d30c5e8bb60844e1f21c76ca41cf3bb805c521553218ce71390055029a6b";
    RSAX931BuildTest(e, xp1, xp2, xp, xq1, xq2, xq, p, q, m, d, &publicKey,  &privateKey);

    e = 3;
    xp1 = "1408766e2cb2d47ebfee7ea614";
    xp2 = "16292b77507cffd2f798b7c9f2";
    xp = "f74435451a7ddaa163c8c8ad03dfde97fe066360dfee52e3a9d8f41310fdb484e92e302de0b88c6c698a0b4af99ae001758441bbeb74be9d8047d104a9edb60e9e127c5d0cfd5d170ab84b314f71cbeea22006a2916a1dbc66c5be0357def520fd38445d0815f5ac3099afeb6f2d48666d22da9e3c961949459ce399829719c1";
    p = "f74435451a7ddaa163c8c8ad03dfde97fe066360dfee52e3a9d8f41310fdb484e92e302de0b88c6c698a0b4af99ae001758441bbeb74be9d8047d104a9edb60e9e127c5d0cfd5d170ab84b314f71cbeea22006a2916a1dbc66c5be0357def520fd38445d081fbe68dd24e14f0711cc0351fec8641d8ea7d22c4709f233e6349b";
    xq1 = "161d77eb77c6f257d8f8a3b0ca";
    xq2 = "152f11dfc70b78f0fc6c9137b8";
    xq = "c4d3feeb0e561be3727fd83dedaeaaecba01c798e917dd8bb11a03ce07fcf08f6f006ac6137d021912dffffc1aee981c395366fef05718e38aef69f0abf64f8b2cb9750826b8ec854dab1e1280c403169e3497ee9af08bd6d2b53a0d9c49e034220506f7719041f0cced1cc846b853a090ac42af0f699c2c3174606e02800952";
    q = "c4d3feeb0e561be3727fd83dedaeaaecba01c798e917dd8bb11a03ce07fcf08f6f006ac6137d021912dffffc1aee981c395366fef05718e38aef69f0abf64f8b2cb9750826b8ec854dab1e1280c403169e3497ee9af08bd6d2b53a0d9c49e034220506f771942204f0890fb5e617c580aa98a7482b5457215badc119f23b21c3";
    m = "be1cfc39868d8e9a8239f504482be60c01071cbdab4355b03c10edafe85d9ca10689d86036b6d35829a364a8a2b69f28743e50e5e27ac6b6fe8962809e1c2e0765b2d7508d61bfa538085dfb685595c6965bc5e0855a6dd8807a83e2ee7fc50b5b48f2d232195b672f2c325eb6649dee9758ce76f690107f3b0d10afef427777fb0bac0a41e23717fc54d9194a344d1823bdc18fa364e5373da39a3e41bcc4d88a688a711b56c6387b669d37c4fd7878559b93473869ae8190c46605f03cf25038bf771246fb81a27bc9d44ba67bfce94a3051856511661dbe0803d220809695ad707022c4acd24d40e011eb3752e39568f66cdd2d90369a67295e19dadb0d11";
    d = "1faf7f5eebc2426f15b45380b6b1fbacaad684ca4735e39d5f58279d5164ef702bc1a410091e788eb19b3b717073c53168b50d7ba5bf211e7fc1906ac504b25690f323e2c23af546340164ff3c0e43a1190f4ba56b8f124ec0146b507d154b81e48c28785daee49132875dba73bb6fa7c3e42269291802bfdf2cd81d528b13e90a7de94f042d0ac33102095d0ec64b433c9e43c3a4651e215072c5ba3175aff6085efd3f868589487fd4c2fd72be000f1bcb51c20f6fa3d56b97872d6f0ed21e67a896478336340105e6672bf90bb250ac4f487e0973ca17161781f58763f58ac25ddb77b7297da53dddb02661b18dad920fd4dd7b7233f125336dd79e1ef3c9";
    RSAX931BuildTest(e, xp1, xp2, xp, xq1, xq2, xq, p, q, m, d, &publicKey,  &privateKey);

    e = 3;
    xp1 = "164511563871556a9babc022c8";
    xp2 = "1ae2a7a04f23efe080f48a24b0";
    xp = "db5c4ccf412b17041b6e20b7e0cb45d807ef4da8282428e05e26782fef3251ea2f613d00a134842c6070aa6ebd2c38bb2a28c0f457601b159ae1f5af94dc8c9812f9b4e031ed1f08c64fdb6ffca71c0d3fc93c63596100b2dbce1d6cbf34fae84bccb859397f700114b4bba2e56678360f79c9df784e5f21e995f84fb8622543a48351520012ff80144653efc08ed49e62e17050fa4fc1c98cdd8e40c68f9512e3c687b4cfcc55eb8caeaa3fd44ab8ad00a8389c288eac128c4ee82832e3d0bb";
    p = "db5c4ccf412b17041b6e20b7e0cb45d807ef4da8282428e05e26782fef3251ea2f613d00a134842c6070aa6ebd2c38bb2a28c0f457601b159ae1f5af94dc8c9812f9b4e031ed1f08c64fdb6ffca71c0d3fc93c63596100b2dbce1d6cbf34fae84bccb859397f700114b4bba2e56678360f79c9df784e5f21e995f84fb8622543a48351520012ff80144653efc08ed49e62e17050fa4fc1c98cdd8e40c68f9512e3c687b4d000a836a83d21ea810c683a30e79e5fc8626e78961f076aef2f89ab";
    xq1 = "18ab1ad30607288890b387858a";
    xq2 = "19975a38d9368fa99deda7e986";
    xq = "bd7cc6c56616fb5b41f35d8de2a5c61d1894895dfa46aa95c2de4ea5dfe370eb4543d6670898431d29a9efbbb034347cfaeb8a4c55bcb52dca553dd93ae81fa9ad2bc2b5e6a42c3d3b237648a3907d8a11e6db8b008016064f94168f50fddd791c3d72f729c21e811e68db7ae5400a0f02906462241a33e8faa1c20f48aa12253a80ce75f87a81b37a80079a9ecc42d378ee0e19e913769b738628a14b772673b0fcbf777c55be99f974e1eff5bd8c9d190abff776f246e6614b2f8d81ed812c";
    q = "bd7cc6c56616fb5b41f35d8de2a5c61d1894895dfa46aa95c2de4ea5dfe370eb4543d6670898431d29a9efbbb034347cfaeb8a4c55bcb52dca553dd93ae81fa9ad2bc2b5e6a42c3d3b237648a3907d8a11e6db8b008016064f94168f50fddd791c3d72f729c21e811e68db7ae5400a0f02906462241a33e8faa1c20f48aa12253a80ce75f87a81b37a80079a9ecc42d378ee0e19e913769b738628a14b772673b0fcbf777c640b3b2f869336b823710bb296f32aaba903f90af79239c3d97279";
    m = "a25e0fbcc06a40ac879bba988e78b9df8f88b800077d580b615e3f2f663c9ce631eb0229ee7a4d5166122378bd055f686dd382e63c1564c96127ec191c88d1ba02fcf90f1efcfe29bdfab0fd6413dcb4027512d15c2e337f7111e7acc7679cd1b96581461466ca63af5fbfc0579d322ca02413b75a6dce25c529d6475fafbc5d07504a29039c0f567cbb9dff2938687a6e6d4633f9ae46383536060dc7efb90ff99a6e97449e8f8ad24853f70726953b3f1dc82222f8407f98250f2060777cbd05d0b2ed6abb99d86ac30974df41da16bc1e3abd610df6bcff49a2be932baeedf163911eec026dcbd5937734b47ceb48db97c27bd2a35338f90332b75374ae4404913ae82caf14bba7410c638676a544046aed0b6605562186a4ba6b3695ab25f900899bd03a8f3e68d548b4eadbd9a348a142618954b1b9d73245926d6c57e26454db887c6272280c2d0efff1b856762da7c8be77a0006da3ea589b21ee5efec36574c041d8e506af55de52083225242642cafdcdadfa9663e4424a2bb937d3";
    d = "1b0fad4a2011b5721699f46ec269744fed417400013f8eac903a5fdd3bb4c4d10851d5b1a7bf0ce2e6585b3eca2b8fe6bcf895d10a0390cc3adbfcaeda16cd9f007f7ed7da7f7fb19fa9c82a3b58a4c8ab138322e4b25dea92d85147769144cd9ee6403658bbcc65f28ff54ab944ddb21ab0adf3e467a25ba0dc4e613a9d4a0f81380c5c2b44ad3914c9efaa86debc1467bce108a99d0bb408de5657a1529ed7feef126e8b6fc297230c0dfe813118df352fa15b05d40abfeeb0d7dababe94c9e77e9a8ecb3eebe9823aec87d9f8225aef4465f3dfc5db367a60cf517603a7596a1fbf9e8b08f115b73ecf81b684bfad73c093df30ebc07e434caa87c09d55ab0b674b3858afa1939ba249c7265fd747731f2384d75b5fe6b9e06bbd3110787618290fb73cd42aca08f3f2ee855e393a5e6e835aa77cafc7d329c1dde7655abeeb8d74a015f8d2d36a3bc8939864dfd60da40c63435f76ac1b411af42d5145e95d1b0798a8e8b2ee23edb188228061fa60760993399b16b0cb2246c63ec809f3";
    RSAX931BuildTest(e, xp1, xp2, xp, xq1, xq2, xq, p, q, m, d, &publicKey,  &privateKey);

    
    e = 3;
    xp1 = "1a02a180a22a37d3ab4d5523fe";
    xp2 = "1179fc502dbe82ff9946c00392";
    xp = "d94a30017127e43b0005e99016c2f4efb8e0c91e61805b52478e35fddf3918e7a3a6e68013e5be75fa246981f222f5862ae79fdc67b3f7e849343ef1d0fb13301e314f267f862d33a66bae633a813b8b91518c95bb3dca18c2b6f02c30b0777cd253329cbcf4779d8d437fdff4c60f27738658f163081d08397e1353073f8df24675588ad215e4dc3615a59d2ad9b9815aeecb9a69fa37e036f36f115e909dbb02fd8a96cad3be182947e944e3a281c3cdf1ad35d4fd62c9417dcb0b3c8beffe8e558e6bab154b78ef43117c2808af1255f7c56dadf8e4ebe384f1eca918cae473e32caf7dc2d5250f6fe5ef00f68a997968dce7fbd2066da370a75aad1f7895";
    p = "d94a30017127e43b0005e99016c2f4efb8e0c91e61805b52478e35fddf3918e7a3a6e68013e5be75fa246981f222f5862ae79fdc67b3f7e849343ef1d0fb13301e314f267f862d33a66bae633a813b8b91518c95bb3dca18c2b6f02c30b0777cd253329cbcf4779d8d437fdff4c60f27738658f163081d08397e1353073f8df24675588ad215e4dc3615a59d2ad9b9815aeecb9a69fa37e036f36f115e909dbb02fd8a96cad3be182947e944e3a281c3cdf1ad35d4fd62c9417dcb0b3c8beffe8e558e6bab154b78ef43117c2808af1255f7c56dadf8e4ebe384f1eca918cae473e32caf7dd1126fd14c73ebcce310791625550d6582891713c38ac374993099";
    xq1 = "1fb621dce29cbb6a66cc3bf7d6";
    xq2 = "122325102c2e57c27d462e1e06";
    xq = "facc7f5f089ed9267363bc23c6c7b8f73208a36f61fa8ea8084ff777bc154107068061c4b9ead9788318eab4c3bf05729a4684f845ce9700aa70811530c50440d4ac19e47a47e5e78047e912996a79bbd9416fa10c3720174ccf8f65d32de16b0dd81187f1bee5b992792105f1d0fa191681cd305f3e113617f58b2d4a54c0cfd88db075c956c137e034fa5573fa71d67a8c076ee5e952a53369db3640438ab55e515e75a81861a99303dcc9c6efc7382cec83234742ccacc7b3e9485b002565c7af8351370aae57d26b2f2b93b7e2885429ab172c516593fb5c1b2b43957b273a2c87cf1d368e88c6f65b41815bac0d1cc9e6113d1d06a1f8ebdba6a1097343";
    q = "facc7f5f089ed9267363bc23c6c7b8f73208a36f61fa8ea8084ff777bc154107068061c4b9ead9788318eab4c3bf05729a4684f845ce9700aa70811530c50440d4ac19e47a47e5e78047e912996a79bbd9416fa10c3720174ccf8f65d32de16b0dd81187f1bee5b992792105f1d0fa191681cd305f3e113617f58b2d4a54c0cfd88db075c956c137e034fa5573fa71d67a8c076ee5e952a53369db3640438ab55e515e75a81861a99303dcc9c6efc7382cec83234742ccacc7b3e9485b002565c7af8351370aae57d26b2f2b93b7e2885429ab172c516593fb5c1b2b43957b273a2c87cf1d710fc707b5e6d58b6f3cb377b286466c4da41f592c749ebf97fca3";
    m = "d4e0061c2150cdf177232b89266af9153902cbd434a39cab549d997ed6dadcb4e84bbac6d49658428728a01bd7036bab4b0003f7e6ccf69df1effad985185c4ab0756237e4be92b2f42085d4388a29f461af98649c700d6dad5e0fe352513b578b3bff5f19b144e6304defe1b4fb43b37ecb4ed7c0e97377802d9e79c6d742837b3b71fd101fcf5ead4a114d9419af008a421d8a4c5efd4e6da8cc3c967502bd4cc1bda09e87bf7a1d0badaf0783a6dbef5c98359c59d6bda1cc9bacfaa962c841ddfa3670211e38a68998508ea1a2be519718a168d09cc0d2c1d0f8d56ca1d7199b0c4fc78ddb595f6681e5b1b96309251c0714bf134d46f58419a0273bfaab3328b59d75d8ada5e6e2745e816d17ded27b52f0b5632088ee6bf9675793adc52591abc3eacbf3ae4b59871ac9c94e98708801f534ad0a99791827e91cbacf7afbbd72e162698aeba0380f74462b8dd097fb576a99d70ad2117efee8f6ef51d6afd6fb8ce9b6c234ebf00d24d44ad505305e48af1a8037fed9a2a44235980d395bf69489309d37a04b66f236d223b1af759232ecf9d6556a71cd74c4936fc6d3efe6efb3311eea1574e0cebd657a9d36142f0719b95c98900bd32b9cdb6702ff92a7eefc5ec99c6f12709cb3a118cdaf56284dd195e0633dd689889924c42d3e6579e403bb3ecb08310128c673de301c3bea248f3bd0f63cab3f2545da9f8d6b";
    d = "237aabaf5ae2ccfd93db31ec3111d42e342b21f8b3709a1c8e1a443fce79cf737c0c9f21236e640b1686c559f92b3c9c8c8000a95122291a52fd5479962eba0c72be3b0950ca6dc87e056ba35ec1b1a8baf299661a12ace79ce502a5e30d89e3ec89ffe52ef2e0d1080cfd5048d48b489521e2794ad1933e955cefbef67935c09489e854d8054d3a723702e243599d2ac1b5af970cba7f8d1246ccb4c3be2b1f8ccaf4f01a6bf53f04d7479d2beb4679fd3a195e44b9a3ca45a219f229c6e5cc0afa545e680585097116eeb817c59b1fb843d9703c22c4cacdcaf82978e7704e8444820d4becf9e43a9115a648499081862f5683752de2367e40aef00689ff1c3a83010a2a02fd60bde977c71b5066fea69851107da6b3c26fc24ca84a0b8df91491bb3fda29e49ff7af5dd0adfbe3454739a4dac131bf48163de6a5af29c957017aac4e66c493f81440beaa685ff96c323c0f334dbb057055a96a8e7dd8297d229c9e915f2b3b7a4cb33cb5279df74b710e5b178eb456f56c07d64afb55f513df7dec96c388184208da0db6088d410e9aae8ffb46fdcc7b813d5c6a28c49a65ed1956711fb321b89ec38172747c0e09aee2ce756f84bc2f00703e8c35f9d2448a1b24dfea1c45c50d75ba01fb8eb4ae1cabcf8cc9ee5974fe9c14958958fbddc93c5d40daaa1c22e3ffcd00d9eca5d29d030c3491aacc2bb50d30fb4667bab3";
    RSAX931BuildTest(e, xp1, xp2, xp, xq1, xq2, xq, p, q, m, d, &publicKey,  &privateKey);

#endif
   
    bzero(inputpadded, 128);
    bzero(outputpadded, 128);
    bcopy(keydata->bytes, inputpadded, keydata->len);
    decryptedKeyLen = 128;
    retval = CCRSACryptorCrypt(privateKey, inputpadded, 128, encryptedKey, &encryptedKeyLen);

    ok(retval == 0, "RSA Raw Private Key Crypt");
    accum += retval;

    retval = CCRSACryptorCrypt(publicKey, encryptedKey, encryptedKeyLen, outputpadded, &decryptedKeyLen);

    ok(retval == 0, "RSA Raw Private Key Crypt");
    accum += retval;
    bcopy(outputpadded, decryptedKey, keydata->len);
    
 	dekeydata = bytesToBytes(decryptedKey, keydata->len);
    ok(bytesAreEqual(dekeydata, keydata), "RSA Raw Encrypt/Decrypt Round-Trip");
	if(!bytesAreEqual(dekeydata, keydata)) {
        diag("expected: %s\n", bytesToHexString(keydata));
        diag("     got: %s\n", bytesToHexString(dekeydata));
        diag("len = %d\n", (int) decryptedKeyLen);
    }
    
    
    static const uint8_t		kAirTunesRSAPublicKey[] = 
    {
        0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xE7, 0xD7, 0x44, 0xF2, 0xA2, 0xE2, 0x78, 
        0x8B, 0x6C, 0x1F, 0x55, 0xA0, 0x8E, 0xB7, 0x05, 0x44, 0xA8, 0xFA, 0x79, 0x45, 0xAA, 0x8B, 0xE6, 
        0xC6, 0x2C, 0xE5, 0xF5, 0x1C, 0xBD, 0xD4, 0xDC, 0x68, 0x42, 0xFE, 0x3D, 0x10, 0x83, 0xDD, 0x2E, 
        0xDE, 0xC1, 0xBF, 0xD4, 0x25, 0x2D, 0xC0, 0x2E, 0x6F, 0x39, 0x8B, 0xDF, 0x0E, 0x61, 0x48, 0xEA, 
        0x84, 0x85, 0x5E, 0x2E, 0x44, 0x2D, 0xA6, 0xD6, 0x26, 0x64, 0xF6, 0x74, 0xA1, 0xF3, 0x04, 0x92, 
        0x9A, 0xDE, 0x4F, 0x68, 0x93, 0xEF, 0x2D, 0xF6, 0xE7, 0x11, 0xA8, 0xC7, 0x7A, 0x0D, 0x91, 0xC9, 
        0xD9, 0x80, 0x82, 0x2E, 0x50, 0xD1, 0x29, 0x22, 0xAF, 0xEA, 0x40, 0xEA, 0x9F, 0x0E, 0x14, 0xC0, 
        0xF7, 0x69, 0x38, 0xC5, 0xF3, 0x88, 0x2F, 0xC0, 0x32, 0x3D, 0xD9, 0xFE, 0x55, 0x15, 0x5F, 0x51, 
        0xBB, 0x59, 0x21, 0xC2, 0x01, 0x62, 0x9F, 0xD7, 0x33, 0x52, 0xD5, 0xE2, 0xEF, 0xAA, 0xBF, 0x9B, 
        0xA0, 0x48, 0xD7, 0xB8, 0x13, 0xA2, 0xB6, 0x76, 0x7F, 0x6C, 0x3C, 0xCF, 0x1E, 0xB4, 0xCE, 0x67, 
        0x3D, 0x03, 0x7B, 0x0D, 0x2E, 0xA3, 0x0C, 0x5F, 0xFF, 0xEB, 0x06, 0xF8, 0xD0, 0x8A, 0xDD, 0xE4, 
        0x09, 0x57, 0x1A, 0x9C, 0x68, 0x9F, 0xEF, 0x10, 0x72, 0x88, 0x55, 0xDD, 0x8C, 0xFB, 0x9A, 0x8B, 
        0xEF, 0x5C, 0x89, 0x43, 0xEF, 0x3B, 0x5F, 0xAA, 0x15, 0xDD, 0xE6, 0x98, 0xBE, 0xDD, 0xF3, 0x59, 
        0x96, 0x03, 0xEB, 0x3E, 0x6F, 0x61, 0x37, 0x2B, 0xB6, 0x28, 0xF6, 0x55, 0x9F, 0x59, 0x9A, 0x78, 
        0xBF, 0x50, 0x06, 0x87, 0xAA, 0x7F, 0x49, 0x76, 0xC0, 0x56, 0x2D, 0x41, 0x29, 0x56, 0xF8, 0x98, 
        0x9E, 0x18, 0xA6, 0x35, 0x5B, 0xD8, 0x15, 0x97, 0x82, 0x5E, 0x0F, 0xC8, 0x75, 0x34, 0x3E, 0xC7, 
        0x82, 0x11, 0x76, 0x25, 0xCD, 0xBF, 0x98, 0x44, 0x7B, 0x02, 0x03, 0x01, 0x00, 0x01, 0xD4, 0x9D
    };
    
    CCRSACryptorRef		key;
    
    retval = CCRSACryptorImport( kAirTunesRSAPublicKey, sizeof( kAirTunesRSAPublicKey ), &key );

    ok(retval == kCCSuccess, "Imported Airport Key");
    accum += retval;
    
    return accum != 0;
}
#endif /* CCRSA */

/*
 * Copyright (c) 2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

/*
 *  randomTest
 *  CommonCrypto
 */
#include "testmore.h"
#include "capabilities.h"
#include "testbyteBuffer.h"

#if (CCRANDOM == 0)
entryPoint(CommonRandom,"Random Number Generation")
#else
#include <CommonCrypto/CommonRandomSPI.h>

static const int kTestTestCount = 1000;
static const int bufmax = kTestTestCount + 16;

int CommonRandom(int argc, char *const *argv)
{
    int i;
    uint8_t buf1[bufmax], buf2[bufmax], buf3[bufmax], buf4[bufmax], buf5[bufmax], buf6[bufmax];
    CCRandomRef rngref;
    CCRNGStatus retval;
    
	plan_tests(kTestTestCount *3);
    retval = CCRNGCreate(0, &rngref);
    
    struct ccrng_state *devRandom = ccDevRandomGetRngState();
    struct ccrng_state *drbg = ccDRBGGetRngState();
    for(i=0; i<kTestTestCount; i++) {
        size_t len = i+16;
        CCRandomCopyBytes(kCCRandomDefault, buf1, len);
        CCRandomCopyBytes(kCCRandomDevRandom, buf2, len);
        CCRandomCopyBytes(rngref, buf3, len);
        CCRandomCopyBytes(NULL, buf4, len);
        ccrng_generate(devRandom, len, buf5);
        ccrng_generate(drbg, len, buf6);

        ok(memcmp(buf1, buf2, len), "Buffers aren't the same");
        ok(memcmp(buf3, buf4, len), "Buffers aren't the same");
        ok(memcmp(buf2, buf3, len), "Buffers aren't the same");
        ok(memcmp(buf5, buf6, len), "Buffers aren't the same");
        ok(memcmp(buf5, buf2, len), "Buffers aren't the same");
        ok(memcmp(buf6, buf1, len), "Buffers aren't the same");
    }
    retval = CCRNGRelease(rngref);
        
    return 0;
}
#endif

//
//  CryptorPadFailure.c
//  CCRegressions
//
//  Created by Richard Murphy on 5/11/11.
//  Copyright 2011 McKenzie-Murphy. All rights reserved.
//

#include <stdio.h>

regression test suite for security components.
by Michael Brouwer


GOALS
=====

The goals of this test setup are  to have something that required
0 configuration and setup and allows developers to quickly write
new standalone test cases.


USAGE
=====

The tests are runnable from the top level Makefile by typing:
    make test
or individually from the command line or with gdb.  Tests will be
built into a directory called build by default or into LOCAL_BUILD_DIR
if you set that in your environment.


DIRECTORY LAYOUT
================

Currently there are subdirectories for a number of different parts
of the security stack.  Each directory contains some of the unit
tests I've managed to find from radar and other places.

The test programs output their results in a format called TAP.  This
is described here:
    http://search.cpan.org/~petdance/Test-Harness-2.46/lib/Test/Harness/TAP.pod
Because of this we can use Perl's Test::Harness to run the tests
and produce some nice looking output without the need to write an
entire test harness.

Tests can be written in C, C++ or Objective-C or perl (using
Test::More in perl).


WRITING TESTS
=============

To add a new test simply copy one of the existing ones and hack away.
Any file with a main() function in it will be built into a test
automatically by the top level Makefile (no configuration required).

To use the testmore C "library" all you need to do is #include
"testmore.h" in your test program.

Then in your main function you must call:

plan_tests(NUMTESTS) where NUMTESTS is the number of test cases you
test program will run.  After that you can start writing tests.
There are a couple of macros to help you get started:

The following are ways to run an actual test case (as in they count
towards the NUMTESTS number above):

ok(EXPR, NAME)
    Evaluate EXPR if it's true the test passes if false it fails.
    The second argument is a descriptive name of the test for debugging
    purposes.

is(EXPR, VALUE, NAME)
    Evaluate EXPR if it's equal to VALUE the test passes otherwise
    it fails.  This is equivalent to ok(EXPR == VALUE, NAME) except
    this produces nicer output in a failure case.
    CAVEAT: Currently EXPR and VALUE must both be type int.

isnt(EXPR, VALUE, NAME)
    Opposite of is() above.
    CAVEAT: Currently EXPR and VALUE must both be type int.

cmp_ok(EXPR, OP, VALUE, NAME)
    Succeeds if EXPR OP VALUE is true.  Produces a diagnostic if not.
    CAVEAT: Currently EXPR and VALUE must both be type int.

ok_status(EXPR, NAME)
    Evaluate EXPR, if it's 0 the test passes otherwise print a
    diagnostic with the name and number of the error returned.

is_status(EXPR, VALUE, NAME)
    Evaluate EXPR, if the error returned equals VALUE the test
    passes, otherwise print a diagnostic with the expected and
    actual error returned.

ok_unix(EXPR, NAME)
    Evaluate EXPR, if it's >= 0 the test passes otherwise print a
    diagnostic with the name and number of the errno.

is_unix(EXPR, VALUE, NAME)
    Evaluate EXPR, if the errno set by it equals VALUE the test
    passes, otherwise print a diagnostic with the expected and
    actual errno.

Finally if you somehow can't express the success or failure of a
test using the macros above you can use pass(NAME) or fail(NAME)
explicitly.  These are equivalent to ok(1, NAME) and ok(0, NAME)
respectively.


LEAKS
=====

If you want to check for leaks in your test you can #include
"testleaks.h" in your program and call:

ok_leaks(NAME)
    Passes if there are no leaks in your program.

is_leaks(VALUE, NAME)
    Passes if there are exactly VALUE leaks in your program.  Useful
    if you are calling code that is known to leak and you can't fix
    it.  But you still want to make sure there are no new leaks in
    your code.


C++
===

For C++ programs you can #include "testcpp.h" which defines these
additional macros:
no_throw(EXPR, NAME)
    Success if EXPR doesn't throw.

does_throw(EXPR, NAME)
    Success if EXPR does throw.

is_throw(EXPR, CLASS, FUNC, VALUE, NAME)
    Success if EXPR throws an exception of type CLASS and CLASS.FUNC == VALUE.
    Example usage:
    is_throw(CssmError::throwMe(42), CssmError, osStatus(), 42, "throwMe(42)");


TODO and SKIP
=============

Sometimes you write a test case that is known to fail (because you
found a bug).  Rather than commenting out that test case you should
put it inside a TODO block.  This will cause the test to run but
the failure will not be reported as an error.  When the test starts
passing (presumably because someone fixed the bug) you can comment
out the TODO block and leave the test in place.

The syntax for doing this looks like so:

    TODO: {
        todo("<rdar://problem/4000000> ER: AAPL target: $4,000,000/share");

        cmp_ok(apple_stock_price(), >=, 4000000, "stock over 4M");
    }

Sometimes you don't want to run a particular test case or set of
test cases because something in the environment is missing or you
are running on a different version of the OS than the test was
designed for.  To achieve this you can use a SKIP block.

The syntax for a SKIP block looks like so:

    SKIP: {
        skip("only runs on Tiger and later", 4, os_version() >= os_tiger);

        ok(tiger_test1(), "test1");
        ok(tiger_test2(), "test2");
        ok(tiger_test3(), "test3");
        ok(tiger_test4(), "test4");
    }

How it works is like so:  If the third argument to skip evaluates
to false it breaks out of the SKIP block and reports N tests as
being skipped (where N is the second argument to skip)  The reason
for the test being skipped is given as the first argument to skip.


Utility Functions
=================

Anyone writing tests can add new utility functions.  Currently there
is a pair called tests_begin and tests_end.  To get them
#include "testenv.h". Calling them doesn't count as running a test
case, unless you wrap them in an ok() macro.  tests_begin creates
a unique dir in /tmp and sets HOME in the environment to that dir.
tests_end cleans up the mess that tests_begin made.

When writing your own utility functions you will probably want to use
the setup("task") macro so that any uses of ok() and other macros
don't count as actual test cases run, but do report errors when they
fail.   Here is an example of how tests_end() does this:

int
tests_end(int result)
{
        setup("tests_end");
        /* Restore previous cwd and remove scratch dir. */
        return (ok_unix(fchdir(current_dir), "fchdir") &&
                ok_unix(close(current_dir), "close") &&
                ok_unix(rmdir_recursive(scratch_dir), "rmdir_recursive"));
}

Setup cases all tests unil the end of the current funtion to not count
against your test cases test count and they output nothing if they
succeed.

There is also a simple utility header called "testcssm.h" which
currently defines cssm_attach and cssm_detach functions for loading
and initializing cssm and loading a module.

package IPC::Run3;

$VERSION = 0.010;

=head1 NAME

IPC::Run3 - Run a subprocess in batch mode (a la system) on Unix, Win32, etc.

=head1 SYNOPSIS

    use IPC::Run3;    ## Exports run3() by default
    use IPC::Run3 (); ## Don't pollute

    run3 \@cmd, \$in, \$out, \$err;
    run3 \@cmd, \@in, \&out, \$err;

=head1 DESCRIPTION

This module allows you to run a subprocess and redirect stdin, stdout,
and/or stderr to files and perl data structures.  It aims to satisfy 99%
of the need for using system()/qx``/open3() with a simple, extremely
Perlish API and none of the bloat and rarely used features of IPC::Run.

Speed (of Perl code; which is often much slower than the kind of
buffered I/O that this module uses to spool input to and output from the
child command), simplicity, and portability are paramount.  Disk space
is not.

Note that passing in \undef explicitly redirects the associated file
descriptor for STDIN, STDOUT, or STDERR from or to the local equivalent
of /dev/null (this does I<not> pass a closed filehandle).  Passing in
"undef" (or not passing a redirection) allows the child to inherit the
corresponding STDIN, STDOUT, or STDERR from the parent.

Because the redirects come last, this allows STDOUT and STDERR to
default to the parent's by just not specifying them; a common use
case.

B<Note>: This means that:

    run3 \@cmd, undef, \$out;   ## Pass on parent's STDIN

B<does not close the child's STDIN>, it passes on the parent's.  Use

    run3 \@cmd, \undef, \$out;  ## Close child's STDIN

for that.  It's not ideal, but it does work.

If the exact same value is passed for $stdout and $stderr, then
the child will write both to the same filehandle.  In general, this
means that

    run3 \@cmd, \undef, "foo.txt", "foo.txt";
    run3 \@cmd, \undef, \$both, \$both;

will DWYM and pass a single file handle to the child for both
STDOUT and STDERR, collecting all into $both.

=head1 DEBUGGING

To enable debugging use the IPCRUN3DEBUG environment variable to
a non-zero integer value:

    $ IPCRUN3DEBUG=1 myapp

.

=head1 PROFILING

To enable profiling, set IPCRUN3PROFILE to a number to enable
emitting profile information to STDERR (1 to get timestamps,
2 to get a summary report at the END of the program,
3 to get mini reports after each run) or to a filename to
emit raw data to a file for later analysis.

=head1 COMPARISON

Here's how it stacks up to existing APIs:

=over

=item compared to system(), qx'', open "...|", open "|...":

=over

=item + redirects more than one file descriptor

=item + returns TRUE on success, FALSE on failure

=item + throws an error if problems occur in the parent process (or the
pre-exec child)

=item + allows a very perlish interface to perl data structures and
subroutines

=item + allows 1 word invocations to avoid the shell easily:

    run3 ["foo"];  ## does not invoke shell

=item - does not return the exit code, leaves it in $?

=back

=item compared to open2(), open3():

=over

=item + No lengthy, error prone polling / select loop needed

=item + Hides OS dependancies

=item + Allows SCALAR, ARRAY, and CODE references to source and sink I/O

=item + I/O parameter order is like open3()  (not like open2()).

=item - Does not allow interaction with the subprocess

=back

=item compared to IPC::Run::run():

=over

=item + Smaller, lower overhead, simpler, more portable

=item + No select() loop portability issues

=item + Does not fall prey to Perl closure leaks

=item - Does not allow interaction with the subprocess (which
IPC::Run::run() allows by redirecting subroutines).

=item - Lacks many features of IPC::Run::run() (filters, pipes,
redirects, pty support).

=back

=back

=cut

@EXPORT = qw( run3 );
%EXPORT_TAGS = ( all => \@EXPORT );
@ISA = qw( Exporter );
use Exporter;

use strict;
use constant debugging => $ENV{IPCRUN3DEBUG} || $ENV{IPCRUNDEBUG} || 0;
use constant profiling => $ENV{IPCRUN3PROFILE} || $ENV{IPCRUNPROFILE} || 0;
use constant is_win32  => 0 <= index $^O, "Win32";

BEGIN {
   if ( is_win32 ) {
      eval "use Win32 qw( GetOSName ); 1" or die $@;
   }
}

#use constant is_win2k => is_win32 && GetOSName() =~ /Win2000/i;
#use constant is_winXP => is_win32 && GetOSName() =~ /WinXP/i;

use Carp qw( croak );
use File::Temp qw( tempfile );
use UNIVERSAL qw( isa );
use POSIX qw( dup dup2 );

## We cache the handles of our temp files in order to
## keep from having to incur the (largish) overhead of File::Temp
my %fh_cache;

my $profiler;

sub _profiler { $profiler } ## test suite access

BEGIN {
    if ( profiling ) {
        eval "use Time::HiRes qw( gettimeofday ); 1" or die $@;
        if ( $ENV{IPCRUN3PROFILE} =~ /\A\d+\z/ ) {
            require IPC::Run3::ProfPP;
            $profiler = IPC::Run3::ProfPP->new(
                Level => $ENV{IPCRUN3PROFILE},
            );
        }
        else {
            my ( $dest, undef, $class ) =
               reverse split /(=)/, $ENV{IPCRUN3PROFILE}, 2;
            $class = "IPC::Run3::ProfLogger"
                unless defined $class && length $class;
            unless ( eval "require $class" ) {
                my $x = $@;
                $class = "IPC::Run3::$class";
                eval "require IPC::Run3::$class" or die $x;
            }
            $profiler = $class->new(
                Destination => $dest,
            );
        }
        $profiler->app_call( [ $0, @ARGV ], scalar gettimeofday() );
    }
}


END {
    $profiler->app_exit( scalar gettimeofday() ) if profiling;
}


sub _spool_data_to_child {
    my ( $type, $source, $binmode_it ) = @_;

    ## If undef (not \undef) passed, they want the child to inherit
    ## the parent's STDIN.
    return undef unless defined $source;
    warn "binmode()ing STDIN\n" if is_win32 && debugging && $binmode_it;

    my $fh;
    if ( ! $type ) {
        local *FH;  ## Do this the backcompat way
        open FH, "<$source" or croak "$!: $source";
        $fh = *FH{IO};
        if ( is_win32 ) {
            binmode ":raw"; ## Remove all layers
            binmode ":crlf" unless $binmode_it;
        }
        warn "run3(): feeding file '$source' to child STDIN\n"
            if debugging >= 2;
    }
    elsif ( $type eq "FH" ) {
        $fh = $source;
        warn "run3(): feeding filehandle '$source' to child STDIN\n"
            if debugging >= 2;
    }
    else {
        $fh = $fh_cache{in} ||= tempfile;
        truncate $fh, 0;
        seek $fh, 0, 0;
        if ( is_win32 ) {
            binmode $fh, ":raw"; ## Remove any previous layers
            binmode $fh, ":crlf" unless $binmode_it;
        }
        my $seekit;
        if ( $type eq "SCALAR" ) {

            ## When the run3()'s caller asks to feed an empty file
            ## to the child's stdin, we want to pass a live file
            ## descriptor to an empty file (like /dev/null) so that
            ## they don't get surprised by invalid fd errors and get
            ## normal EOF behaviors.
            return $fh unless defined $$source;  ## \undef passed

            warn "run3(): feeding SCALAR to child STDIN",
                debugging >= 3
                   ? ( ": '", $$source, "' (", length $$source, " chars)" )
                   : (),
                "\n"
                if debugging >= 2;

            $seekit = length $$source;
            print $fh $$source or die "$! writing to temp file";

        }
        elsif ( $type eq "ARRAY" ) {
            warn "run3(): feeding ARRAY to child STDIN",
                debugging >= 3 ? ( ": '", @$source, "'" ) : (),
                "\n"
            if debugging >= 2;

            print $fh @$source or die "$! writing to temp file";
            $seekit = grep length, @$source;
        }
        elsif ( $type eq "CODE" ) {
            warn "run3(): feeding output of CODE ref '$source' to child STDIN\n"
                if debugging >= 2;
            my $parms = [];  ## TODO: get these from $options
            while (1) {
                my $data = $source->( @$parms );
                last unless defined $data;
                print $fh $data or die "$! writing to temp file";
                $seekit = length $data;
            }
        }

        seek $fh, 0, 0 or croak "$! seeking on temp file for child's stdin"
            if $seekit;
    }

    croak "run3() can't redirect $type to child stdin"
        unless defined $fh;

    return $fh;
}


sub _fh_for_child_output {
    my ( $what, $type, $dest, $binmode_it ) = @_;

    my $fh;
    if ( $type eq "SCALAR" && $dest == \undef ) {
        warn "run3(): redirecting child $what to oblivion\n"
            if debugging >= 2;

        $fh = $fh_cache{nul} ||= do {
            local *FH;
            open FH, ">" . File::Spec->devnull;
            *FH{IO};
        };
    }
    elsif ( !$type ) {
        warn "run3(): feeding child $what to file '$dest'\n"
            if debugging >= 2;

        local *FH;
        open FH, ">$dest" or croak "$!: $dest";
        $fh = *FH{IO};
    }
    else {
        warn "run3(): capturing child $what\n"
            if debugging >= 2;

        $fh = $fh_cache{$what} ||= tempfile;
        seek $fh, 0, 0;
        truncate $fh, 0;
    }

    if ( is_win32 ) {
        warn "binmode()ing $what\n" if debugging && $binmode_it;
        binmode $fh, ":raw";
        binmode $fh, ":crlf" unless $binmode_it;
    }
    return $fh;
}


sub _read_child_output_fh {
    my ( $what, $type, $dest, $fh, $options ) = @_;

    return if $type eq "SCALAR" && $dest == \undef;

    seek $fh, 0, 0 or croak "$! seeking on temp file for child $what";

    if ( $type eq "SCALAR" ) {
        warn "run3(): reading child $what to SCALAR\n"
            if debugging >= 3;

        ## two read()s are used instead of 1 so that the first will be
        ## logged even it reads 0 bytes; the second won't.
        my $count = read $fh, $$dest, 10_000;
        while (1) {
            croak "$! reading child $what from temp file"
                unless defined $count;

            last unless $count;

            warn "run3(): read $count bytes from child $what",
                debugging >= 3 ? ( ": '", substr( $$dest, -$count ), "'" ) : (),
                "\n"
                if debugging >= 2;

            $count = read $fh, $$dest, 10_000, length $$dest;
        }
    }
    elsif ( $type eq "ARRAY" ) {
        @$dest = <$fh>;
        if ( debugging >= 2 ) {
            my $count = 0;
            $count += length for @$dest;
            warn
                "run3(): read ",
                scalar @$dest,
                " records, $count bytes from child $what",
                debugging >= 3 ? ( ": '", @$dest, "'" ) : (),
                "\n";
        }
    }
    elsif ( $type eq "CODE" ) {
        warn "run3(): capturing child $what to CODE ref\n"
            if debugging >= 3;

        local $_;
        while ( <$fh> ) {
            warn
                "run3(): read ",
                length,
                " bytes from child $what",
                debugging >= 3 ? ( ": '", $_, "'" ) : (),
                "\n"
                if debugging >= 2;

            $dest->( $_ );
        }
    }
    else {
        croak "run3() can't redirect child $what to a $type";
    }

#    close $fh;
}


sub _type {
    my ( $redir ) = @_;
    return "FH" if isa $redir, "IO::Handle";
    my $type = ref $redir;
    return $type eq "GLOB" ? "FH" : $type;
}


sub _max_fd {
    my $fd = dup(0);
    POSIX::close $fd;
    return $fd;
}

my $run_call_time;
my $sys_call_time;
my $sys_exit_time;

sub run3 {
    $run_call_time = gettimeofday() if profiling;

    my $options = @_ && ref $_[-1] eq "HASH" ? pop : {};

    my ( $cmd, $stdin, $stdout, $stderr ) = @_;

    print STDERR "run3(): running ", 
       join( " ", map "'$_'", ref $cmd ? @$cmd : $cmd ), 
       "\n"
       if debugging;

    if ( ref $cmd ) {
        croak "run3(): empty command"     unless @$cmd;
        croak "run3(): undefined command" unless defined $cmd->[0];
        croak "run3(): command name ('')" unless length  $cmd->[0];
    }
    else {
        croak "run3(): missing command" unless @_;
        croak "run3(): undefined command" unless defined $cmd;
        croak "run3(): command ('')" unless length  $cmd;
    }

    my $in_type  = _type $stdin;
    my $out_type = _type $stdout;
    my $err_type = _type $stderr;

    ## This routine procedes in stages so that a failure in an early
    ## stage prevents later stages from running, and thus from needing
    ## cleanup.

    my $in_fh  = _spool_data_to_child $in_type, $stdin,
        $options->{binmode_stdin} if defined $stdin;

    my $out_fh = _fh_for_child_output "stdout", $out_type, $stdout,
        $options->{binmode_stdout} if defined $stdout;

    my $tie_err_to_out =
        defined $stderr && defined $stdout && $stderr eq $stdout;

    my $err_fh = $tie_err_to_out
        ? $out_fh
        : _fh_for_child_output "stderr", $err_type, $stderr,
            $options->{binmode_stderr} if defined $stderr;

    ## this should make perl close these on exceptions
    local *STDIN_SAVE;
    local *STDOUT_SAVE;
    local *STDERR_SAVE;

    my $saved_fd0 = dup( 0 ) if defined $in_fh;

#    open STDIN_SAVE,  "<&STDIN"#  or croak "run3(): $! saving STDIN"
#        if defined $in_fh;
    open STDOUT_SAVE, ">&STDOUT" or croak "run3(): $! saving STDOUT"
        if defined $out_fh;
    open STDERR_SAVE, ">&STDERR" or croak "run3(): $! saving STDERR"
        if defined $err_fh;

    my $ok = eval {
        ## The open() call here seems to not force fd 0 in some cases;
        ## I ran in to trouble when using this in VCP, not sure why.
        ## the dup2() seems to work.
        dup2( fileno $in_fh, 0 )
#        open STDIN,  "<&=" . fileno $in_fh
            or croak "run3(): $! redirecting STDIN"
            if defined $in_fh;

#        close $in_fh or croak "$! closing STDIN temp file"
#            if ref $stdin;

        open STDOUT, ">&" . fileno $out_fh
            or croak "run3(): $! redirecting STDOUT"
            if defined $out_fh;

        open STDERR, ">&" . fileno $err_fh
            or croak "run3(): $! redirecting STDERR"
            if defined $err_fh;

        $sys_call_time = gettimeofday() if profiling;

        my $r = ref $cmd
           ? system {$cmd->[0]}
                   is_win32
                       ? map {
                           ## Probably need to offer a win32 escaping
                           ## option, every command may be different.
                           ( my $s = $_ ) =~ s/"/"""/g;
                           $s = qq{"$s"};
                           $s;
                       } @$cmd
                       : @$cmd
           : system $cmd;

        $sys_exit_time = gettimeofday() if profiling;

        unless ( defined $r ) {
            if ( debugging ) {
                my $err_fh = defined $err_fh ? \*STDERR_SAVE : \*STDERR;
                print $err_fh "run3(): system() error $!\n"
            }
            die $!;
        }

        if ( debugging ) {
            my $err_fh = defined $err_fh ? \*STDERR_SAVE : \*STDERR;
            print $err_fh "run3(): \$? is $?\n"
        }
        1;
    };
    my $x = $@;

    my @errs;

    if ( defined $saved_fd0 ) {
        dup2( $saved_fd0, 0 );
        POSIX::close( $saved_fd0 );
    }

#    open STDIN,  "<&STDIN_SAVE"#  or push @errs, "run3(): $! restoring STDIN"
#        if defined $in_fh;
    open STDOUT, ">&STDOUT_SAVE" or push @errs, "run3(): $! restoring STDOUT"
        if defined $out_fh;
    open STDERR, ">&STDERR_SAVE" or push @errs, "run3(): $! restoring STDERR"
        if defined $err_fh;

    croak join ", ", @errs if @errs;

    die $x unless $ok;

    _read_child_output_fh "stdout", $out_type, $stdout, $out_fh, $options
        if defined $out_fh && $out_type && $out_type ne "FH";
    _read_child_output_fh "stderr", $err_type, $stderr, $err_fh, $options
        if defined $err_fh && $err_type && $err_type ne "FH" && !$tie_err_to_out;
    $profiler->run_exit(
       $cmd,
       $run_call_time,
       $sys_call_time,
       $sys_exit_time,
       scalar gettimeofday 
    ) if profiling;

    return 1;
}

my $in_fh;
my $in_fd;
my $out_fh;
my $out_fd;
my $err_fh;
my $err_fd;
        $in_fh = tempfile;
        $in_fd = fileno $in_fh;
        $out_fh = tempfile;
        $out_fd = fileno $out_fh;
        $err_fh = tempfile;
        $err_fd = fileno $err_fh;
    my $saved_fd0 = dup 0;
    my $saved_fd1 = dup 1;
    my $saved_fd2 = dup 2;
    my $r;
    my ( $cmd, $stdin, $stdout, $stderr );

sub _run3 {
    ( $cmd, $stdin, $stdout, $stderr ) = @_;

    truncate $in_fh, 0;
    seek $in_fh, 0, 0;

    print $in_fh $$stdin or die "$! writing to temp file";
    seek $in_fh, 0, 0;

    seek $out_fh, 0, 0;
    truncate $out_fh, 0;

    seek $err_fh, 0, 0;
    truncate $err_fh, 0;

    dup2 $in_fd,  0 or croak "run3(): $! redirecting STDIN";
    dup2 $out_fd, 1 or croak "run3(): $! redirecting STDOUT";
    dup2 $err_fd, 2 or croak "run3(): $! redirecting STDERR";

    $r = 
       system {$cmd->[0]}
               is_win32
                   ? map {
                       ## Probably need to offer a win32 escaping
                       ## option, every command is different.
                       ( my $s = $_ ) =~ s/"/"""/g;
                       $s = q{"$s"} if /[^\w.:\/\\'-]/;
                       $s;
                   } @$cmd
                   : @$cmd;

    die $! unless defined $r;

    dup2 $saved_fd0, 0;
    dup2 $saved_fd1, 1;
    dup2 $saved_fd2, 2;

    seek $out_fh, 0, 0 or croak "$! seeking on temp file for child output";

        my $count = read $out_fh, $$stdout, 10_000;
        while ( $count == 10_000 ) {
            $count = read $out_fh, $$stdout, 10_000, length $$stdout;
        }
        croak "$! reading child output from temp file"
            unless defined $count;

    seek $err_fh, 0, 0 or croak "$! seeking on temp file for child errput";

        $count = read $err_fh, $$stderr, 10_000;
        while ( $count == 10_000 ) {
            $count = read $err_fh, $$stderr, 10_000, length $$stdout;
        }
        croak "$! reading child stderr from temp file"
            unless defined $count;

    return 1;
}

=cut


=head1 TODO

pty support

=head1 LIMITATIONS

Often uses intermediate files (determined by File::Temp, and thus by the
File::Spec defaults and the TMPDIR env. variable) for speed, portability and
simplicity.

=head1 COPYRIGHT

    Copyright 2003, R. Barrie Slaymaker, Jr., All Rights Reserved

=head1 LICENSE

You may use this module under the terms of the BSD, Artistic, or GPL licenses,
any version.

=head1 AUTHOR

Barrie Slaymaker <barries@slaysys.com>

=cut

1;

use warnings;
use strict;

package MyStraps;
use base qw( Test::Harness::Straps );
 
sub _command_line {
    my $self = shift;
    my $file = shift;

    $file = qq["$file"] if ($file =~ /\s/) && ($file !~ /^".*"$/);
    my $line = "$file";

    return $line;
}

sub _default_inc {
    return @INC;
}
 
package MyHarness;
use base qw( Test::Harness );

#my $Strap = MyStraps->new();
$Test::Harness::Strap = MyStraps->new();
 
sub strap { return $Test::Harness::Strap }
 
1;

#include <stdio.h>


#include "testenv.h"

int main (int argc, char * const *argv) {

    printf("WARNING: If running those tests on a device with a passcode, DONT FORGET TO UNLOCK!!!\n");
    tests_begin(argc, argv);
    return 0;
}

#!/usr/bin/perl -w
#
#  Copyright (c) 2006-2007 Apple Inc. All Rights Reserved.
#

my $pid = $$;

END {
    return unless $$ == $pid;
    rm_test($_) for @TOCLEAN;
}

use strict;
use Test::More;
use IPC::Run3;

sub plan_security {
    
    unless (1) {
	plan skip_all => "security not installed";
	exit;
    };
    plan @_;
}

use Carp;
our @TOCLEAN;
END {
    return unless $$ == $pid;
    $SIG{__WARN__} = sub { 1 };
    cleanup_test($_) for @TOCLEAN;
}

our $output = '';

sub build_test {
    my $xd = "/tmp/test-$pid";
    my $security = 'security';
    $ENV{HOME} = $xd;
    push @TOCLEAN, [$xd, $security];
    return ($xd, $security);
}

sub rm_test {
    my ($xd, $security) = @{+shift};
    #rmtree [$xd];
}

sub cleanup_test {
    return unless $ENV{TEST_VERBOSE};
    my ($xd, $security) = @{+shift};
}

sub is_output {
    my ($security, $cmd, $arg, $expected, $test) = @_;
    $output = '';
    run3([$security, $cmd, @$arg], \undef, \$output, \$output);
#    open(STDOUT, ">&STDERR") || die "couldn't dup strerr: $!";
#    open(my $out, '-|', $security, $cmd, @$arg);
#    while (<$out>) { $output .= $_; }

    my $cmp = (grep {ref ($_) eq 'Regexp'} @$expected)
	? \&is_deeply_like : \&is_deeply;
    @_ = ([sort split (/\r?\n/, $output)], [sort @$expected], $test || join(' ', $cmd, @$arg));
    goto &$cmp;
}

1;

/*
 * Copyright (c) 2006-2007 Apple Inc. All Rights Reserved.
 */

#include <stdlib.h>

#include "testmore.h"

int main(int argc, char *const *argv)
{
    int rv = 1;
    plan_tests(6);

    TODO: {
	todo("ok 0 is supposed to fail");

	rv = ok(0, "ok bad");
	if (!rv)
	    diag("ok bad not good today");
    }
    rv &= ok(1, "ok ok");
#if 0
    SKIP: {
	skip("is bad will fail", 1, 0);

	if (!is(0, 4, "is bad"))
	    diag("is bad not good today");
    }
    SKIP: {
	skip("is ok should not be skipped", 1, 1);

        is(3, 3, "is ok");
    }
#endif
    isnt(0, 4, "isnt ok");
    TODO: {
	todo("isnt bad is supposed to fail");

	isnt(3, 3, "isnt bad");
    }
    TODO: {
	todo("cmp_ok bad is supposed to fail");

	cmp_ok(3, &&, 0, "cmp_ok bad");
    }
    cmp_ok(3, &&, 3, "cmp_ok ok");

    return 0;
}

#!/bin/sh

# run_tests.sh
# Security
#
# Created by Fabrice Gautier on 8/26/10.
# Modified for use with CommonCrypto on 3/10/11
# Copyright 2011 Apple, Inc. All rights reserved.


# Run a command line tool on the sim or the device

CMD=CCRegressions

if [ "${PLATFORM_NAME}" == "iphoneos" ]; then
    INSTALL_DIR=
    SCP_URL=phone:${INSTALL_DIR}
#copy libcommonCrypto.dylib and CCRegressions program to the device, to /tmp
#this will not replace the system CommonCrypto.
#it is assumed that ssh is pre-setup on the device with pubkey authentication
    export RSYNC_PASSWORD=alpine
    echo "run_tests.sh:${LINENO}: note: Copying stuff to device"
    # scp ${CONFIGURATION_BUILD_DIR}/libcommonCrypto.dylib ${SCP_URL}
    scp ${CONFIGURATION_BUILD_DIR}/CCRegressions ${SCP_URL}
    echo "run_tests.sh:${LINENO}: note: Running the test"
    xcrun -sdk "$SDKROOT" PurpleExec --env "DYLD_FRAMEWORK_PATH=${INSTALL_DIR}" --cmd ${INSTALL_DIR}/${CMD}
else
    echo "run_tests.sh:${LINENO}: note: Running test on simulator (${BUILT_PRODUCTS_DIR}/${CMD})"
	export DYLD_ROOT_PATH="${SDKROOT}"
    export DYLD_LIBRARY_PATH="${BUILT_PRODUCTS_DIR}"
    export DYLD_FRAMEWORK_PATH="${BUILT_PRODUCTS_DIR}"
    ${BUILT_PRODUCTS_DIR}/${CMD}
fi

/*
 * Copyright (c) 2005-2007 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 *
 * testcpp.h
 */

#ifndef _TESTCPP_H_
#define _TESTCPP_H_  1

#include "testmore.h"

#ifdef __cplusplus

#define no_throw(THIS, TESTNAME) \
({ \
    bool _this; \
    try { THIS; _this = true; } catch (...) { _this = false; } \
    test_ok(_this, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
		"#          got: <unknown excepetion>\n" \
		"#     expected: <no throw>\n"); \
})
#define does_throw(THIS, TESTNAME) \
({ \
    bool _this; \
    try { THIS; _this = false; } catch (...) { _this = true; } \
    test_ok(_this, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
		"#          got: <no throw>\n" \
		"#     expected: <any excepetion>\n"); \
})
#define is_throw(THIS, CLASS, METHOD, VALUE, TESTNAME) \
({ \
    bool _this; \
    try \
	{ \
		THIS; \
		_this = test_ok(false, TESTNAME, test_directive, test_reason, \
			__FILE__, __LINE__, \
			"#          got: <no throw>\n" \
			"#     expected: %s.%s == %s\n", \
			#CLASS, #METHOD, #VALUE); \
	} \
    catch (const CLASS &_exception) \
    { \
		_this = test_ok(_exception.METHOD == (VALUE), TESTNAME, \
			test_directive, test_reason, __FILE__, __LINE__, \
			"#          got: %d\n" \
			"#     expected: %s.%s == %s\n", \
			_exception.METHOD, #CLASS, #METHOD, #VALUE); \
	} \
    catch (...) \
    { \
    	_this = test_ok(false, TESTNAME, test_directive, test_reason, \
			__FILE__, __LINE__, \
			"#          got: <unknown excepetion>\n" \
			"#     expected: %s.%s == %s\n", \
			#CLASS, #METHOD, #VALUE); \
	} \
	_this; \
})
#endif /* __cplusplus */

#endif /* !_TESTCPP_H_ */

/*
 * Copyright (c) 2005-2007,2009-2010 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 *
 * testenv.c
 */

#include <fcntl.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdbool.h>

#include "testmore.h"
#include "testenv.h"

#if NO_SERVER
#include <securityd/spi.h>

static int current_dir = -1;
static char scratch_dir[50];
static char *home_var;
static bool keep_scratch_dir = false;

static int
rmdir_recursive(const char *path)
{
	char command_buf[256];
	if (strlen(path) + 10 > sizeof(command_buf) || strchr(path, '\''))
	{
		fprintf(stderr, "# rmdir_recursive: invalid path: %s", path);
		return -1;
	}

	sprintf(command_buf, "rm -rf '%s'", path);
	return system(command_buf);
}
#endif

static int tests_init(void) {
    printf("[TEST] CommonCrypto\n");
#if NO_SERVER
	char preferences_dir[80];
	char library_dir[70];

    securityd_init();

	setup("tests_init");
    
    /* Create scratch dir for tests to run in. */
    sprintf(scratch_dir, "/tmp/tst-%d", getpid());
    if (keep_scratch_dir) {
        printf("running tests with HOME=%s\n", scratch_dir);
    }
    sprintf(library_dir, "%s/Library", scratch_dir);
    sprintf(preferences_dir, "%s/Preferences", library_dir);
    return (ok_unix(mkdir(scratch_dir, 0755), "mkdir") &&
            ok_unix(current_dir = open(".", O_RDONLY), "open") &&
            ok_unix(chdir(scratch_dir), "chdir") &&
            ok_unix(setenv("HOME", scratch_dir, 1), "setenv") &&
            /* @@@ Work around a bug that the prefs code in
             libsecurity_keychain never creates the Library/Preferences
             dir. */
            ok_unix(mkdir(library_dir, 0755), "mkdir") &&
            ok_unix(mkdir(preferences_dir, 0755), "mkdir") &&
            ok(home_var = getenv("HOME"), "getenv"));
    
#else
    return 0;
#endif 
}

static int
tests_end(void)
{
    printf("[SUMMARY]\n"); 
#if NO_SERVER
	setup("tests_end");
	/* Restore previous cwd and remove scratch dir. */
	int ok = ok_unix(fchdir(current_dir), "fchdir");
	if (ok)
		ok = ok_unix(close(current_dir), "close");
	if (ok) {
		if (!keep_scratch_dir) {
			ok = ok_unix(rmdir_recursive(scratch_dir), "rmdir_recursive");
		}
	}
    
	return ok;
#else
    return 0;
#endif
}

static void usage(const char *progname)
{
    fprintf(stderr, "usage: %s [-k][-w][testname [testargs] ...]\n", progname);
    exit(1);
}

static int tests_run_index(int i, int argc, char * const *argv)
{
    int verbose = 0;
    int ch;

    while ((ch = getopt(argc, argv, "v")) != -1)
    {
        switch  (ch)
        {
            case 'v':
                verbose++;
                break;
            default:
                usage(argv[0]);
        }
    }

    fprintf(stderr, "[BEGIN] %s\n", testlist[i].name);
    
    run_one_test(&testlist[i], argc, argv);
    if(testlist[i].failed_tests) {
        fprintf(stderr, "[FAIL] %s\n", testlist[i].name);
    } else {
        fprintf(stderr, "duration: %u ms\n", testlist[i].duration);
        fprintf(stderr, "[PASS] %s\n", testlist[i].name);
    }
    
    return 0;
}

static int tests_named_index(const char *testcase)
{
    int i;

    for (i = 0; testlist[i].name; ++i) {
        if (strcmp(testlist[i].name, testcase) == 0) {
            return i;
        }
    }

    return -1;
}

static int tests_run_all(int argc, char * const *argv)
{
    int curroptind = optind;
    int i;

    for (i = 0; testlist[i].name; ++i) {
        tests_run_index(i, argc, argv);
        optind = curroptind;
    }
    
    return 0;
}

int
tests_begin(int argc, char * const *argv)
{
    const char *testcase = NULL;
    bool initialized = false;
    int testix = -1;
	int ch;

    for (;;) {
        while (!testcase && (ch = getopt(argc, argv, "kw")) != -1)
        {
            switch  (ch)
            {
#ifdef NO_SERVER
            case 'k':
                keep_scratch_dir = true;
                break;
#endif
            case 'w':
                sleep(100);
                break;
            case '?':
            default:
                printf("invalid option %c\n",ch); 
                usage(argv[0]);
            }
        }

        if (optind < argc) {
            testix = tests_named_index(argv[optind]);
            if(testix<0) {
                printf("invalid test %s\n",argv[optind]); 
                usage(argv[0]);
            }
        }

        if (testix < 0) {
            if (!initialized) {
                initialized = true;
                tests_init();
                tests_run_all(argc, argv);
            }
            break;
        } else {
            if (!initialized) {
                tests_init();
                initialized = true;
            }
            optind++;
            tests_run_index(testix, argc, argv);
            testix = -1;
        }
    }
        
    /* Cleanups */
    tests_end();
    
    return 0;
}

/*
 * Copyright (c) 2005-2007 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 *
 * testenv.h
 */

#ifndef _TESTENV_H_
#define _TESTENV_H_  1

#ifdef __cplusplus
extern "C" {
#endif

int tests_begin(int argc, char * const *argv);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* !_TESTENV_H_ */

/* This file contains an array of all test functions, last element is NULL */

#include "testmore.h"
#include "testlist.h"

#define ONE_TEST(x) {#x, x, 0 , 0, 0 },
#define DISABLED_ONE_TEST(x)
struct one_test_s testlist[] = {
#include "testlistInc.h"
    { NULL, NULL, 0, 0, 0}, 
};
#undef ONE_TEST
#undef DISABLED_ONE_TEST

/* This file contains all the prototypes for all the test functions */
#ifndef __TESTLIST_H__
#define __TESTLIST_H__


#define ONE_TEST(x) int x(int argc, char *const *argv);
#define DISABLED_ONE_TEST(x) ONE_TEST(x)
#include "testlistInc.h"
#undef ONE_TEST
#undef DISABLED_ONE_TEST


#endif /* __TESTLIST_H__ */

/* To add a test, just add it here */

ONE_TEST(CommonRandom)
ONE_TEST(CommonEC)
ONE_TEST(CommonRSA)
ONE_TEST(CommonHMacClone)
ONE_TEST(CommonCMac)
ONE_TEST(CommonCryptoSymCBC)
ONE_TEST(CommonCryptoSymOFB)
ONE_TEST(CommonCryptoSymGCM)
ONE_TEST(CommonCryptoSymCTR)
ONE_TEST(CommonCryptoSymXTS)
ONE_TEST(CommonCryptoSymRC2)
ONE_TEST(CommonCryptoSymRegression)
ONE_TEST(CommonCryptoSymOffset)
ONE_TEST(CommonCryptoSymZeroLength)
ONE_TEST(CommonCryptoSymCFB)
ONE_TEST(CommonCryptoCTSPadding)
ONE_TEST(CommonSymmetricWrap)
ONE_TEST(CommonDH)
ONE_TEST(CommonDigest)
ONE_TEST(CommonBaseEncoding)
ONE_TEST(CommonCryptoReset)
ONE_TEST(CommonBigNum)
ONE_TEST(CommonBigDigest)

/*
 * Copyright (c) 2005-2007 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 *
 * testmore.c
 */

#include <fcntl.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
// #include <AvailabilityMacros.h>

#include "testmore.h"

static int test_num = 0;
static int test_fails = 0;
static int test_cases = 0;
static const char *test_plan_file;
static int test_plan_line=0;

const char *test_directive = NULL;
const char *test_reason = NULL;

void test_skip(const char *reason, int how_many, int unless)
{
    if (unless)
        return;

    int done;
    for (done = 0; done < how_many; ++done)
        test_ok(1, NULL, "skip", reason, __FILE__, __LINE__, NULL);
}

void test_bail_out(const char *reason, const char *file, unsigned line)
{
    printf("BAIL OUT! (%s at line %u) %s\n", file, line, reason);
    fflush(stdout);
    exit(255);
}

void test_plan_skip_all(const char *reason)
{
    if (test_num > test_cases)
    {
	test_skip(reason, test_cases - test_num, 0);
	exit(test_fails > 255 ? 255 : test_fails);
    }
}

static void test_plan_exit(void)
{
    int status = 0;
    fflush(stdout);

    if (!test_num)
    {
        if (test_cases)
        {
            fprintf(stderr, "%s:%u: warning: No tests run!\n", test_plan_file, test_plan_line);
            status = 255;
        }
        else
        {
            fprintf(stderr, "%s:%u: error: Looks like your test died before it could "
                    "output anything.\n", test_plan_file, test_plan_line);
            status = 255;
        }
    }
    else if (test_num < test_cases)
    {
        fprintf(stderr, "%s:%u: warning: Looks like you planned %d tests but only ran %d.\n",
               test_plan_file, test_plan_line, test_cases, test_num);
        status = test_fails + test_cases - test_num;
    }
    else if (test_num > test_cases)
    {
        fprintf(stderr, "%s:%u: warning: Looks like you planned %d tests but ran %d extra.\n",
               test_plan_file, test_plan_line, test_cases, test_num - test_cases);
        status = test_fails;
    }
    else if (test_fails)
    {
        fprintf(stderr, "%s:%u: error: Looks like you failed %d tests of %d.\n",
               test_plan_file, test_plan_line, test_fails, test_cases);
        status = test_fails;
    }

    fflush(stderr);
    
    /* reset the test plan */
    test_num = 0;
    test_fails = 0;
    test_cases = 0;
}

void test_plan_tests(int count, const char *file, unsigned line)
{
#if 0
    if (atexit(test_plan_exit) < 0)
    {
        fprintf(stderr, "failed to setup atexit handler: %s\n",
                strerror(errno));
        fflush(stderr);
        exit(255);
    }
#endif

	if (test_cases)
    {
        fprintf(stderr,
                "%s:%u: error: You tried to plan twice!\n",
                file, line);
        
        fflush(stderr);
        exit(255);
    }
    else
	{
        if (!count)
        {
            fprintf(stderr, "%s:%u: warning: You said to run 0 tests!  You've got to run "
                    "something.\n", file, line);
            fflush(stderr);
            exit(255);
        }

        test_plan_file=file;
        test_plan_line=line;
        
        test_cases = count;
		fprintf(stderr, "%s:%u: note: 1..%d\n", file, line, test_cases);
		fflush(stdout);
	}
}

int
test_diag(const char *directive, const char *reason,
	const char *file, unsigned line, const char *fmt, ...)
{
	int is_todo = directive && !strcmp(directive, "TODO");
	va_list args;

	va_start(args, fmt);

	if (is_todo)
	{
		fputs("# ", stdout);
		if (fmt)
			vprintf(fmt, args);
		fputs("\n", stdout);
		fflush(stdout);
	}
	else
	{
		fflush(stdout);
		fputs("# ", stderr);
		if (fmt)
			vfprintf(stderr, fmt, args);
		fputs("\n", stderr);
		fflush(stderr);
	}

	va_end(args);

	return 1;
}

int
test_ok(int passed, const char *description, const char *directive,
	const char *reason, const char *file, unsigned line,
	const char *fmt, ...)
{
	int is_todo = !passed && directive && !strcmp(directive, "TODO");
	int is_setup = directive && !is_todo && !strcmp(directive, "SETUP");

	if (is_setup)
	{
		if (!passed)
		{
			fflush(stdout);
			fprintf(stderr, "# SETUP not ok%s%s%s%s\n", 
				   description ? " - " : "",
				   description ? description : "",
				   reason ? " - " : "",
				   reason ? reason : "");
		}
	}
	else
	{
		if (!test_cases)
		{
			atexit(test_plan_exit);
			fprintf(stderr, "You tried to run a test without a plan!  "
					"Gotta have a plan. at %s line %u\n", file, line);
			fflush(stderr);
			exit(255);
		}

		++test_num;
		if (test_num > test_cases || (!passed && !is_todo))
			++test_fails;
/* We dont need to print this unless we want to */
#if 0
		fprintf(stderr, "%s:%u: note: %sok %d%s%s%s%s%s%s\n", file, line, passed ? "" : "not ", test_num,
			   description ? " - " : "",
			   description ? description : "",
			   directive ? " # " : "",
			   directive ? directive : "",
			   reason ? " " : "",
			   reason ? reason : "");
#endif
 }

    if (passed)
		fflush(stdout);
	else
    {
		va_list args;

		va_start(args, fmt);

		if (is_todo)
		{
/* Enable this to output TODO as warning */
#if 0             
			printf("%s:%d: warning: Failed (TODO) test\n", file, line);
			if (fmt)
				vprintf(fmt, args);
#endif
			fflush(stdout);
		}
        else
		{
			fflush(stdout);
			fprintf(stderr, "%s:%d: error: Failed test\n", file, line);
			if (fmt)
				vfprintf(stderr, fmt, args);
			fflush(stderr);
		}

		va_end(args);
    }

    return passed;
}


const char *
sec_errstr(int err)
{
#if 1
	static int bufnum = 0;
    static char buf[2][20];
	bufnum = bufnum ? 0 : 1;
    sprintf(buf[bufnum], "0x%X", err);
    return buf[bufnum];
#else /* !1 */
    if (err >= errSecErrnoBase && err <= errSecErrnoLimit)
        return strerror(err - 100000);

#ifdef MAC_OS_X_VERSION_10_4
    /* AvailabilityMacros.h would only define this if we are on a
       Tiger or later machine. */
    extern const char *cssmErrorString(long);
    return cssmErrorString(err);
#else /* !defined(MAC_OS_X_VERSION_10_4) */
    extern const char *_ZN8Security15cssmErrorStringEl(long);
    return _ZN8Security15cssmErrorStringEl(err);
#endif /* MAC_OS_X_VERSION_10_4 */
#endif /* !1 */
}

/* run one test, described by test, return info in test struct */
int run_one_test(struct one_test_s *test, int argc, char * const *argv)
{
    struct timeval start, stop;
    
    if(test->entry==NULL) {
        printf("%s:%d: error: wtf?\n", __FILE__, __LINE__);
        return -1;
    }
    
    gettimeofday(&start, NULL);
    test->entry(argc, argv);
    gettimeofday(&stop, NULL);
    
    test_plan_exit();
    
    /* this may overflow... */
    test->duration=(unsigned int) (stop.tv_sec-start.tv_sec)*1000+(stop.tv_usec/1000)-(start.tv_usec/1000);
    test->failed_tests=test_fails;
    
    return test_fails;
};

/*
 * Copyright (c) 2005-2007 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 *
 * testmore.h
 */

#ifndef _TESTMORE_H_
#define _TESTMORE_H_  1

#include <errno.h>
#include <string.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

/* This is included here, because its already included by all the test case */
#include "testlist.h"
    
typedef int (*one_test_entry)(int argc, char *const *argv);
    
#define ONE_TEST_ENTRY(x) int x(int argc, char *const *argv)
    
struct one_test_s {
    char *name;            /* test name */
    one_test_entry entry;  /* entry point */
    int sub_tests;         /* number of subtests */
    int failed_tests;      /* number of failed tests*/
    unsigned int duration; /* test duration in msecs */
    /* add more later: timing, etc... */
};

extern struct one_test_s testlist[];
    
int run_one_test(struct one_test_s *test, int argc, char * const *argv);

/* this test harnes rely on shadowing for TODO, SKIP and SETUP blocks */
#pragma GCC diagnostic ignored "-Wshadow"
    
#define ok(THIS, TESTNAME) \
    test_ok(!!(THIS), TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, NULL)
#define is(THIS, THAT, TESTNAME) \
({ \
    __typeof__(THIS) _this = (THIS); \
    __typeof__(THAT) _that = (THAT); \
    test_ok((_this == _that), TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
		"#          got: '%d'\n" \
		"#     expected: '%d'\n", \
		_this, _that); \
})
#define isnt(THIS, THAT, TESTNAME) \
	cmp_ok((THIS), !=, (THAT), (TESTNAME))
#define diag(MSG, ARGS...) \
	test_diag(test_directive, test_reason, __FILE__, __LINE__, MSG, ## ARGS)
#define cmp_ok(THIS, OP, THAT, TESTNAME) \
({ \
	__typeof__(THIS) _this = (THIS); \
	__typeof__(THAT) _that = (THAT); \
	test_ok((_this OP _that), TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
	   "#     '%d'\n" \
	   "#         " #OP "\n" \
	   "#     '%d'\n", \
	   _this, _that); \
})
#define eq_string(THIS, THAT, TESTNAME) \
({ \
	const char *_this = (THIS); \
	const char *_that = (THAT); \
	test_ok(!strcmp(_this, _that), TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
	   "#     '%s'\n" \
	   "#         eq\n" \
	   "#     '%s'\n", \
	   _this, _that); \
})
#define eq_stringn(THIS, THISLEN, THAT, THATLEN, TESTNAME) \
({ \
	__typeof__(THISLEN) _thislen = (THISLEN); \
	__typeof__(THATLEN) _thatlen = (THATLEN); \
	const char *_this = (THIS); \
	const char *_that = (THAT); \
	test_ok(_thislen == _thatlen && !strncmp(_this, _that, _thislen), \
		TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
	   "#     '%.*s'\n" \
	   "#         eq\n" \
	   "#     '%.*s'\n", \
	   (int)_thislen, _this, (int)_thatlen, _that); \
})
#define like(THIS, REGEXP, TESTNAME) like_not_yet_implemented()
#define unlike(THIS, REGEXP, TESTNAME) unlike_not_yet_implemented()
#define is_deeply(STRUCT1, STRUCT2, TESTNAME) is_deeply_not_yet_implemented()
#define TODO switch(0) default
#define SKIP switch(0) default
#define SETUP switch(0) default
#define todo(REASON) const char *test_directive __attribute__((unused)) = "TODO", \
	*test_reason __attribute__((unused)) = (REASON)
#define skip(WHY, HOW_MANY, UNLESS) if (!(UNLESS)) \
    { test_skip((WHY), (HOW_MANY), 0); break; }
#define setup(REASON) const char *test_directive = "SETUP", \
	*test_reason = (REASON)
#define pass(TESTNAME) ok(1, (TESTNAME))
#define fail(TESTNAME) ok(0, (TESTNAME))
#define BAIL_OUT(WHY) test_bail_out(WHY, __FILE__, __LINE__)
#define plan_skip_all(REASON) test_plan_skip_all(REASON)
#define plan_tests(COUNT) test_plan_tests(COUNT, __FILE__, __LINE__)

#define ok_status(THIS, TESTNAME) \
({ \
	OSStatus _this = (THIS); \
	test_ok(!_this, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
	   "#     status: %s(%ld)\n", \
	   sec_errstr(_this), _this); \
})
#define is_status(THIS, THAT, TESTNAME) \
({ \
    OSStatus _this = (THIS); \
    OSStatus _that = (THAT); \
    test_ok(_this == _that, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
	   "#          got: %s(%ld)\n" \
	   "#     expected: %s(%ld)\n", \
	   sec_errstr(_this), _this, sec_errstr(_that), _that); \
})
#define ok_unix(THIS, TESTNAME) \
({ \
    int _this = (THIS) < 0 ? errno : 0; \
    test_ok(!_this, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
	   "#          got: %s(%d)\n", \
	   strerror(_this), _this); \
})
#define is_unix(THIS, THAT, TESTNAME) \
({ \
    int _result = (THIS); \
    int _this = _result < 0 ? errno : 0; \
    int _that = (THAT); \
    _that && _result < 0 \
	? test_ok(_this == _that, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
		"#          got: %s(%d)\n" \
		"#     expected: %s(%d)\n", \
		strerror(_this), _this, strerror(_that), _that) \
	: test_ok(_this == _that, TESTNAME, test_directive, test_reason, \
		__FILE__, __LINE__, \
		"#            got: %d\n" \
		"# expected errno: %s(%d)\n", \
		_result, strerror(_that), _that); \
})


extern const char *test_directive;
extern const char *test_reason;

void test_bail_out(const char *reason, const char *file, unsigned line);
int test_diag(const char *directive, const char *reason,
	const char *file, unsigned line, const char *fmt, ...);
int test_ok(int passed, const char *description, const char *directive,
	const char *reason, const char *file, unsigned line, const char *fmt, ...);
void test_plan_skip_all(const char *reason);
void test_plan_tests(int count, const char *file, unsigned line);
void test_skip(const char *reason, int how_many, int unless);

const char *sec_errstr(int err);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* !_TESTMORE_H_ */

//
//  capabilities.h
//  CCRegress
//

#include <Availability.h>

#ifndef __CAPABILITIES_H__
#define __CAPABILITIES_H__

#define entryPoint(testname,supportname) \
int testname(int argc, char *const *argv) { \
char prString[80];\
sprintf(prString, "No %s Support in this release\n", supportname);\
plan_tests(1); \
diag(prString); \
ok(1, prString); \
return 0; \
}


#define _SNOWLEOPARD_ 1060
#define _LION_ 1070
#define _ZIN_ 1080
#define _CAB_ 1090
#define _NMOS_ 1091



#if __MAC_OS_X_VERSION_MAX_ALLOWED < _NMOS_
#define CC_RMD128_DIGEST_LENGTH 16
#define CC_RMD160_DIGEST_LENGTH 20
#define CC_RMD256_DIGEST_LENGTH 32
#define CC_RMD320_DIGEST_LENGTH 40
#endif


#define CRYPTORWITHMODE 1
#define CCDIGEST 1
#define CCRANDOM 1
#define CCKEYDERIVATION 1
#define CCCMAC 1
#define CCRSA 1
#define CCEC 1
#define CCDH 1
#define CCBIGNUM 1
#define CCRESET 1
#define CCSYMREGRESSION 1
#define CCSYMOFFSET 1
#define CCSYMZEROLEN 1
#define CCSYMCBC 1
#define CCSYMOFB 1
#define CCSYMCFB 1
#define CCSYMGCM 1
#define CCSYMXTS 1
#define CCSYMRC2 1
#define CCPADCTS 1
#define CCHMACCLONE 1
#define CCSELFTEST 0
#define CCSYMWRAP 1
#define CNENCODER 0
#define CCBIGDIGEST 0
#define CCSYMCTR 1

#endif /* __CAPABILITIES_H__ */