--- /dev/null
+/* Copyright (c) 1998,2003-2005,2008 Apple Inc.
+ *
+ * wrapTest.c - wrap/unwrap exerciser.
+ *
+ * Revision History
+ * ----------------
+ * 4 May 2000 Doug Mitchell
+ * Ported to X/CDSA2.
+ * 6 Aug 1998 Doug Mitchell at Apple
+ * Created.
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <Security/cssm.h>
+#include "cspwrap.h"
+#include "common.h"
+#include "cspdlTesting.h"
+
+/*
+ * Currently the CSP can use wrapping keys flagged exclusively for wrapping
+ * (CSSM_KEYUSE_{WRAP,UNWRAP} for the actual wrap sinceÊthe wrp/unwrap op is
+ * done with an encrypt/decrypt op. The WrapKey op doesn't even see the
+ * wrapping key - it's in the context we pass it. Thus for now wrap/unwrap
+ * keys have to be marked with CSSM_KEYUSE_ANY.
+ */
+#define WRAP_USAGE_ANY 0
+
+/*
+ * When false, the CMS wrap algorithm can't deal with RSA encryption - we
+ * have to encrypt something twice with the same key. An impossibility with
+ * BSAFE-based RSA encryption because the output of the first encrypt is
+ * the size of the key modulus, and you can't encrypt something that big
+ * with that key.
+ * This is not a limitation with openssl-based RSA.
+ */
+#define WRAP_WITH_RSA 1
+
+/*
+ * When false, can't wrap with RC4 because the RC4 context is stateful
+ * but doesn't get reinit'd for the second CMS encrypt.
+ */
+#define WRAP_WITH_RC4 1
+
+/*
+ * Temporary hack to use CSSM_KEYBLOB_WRAPPED_FORMAT_{PKCS7,PKCS8}, which
+ * are no longer supported as of 7/28/00
+ */
+#define PKCS7_FORMAT_ENABLE 1 // for wrapping symmetric keys
+#define PKCS8_FORMAT_ENABLE 1 // for wrapping private keys
+
+
+#define ENCR_LABEL "encrKey"
+#define ENCR_LABEL_LEN (strlen(ENCR_LABEL))
+#define WRAP_LABEL "wrapKey"
+#define WRAP_LABEL_LEN (strlen(WRAP_LABEL))
+#define LOOPS_DEF 10
+#define MAX_PTEXT_SIZE 100
+#define LOOP_PAUSE 100
+#define MAX_DESC_DATA_SIZE 16
+
+/*
+ * Enumerate algorithms our way to allow loop interations.
+ */
+typedef unsigned PrivAlg;
+enum {
+ ALG_DES = 1,
+ ALG_3DES,
+ ALG_RC2,
+ ALG_RC4,
+ ALG_RSA,
+ ALG_NULL,
+ ALG_FEEDEXP,
+ ALG_ASC,
+ ALG_AES
+};
+
+#define ALG_MIN ALG_DES
+#define ALG_MAX_WRAP ALG_AES
+#define ALG_MAX_ENCR ALG_AES
+
+static void usage(char **argv)
+{
+ printf("usage: %s [options]\n", argv[0]);
+ printf(" Options:\n");
+ printf(" w=wrapAlg (d=DES, 3=3DES, f=FEEDEXP, r=RSA, A=ASC, 4=RC4, "
+ "a=AES, n=null)\n");
+ printf(" e=encrAlg (d=DES, 3=3DES, f=FEEDEXP, r=RSA, A=ASC, 4=RC4, "
+ "a=AES)\n");
+ printf(" l=loops (default=%d; 0=forever)\n", LOOPS_DEF);
+ printf(" r (ref keys only)\n");
+ printf(" p(ause every loop)\n");
+ printf(" D (CSP/DL; default = bare CSP)\n");
+ printf(" v(erbose)\n");
+ printf(" k (quick; small keys)\n");
+ printf(" h(elp)\n");
+ exit(1);
+}
+
+/* wrapped format to string */
+static const char *formatString(CSSM_KEYBLOB_FORMAT format)
+{
+ static char noform[100];
+
+ switch(format) {
+ case CSSM_KEYBLOB_WRAPPED_FORMAT_NONE:
+ return "NONE (default)";
+ case CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7:
+ return "PKCS7";
+ case CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS8:
+ return "PKCS8";
+ case CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM:
+ return "APPLE_CUSTOM";
+ default:
+ sprintf(noform, "***UNKNOWN (%u)***", (unsigned)format);
+ return noform;
+ }
+}
+
+static int vfyWrapHeader(
+ const CSSM_KEYHEADER *srcHdr,
+ const CSSM_KEYHEADER *dstHdr,
+ CSSM_KEYBLOB_TYPE expectBlob,
+ const char *op,
+ CSSM_BOOL bareCsp,
+ int quiet)
+{
+ if(dstHdr->BlobType != expectBlob) {
+ printf("***%s.BlobType error: expect %u got %u\n",
+ op, (unsigned)expectBlob, (unsigned)dstHdr->BlobType);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ if(srcHdr->KeyClass != dstHdr->KeyClass) {
+ printf("***%s.KeyClass error: expect %u got %u\n",
+ op, (unsigned)srcHdr->KeyClass, (unsigned)dstHdr->KeyClass);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ if(srcHdr->AlgorithmId != dstHdr->AlgorithmId) {
+ printf("***%s.AlgorithmId error: expect %u got %u\n",
+ op, (unsigned)srcHdr->AlgorithmId, (unsigned)dstHdr->AlgorithmId);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ if(srcHdr->KeyUsage != dstHdr->KeyUsage) {
+ printf("***%s.KeyUsage error: expect 0x%x got 0x%x\n",
+ op, (unsigned)srcHdr->KeyUsage, (unsigned)dstHdr->KeyUsage);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ if(bareCsp) {
+ /* GUIDs must match */
+ if(memcmp(&srcHdr->CspId, &dstHdr->CspId, sizeof(CSSM_GUID))) {
+ printf("***%s.CspId mismatch\n", op);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ }
+ else {
+ /* CSPDL - GUIDs do NOT match - ref keys are in the CSPDL's domain;
+ * wrapped keys are in the bare CSP's domain. */
+ if(!memcmp(&srcHdr->CspId, &dstHdr->CspId, sizeof(CSSM_GUID))) {
+ printf("***Unexpected %s.CspId compare\n", op);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+#define UNWRAPPED_LABEL "unwrapped thing"
+#define SHOW_WRAP_FORMAT 0
+
+/* not all algs need this */
+CSSM_DATA initVector = {16, (uint8 *)"SomeReallyStrangeInitVect"};
+
+static int doTest(CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR encrKey,
+ CSSM_BOOL wrapEncrKey, // wrap encrKey before using
+ CSSM_KEY_PTR decrKey, // we wrap this one
+ CSSM_KEY_PTR wrappingKey, // ...using this key
+ CSSM_KEY_PTR unwrappingKey,
+ CSSM_ALGORITHMS wrapAlg,
+ CSSM_ENCRYPT_MODE wrapMode,
+ CSSM_KEYBLOB_FORMAT wrapFormat, // NONE, PKCS7, PKCS8, APPLE_CUSTOM
+ CSSM_KEYBLOB_FORMAT expectFormat, // PKCS7, PKCS8, APPLE_CUSTOM
+ CSSM_PADDING wrapPad,
+ uint32 wrapIvSize,
+ CSSM_ALGORITHMS encrAlg,
+ CSSM_ENCRYPT_MODE encrMode,
+ CSSM_PADDING encrPad,
+ uint32 encrIvSize,
+ uint32 effectiveKeySizeInBits, // for encr/decr - 0 means none specified
+ CSSM_DATA_PTR ptext,
+ CSSM_DATA_PTR descData,
+ CSSM_BOOL quiet,
+ CSSM_BOOL bareCsp)
+{
+ CSSM_DATA ctext;
+ CSSM_DATA rptext;
+ CSSM_KEY wrappedDecrKey;
+ CSSM_KEY unwrappedDecrKey;
+ CSSM_KEY wrappedEncrKey;
+ CSSM_RETURN crtn;
+ CSSM_KEY_PTR actualEncrKey;
+ uint32 maxPtextSize = MAX_PTEXT_SIZE;
+ CSSM_DATA outDescData1 = {0, NULL}; // for encr key
+ CSSM_DATA outDescData2 = {0, NULL}; // for decr key, must match descData
+ CSSM_DATA nullInitVect = {0, NULL}; // for custom unwrap
+ CSSM_DATA_PTR wrapIvp;
+ CSSM_DATA_PTR encrIvp;
+
+ /* Hack to deal with RSA's max encrypt size */
+ #if 0
+ /* no more */
+ if(encrAlg == CSSM_ALGID_RSA) {
+ uint32 keySizeBytes = encrKey->KeyHeader.LogicalKeySizeInBits / 8;
+ maxPtextSize = keySizeBytes - 11;
+ if(maxPtextSize > MAX_PTEXT_SIZE) {
+ maxPtextSize = MAX_PTEXT_SIZE;
+ }
+ }
+ else {
+ maxPtextSize = MAX_PTEXT_SIZE;
+ }
+ #endif
+ simpleGenData(ptext, 1, maxPtextSize);
+
+ /*
+ * Optionaly wrap/unwrap encrKey. If encrKey is a ref key, do a
+ * NULL wrap. If encrKey is a raw key, do a NULL unwrap.
+ */
+ if(wrapEncrKey) {
+ CSSM_KEYBLOB_TYPE expectBlob;
+
+ if(encrKey->KeyHeader.BlobType == CSSM_KEYBLOB_REFERENCE) {
+ crtn = cspWrapKey(cspHand,
+ encrKey,
+ NULL, // wrappingKey
+ CSSM_ALGID_NONE,
+ CSSM_ALGMODE_NONE,
+ wrapFormat,
+ CSSM_PADDING_NONE,
+ NULL, // iv
+ descData,
+ &wrappedEncrKey);
+ expectBlob = CSSM_KEYBLOB_RAW;
+ }
+ else {
+ crtn = cspUnwrapKey(cspHand,
+ encrKey,
+ NULL, // unwrappingKey
+ CSSM_ALGID_NONE,
+ CSSM_ALGMODE_NONE,
+ CSSM_PADDING_NONE,
+ NULL, // iv
+ &wrappedEncrKey,
+ &outDescData1,
+ WRAP_LABEL,
+ WRAP_LABEL_LEN);
+ expectBlob = CSSM_KEYBLOB_REFERENCE;
+ }
+ if(crtn) {
+ return testError(quiet);
+ }
+ if(vfyWrapHeader(&encrKey->KeyHeader,
+ &wrappedEncrKey.KeyHeader,
+ expectBlob,
+ "wrappedEncrKey",
+ bareCsp,
+ quiet)) {
+ return 1;
+ }
+ actualEncrKey = &wrappedEncrKey;
+ }
+ else {
+ actualEncrKey = encrKey;
+ }
+ /* encrypt using actualEncrKey ==> ctext */
+ ctext.Data = NULL;
+ ctext.Length = 0;
+ if(encrIvSize) {
+ initVector.Length = encrIvSize;
+ encrIvp = &initVector;
+ }
+ else {
+ encrIvp = NULL;
+ }
+ crtn = cspEncrypt(cspHand,
+ encrAlg,
+ encrMode,
+ encrPad,
+ actualEncrKey,
+ NULL, // no 2nd key
+ effectiveKeySizeInBits,
+ 0, // rounds
+ encrIvp,
+ ptext,
+ &ctext,
+ CSSM_TRUE); // mallocCtext
+ if(crtn) {
+ return testError(quiet);
+ }
+ /* wrap decrKey using wrappingKey ==> wrappedDecrKey */
+ /* Note that APPLE_CUSTOM wrap alg REQUIRES an 8-byte IV */
+ if(expectFormat == CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM) {
+ initVector.Length = 8;
+ }
+ else {
+ initVector.Length = wrapIvSize;
+ }
+ crtn = cspWrapKey(cspHand,
+ decrKey,
+ wrappingKey,
+ wrapAlg,
+ wrapMode,
+ wrapFormat,
+ wrapPad,
+ &initVector,
+ descData,
+ &wrappedDecrKey);
+ if(crtn) {
+ return testError(quiet);
+ }
+ if(wrapAlg != CSSM_ALGID_NONE) {
+ if(wrappedDecrKey.KeyHeader.Format != expectFormat) {
+ printf("***Wrap format mismatch expect %s got %s\n",
+ formatString(wrappedDecrKey.KeyHeader.Format),
+ formatString(expectFormat));
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ }
+
+ if(vfyWrapHeader(&decrKey->KeyHeader,
+ &wrappedDecrKey.KeyHeader,
+ (wrapAlg == CSSM_ALGID_NONE) ? CSSM_KEYBLOB_RAW : CSSM_KEYBLOB_WRAPPED,
+ "wrappedDecrKey",
+ bareCsp,
+ quiet)) {
+ return 1;
+ }
+
+ if(wrappedDecrKey.KeyHeader.Format == CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM) {
+ /* special case - no IV needed - test it */
+ wrapIvp = &nullInitVect;
+ }
+ else {
+ wrapIvp = &initVector;
+ initVector.Length = wrapIvSize;
+ }
+
+ /* unwrap wrappedDecrKey using unwrappingKey ==> unwrappedDecrKey; */
+ crtn = cspUnwrapKey(cspHand,
+ &wrappedDecrKey,
+ unwrappingKey,
+ wrapAlg,
+ wrapMode,
+ wrapPad,
+ wrapIvp,
+ &unwrappedDecrKey,
+ &outDescData2,
+ "unwrapped thing",
+ 15);
+ if(crtn) {
+ return testError(quiet);
+ }
+
+ if(vfyWrapHeader(&wrappedDecrKey.KeyHeader,
+ &unwrappedDecrKey.KeyHeader,
+ CSSM_KEYBLOB_REFERENCE,
+ "unwrappedDecrKey",
+ bareCsp,
+ quiet)) {
+ return 1;
+ }
+
+ /* compare descData to outDescData2 */
+ if(descData) {
+ if(descData->Length != outDescData2.Length) {
+ printf("descData length mismatch\n");
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ if(memcmp(descData->Data, outDescData2.Data, outDescData2.Length)) {
+ printf("***descDatadata miscompare\n");
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ }
+
+ /* decrypt ctext with unwrappedDecrKey ==> rptext; */
+ rptext.Data = NULL;
+ rptext.Length = 0;
+ if(encrIvSize) {
+ initVector.Length = encrIvSize;
+ }
+ crtn = cspDecrypt(cspHand,
+ encrAlg,
+ encrMode,
+ encrPad,
+ &unwrappedDecrKey,
+ NULL, // no 2nd key
+ effectiveKeySizeInBits,
+ 0, // rounds
+ &initVector,
+ &ctext,
+ &rptext,
+ CSSM_TRUE);
+ if(crtn) {
+ return testError(quiet);
+ }
+ /* compare ptext vs. rptext; */
+ if(ptext->Length != rptext.Length) {
+ printf("ptext length mismatch\n");
+ return testError(quiet);
+ }
+ if(memcmp(ptext->Data, rptext.Data, ptext->Length)) {
+ printf("***data miscompare\n");
+ return testError(quiet);
+ }
+ /* free resources */
+ cspFreeKey(cspHand, &wrappedDecrKey);
+ cspFreeKey(cspHand, &unwrappedDecrKey);
+ if(wrapEncrKey) {
+ cspFreeKey(cspHand, actualEncrKey);
+ }
+ CSSM_FREE(ctext.Data);
+ CSSM_FREE(rptext.Data);
+ if(outDescData2.Data != NULL) {
+ CSSM_FREE(outDescData2.Data);
+ }
+ if(outDescData1.Data != NULL) {
+ CSSM_FREE(outDescData1.Data);
+ }
+ return 0;
+}
+
+/*
+ * values associated with a private algorithm (e.g., ALG_DES).
+ */
+typedef enum {
+ WT_Symmetric,
+ WT_Asymmetric,
+ WT_Null
+} wrapType;
+
+typedef struct {
+ uint32 keyGenAlg;
+ wrapType wtype;
+ CSSM_ALGORITHMS encrAlg;
+ CSSM_ENCRYPT_MODE encrMode;
+ CSSM_PADDING encrPad;
+ uint32 ivSize; // in bytes; 0 means no IV
+ const char *algName;
+} AlgInfo;
+
+/*
+ * Convert our private alg to CDSA keygen alg, encr alg, encr mode, pad
+ */
+static void getAlgInfo(PrivAlg privAlg, // e.g., ALG_DES
+ AlgInfo *algInfo)
+{
+ switch(privAlg) {
+ case ALG_DES:
+ algInfo->keyGenAlg = CSSM_ALGID_DES;
+ algInfo->wtype = WT_Symmetric;
+ algInfo->encrAlg = CSSM_ALGID_DES;
+ algInfo->encrMode = CSSM_ALGMODE_CBCPadIV8;
+ algInfo->encrPad = CSSM_PADDING_PKCS5;
+ algInfo->ivSize = 8;
+ algInfo->algName = "DES";
+ break;
+ case ALG_3DES:
+ algInfo->keyGenAlg = CSSM_ALGID_3DES_3KEY;
+ algInfo->wtype = WT_Symmetric;
+ algInfo->encrAlg = CSSM_ALGID_3DES_3KEY_EDE;
+ algInfo->encrMode = CSSM_ALGMODE_CBCPadIV8;
+ algInfo->encrPad = CSSM_PADDING_PKCS5;
+ algInfo->ivSize = 8;
+ algInfo->algName = "3DES";
+ break;
+ case ALG_FEEDEXP:
+ algInfo->keyGenAlg = CSSM_ALGID_FEE;
+ algInfo->wtype = WT_Asymmetric;
+ algInfo->encrAlg = CSSM_ALGID_FEEDEXP;
+ algInfo->encrMode = CSSM_ALGMODE_NONE;
+ algInfo->encrPad = CSSM_PADDING_NONE;
+ algInfo->ivSize = 0;
+ algInfo->algName = "FEEDEXP";
+ break;
+ case ALG_RSA:
+ algInfo->keyGenAlg = CSSM_ALGID_RSA;
+ algInfo->wtype = WT_Asymmetric;
+ algInfo->encrAlg = CSSM_ALGID_RSA;
+ algInfo->encrMode = CSSM_ALGMODE_NONE;
+ algInfo->encrPad = CSSM_PADDING_PKCS1;
+ algInfo->ivSize = 0;
+ algInfo->algName = "RSA";
+ break;
+ case ALG_ASC:
+ algInfo->keyGenAlg = CSSM_ALGID_ASC;
+ algInfo->wtype = WT_Symmetric;
+ algInfo->encrAlg = CSSM_ALGID_ASC;
+ algInfo->encrMode = CSSM_ALGMODE_NONE;
+ algInfo->encrPad = CSSM_PADDING_NONE;
+ algInfo->ivSize = 0;
+ algInfo->algName = "ASC";
+ break;
+ case ALG_RC2:
+ algInfo->keyGenAlg = CSSM_ALGID_RC2;
+ algInfo->wtype = WT_Symmetric;
+ algInfo->encrAlg = CSSM_ALGID_RC2;
+ algInfo->encrMode = CSSM_ALGMODE_CBCPadIV8;
+ algInfo->encrPad = CSSM_PADDING_PKCS5;
+ algInfo->ivSize = 8;
+ algInfo->algName = "RC2";
+ break;
+ case ALG_RC4:
+ algInfo->keyGenAlg = CSSM_ALGID_RC4;
+ algInfo->wtype = WT_Symmetric;
+ algInfo->encrAlg = CSSM_ALGID_RC4;
+ algInfo->encrMode = CSSM_ALGMODE_CBCPadIV8;
+ algInfo->encrPad = CSSM_PADDING_PKCS5;
+ algInfo->ivSize = 0;
+ algInfo->algName = "RC4";
+ break;
+ case ALG_NULL:
+ algInfo->keyGenAlg = CSSM_ALGID_NONE;
+ algInfo->wtype = WT_Null;
+ algInfo->encrAlg = CSSM_ALGID_NONE;
+ algInfo->encrMode = CSSM_ALGMODE_NONE;
+ algInfo->encrPad = CSSM_PADDING_NONE;
+ algInfo->ivSize = 0;
+ algInfo->algName = "Null";
+ break;
+ case ALG_AES:
+ algInfo->keyGenAlg = CSSM_ALGID_AES;
+ algInfo->wtype = WT_Symmetric;
+ algInfo->encrAlg = CSSM_ALGID_AES;
+ algInfo->encrMode = CSSM_ALGMODE_CBCPadIV8;
+ algInfo->encrPad = CSSM_PADDING_PKCS7;
+ algInfo->ivSize = 16;
+ algInfo->algName = "AES";
+ break;
+ default:
+ printf("Bogus privAlg\n");
+ exit(1);
+ }
+ return;
+}
+
+/* argv letter to private alg */
+static PrivAlg letterToAlg(char **argv, char letter)
+{
+ switch(letter) {
+ case 'd': return ALG_DES;
+ case '3': return ALG_3DES;
+ case 'f': return ALG_FEEDEXP;
+ case 'r': return ALG_RSA;
+ case 'A': return ALG_ASC;
+ case '4': return ALG_RC4;
+ case 'a': return ALG_AES;
+ default:
+ usage(argv);
+ return 0;
+ }
+}
+
+/*
+ * Null wrapping of symmetric keys now allowed
+ */
+#define SYMM_NULL_WRAP_ENABLE 1
+
+/* indices into algInfo[] */
+#define AI_WRAP 0
+#define AI_ENCR 1
+
+int main(int argc, char **argv)
+{
+ int arg;
+ char *argp;
+ unsigned loop;
+ CSSM_CSP_HANDLE cspHand;
+ CSSM_RETURN crtn;
+ CSSM_DATA ptext;
+ uint32 encrKeySizeBits; // well aligned
+ uint32 wrapKeySizeBits;
+ uint32 effectiveKeySizeInBits; // for encr, may be odd
+ int rtn = 0;
+ uint32 maxRsaKeySize = 1024;
+ uint32 maxFeeKeySize = 192;
+ CSSM_KEYBLOB_FORMAT wrapFormat; // NONE, PKCS7, PKCS8, APPLE_CUSTOM
+ CSSM_KEYBLOB_FORMAT expectFormat; // PKCS7, PKCS8, APPLE_CUSTOM
+ CSSM_DATA descData = {0, NULL};
+ CSSM_DATA_PTR descDataP;
+
+ /*
+ * key pointers passed to doTest() - for symmetric algs, the pairs
+ * might point to the same key
+ */
+ CSSM_KEY_PTR encrKeyPtr;
+ CSSM_KEY_PTR decrKeyPtr;
+ CSSM_KEY_PTR wrapKeyPtr;
+ CSSM_KEY_PTR unwrapKeyPtr;
+
+ /* persistent asymmetric keys - symm keys are dynamically allocated */
+ CSSM_KEY pubEncrKey;
+ CSSM_KEY privEncrKey;
+ CSSM_KEY pubWrapKey;
+ CSSM_KEY privWrapKey;
+
+ /* we iterate these values thru all possible algs */
+ PrivAlg privEncrAlg; // ALG_xxx
+ PrivAlg privWrapAlg;
+
+ /* two AlgInfo which contain everything we need to know per alg */
+ AlgInfo algInfo[2];
+ AlgInfo *encrInfo;
+ AlgInfo *wrapInfo;
+ CSSM_BOOL wrapEncrKey = CSSM_FALSE; // varies loop-to-loop
+ CSSM_BOOL encrKeyIsRef = CSSM_TRUE; // ditto
+
+ CSSM_BOOL genSeed; // for FEE key gen
+ int i;
+
+ /* user-specified vars */
+ unsigned loops = LOOPS_DEF;
+ CSSM_BOOL pause = CSSM_FALSE;
+ CSSM_BOOL verbose = CSSM_FALSE;
+ PrivAlg minWrapAlg = ALG_MIN;
+ PrivAlg maxWrapAlg = ALG_MAX_WRAP;
+ PrivAlg minEncrAlg = ALG_MIN;
+ PrivAlg maxEncrAlg = ALG_MAX_ENCR;
+ CSSM_BOOL quick = CSSM_FALSE;
+ CSSM_BOOL quiet = CSSM_FALSE;
+ CSSM_BOOL bareCsp = CSSM_TRUE;
+ CSSM_BOOL refKeysOnly = CSSM_FALSE;
+
+ for(arg=1; arg<argc; arg++) {
+ argp = argv[arg];
+ switch(argp[0]) {
+ case 'w':
+ if(argp[2] == 'n') {
+ minWrapAlg = maxWrapAlg = ALG_NULL;
+ }
+ else {
+ minWrapAlg = maxWrapAlg = letterToAlg(argv, argp[2]);
+ }
+ break;
+ case 'e':
+ minEncrAlg = maxEncrAlg = letterToAlg(argv, argp[2]);
+ break;
+ case 'l':
+ loops = atoi(&argp[2]);
+ break;
+ case 'p':
+ pause = CSSM_TRUE;
+ break;
+ case 'v':
+ verbose = CSSM_TRUE;
+ break;
+ case 'D':
+ bareCsp = CSSM_FALSE;
+ #if CSPDL_ALL_KEYS_ARE_REF
+ refKeysOnly = CSSM_TRUE;
+ #endif
+ break;
+ case 'r':
+ refKeysOnly = CSSM_TRUE;
+ break;
+ case 'q':
+ quiet = CSSM_TRUE;
+ break;
+ case 'k':
+ quick = CSSM_TRUE;
+ maxRsaKeySize = 512;
+ maxFeeKeySize = 127;
+ break;
+ default:
+ usage(argv);
+ }
+ }
+ cspHand = cspDlDbStartup(bareCsp, NULL);
+ if(cspHand == 0) {
+ exit(1);
+ }
+ wrapInfo = &algInfo[AI_WRAP];
+ encrInfo = &algInfo[AI_ENCR];
+
+ /* cook up ptext, descData */
+ ptext.Data = (uint8 *)CSSM_MALLOC(MAX_PTEXT_SIZE);
+ descData.Data = (uint8 *)CSSM_MALLOC(MAX_DESC_DATA_SIZE);
+
+ printf("Starting wrapTest; args: ");
+ for(i=1; i<argc; i++) {
+ printf("%s ", argv[i]);
+ }
+ printf("\n");
+
+ for(loop=0; loop<loops; loop++) {
+ if(!quiet) {
+ printf("...loop %d\n", loop);
+ }
+ if(pause) {
+ fpurge(stdin);
+ printf("Hit CR to proceed: ");
+ getchar();
+ }
+
+ /* iterate thru all encryption algs */
+ for(privEncrAlg=minEncrAlg; privEncrAlg<=maxEncrAlg; privEncrAlg++) {
+ /* handle disabled algs */
+ switch(privEncrAlg) {
+ case ALG_NULL: /* just skip this one, it's just for wrap */
+ continue;
+ default:
+ break;
+ }
+
+ /* generate key(s) to be wrapped */
+ getAlgInfo(privEncrAlg, encrInfo);
+ effectiveKeySizeInBits = randKeySizeBits(encrInfo->keyGenAlg, OT_Encrypt);
+ if(!refKeysOnly) {
+ encrKeyIsRef = (loop & 2) ? CSSM_TRUE : CSSM_FALSE;
+ }
+
+ switch(encrInfo->wtype) {
+ case WT_Symmetric:
+ /* round up to even byte */
+ encrKeySizeBits = (effectiveKeySizeInBits + 7) & ~7;
+ if(encrKeySizeBits == effectiveKeySizeInBits) {
+ effectiveKeySizeInBits = 0;
+ }
+ encrKeyPtr = decrKeyPtr = cspGenSymKey(cspHand,
+ encrInfo->keyGenAlg,
+ ENCR_LABEL,
+ ENCR_LABEL_LEN,
+ CSSM_KEYUSE_ENCRYPT | CSSM_KEYUSE_DECRYPT,
+ encrKeySizeBits,
+ encrKeyIsRef);
+ if(encrKeyPtr == NULL) {
+ rtn = 1;
+ goto testDone;
+ }
+ #if SYMM_NULL_WRAP_ENABLE
+ /* wrapEncrKey every other loop */
+ if(!refKeysOnly) {
+ wrapEncrKey = (loop & 1) ? CSSM_TRUE : CSSM_FALSE;
+ }
+ #else
+ wrapEncrKey = CSSM_FALSE;
+ #endif /* SYMM_NULL_WRAP_ENABLE */
+ break;
+ case WT_Asymmetric:
+ /* handle alg-specific cases */
+ genSeed = CSSM_FALSE;
+ switch(privEncrAlg) {
+ case ALG_RSA:
+ if(effectiveKeySizeInBits > maxRsaKeySize) {
+ effectiveKeySizeInBits = maxRsaKeySize;
+ }
+ break;
+ case ALG_FEEDEXP:
+ if(effectiveKeySizeInBits > maxFeeKeySize) {
+ effectiveKeySizeInBits = maxFeeKeySize;
+ }
+ if(loop & 4) {
+ genSeed = CSSM_TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+ encrKeySizeBits = effectiveKeySizeInBits;
+ effectiveKeySizeInBits = 0; // i.e., not specified
+ crtn = cspGenKeyPair(cspHand,
+ encrInfo->keyGenAlg,
+ ENCR_LABEL,
+ ENCR_LABEL_LEN,
+ encrKeySizeBits,
+ &pubEncrKey,
+ encrKeyIsRef, // pubIsRef
+ CSSM_KEYUSE_ENCRYPT,
+ CSSM_KEYBLOB_RAW_FORMAT_NONE,
+ &privEncrKey,
+ CSSM_TRUE, // privIsRef
+ CSSM_KEYUSE_DECRYPT,
+ CSSM_KEYBLOB_RAW_FORMAT_NONE,
+ genSeed);
+ if(crtn) {
+ rtn = testError(quiet);
+ goto testDone;
+ }
+ encrKeyPtr = &pubEncrKey;
+ decrKeyPtr = &privEncrKey;
+ /* wrapEncrKey every other loop */
+ if(!refKeysOnly) {
+ wrapEncrKey = (loop & 1) ? CSSM_TRUE : CSSM_FALSE;
+ }
+ break;
+ case WT_Null:
+ printf("***BRRZAP: can't do null encrypt\n");
+ goto testDone;
+ }
+ if(verbose) {
+ printf(" ...encrAlg %s wrapEncrKey %d encrKeyIsRef %d size %u "
+ "bits effectSize %u\n",
+ encrInfo->algName, (int)wrapEncrKey, (int)encrKeyIsRef,
+ (unsigned)encrKeySizeBits, (unsigned)effectiveKeySizeInBits);
+ }
+ /* iterate thru all wrap algs */
+ for(privWrapAlg=minWrapAlg; privWrapAlg<=maxWrapAlg; privWrapAlg++) {
+ /* handle disabled algs */
+ if((privWrapAlg == ALG_AES) && (privEncrAlg == ALG_FEEDEXP)) {
+ /*
+ * Can't do it. FEED can't do PKCS8 because it doesn't
+ * support PKCS8 private key format, and AES can't
+ * do APPLE_CUSTOM because AES needs a 16-byte IV.
+ */
+ continue;
+ }
+ /* any other restrictions/ */
+
+ /* generate wrapping key(s) */
+ getAlgInfo(privWrapAlg, wrapInfo);
+ switch(wrapInfo->wtype) {
+ case WT_Symmetric:
+ /* note we can't do odd-size wrapping keys */
+ wrapKeySizeBits = randKeySizeBits(wrapInfo->keyGenAlg,
+ OT_KeyExch);
+ wrapKeySizeBits &= ~7;
+ wrapKeyPtr = unwrapKeyPtr = cspGenSymKey(cspHand,
+ wrapInfo->keyGenAlg,
+ WRAP_LABEL,
+ WRAP_LABEL_LEN,
+ WRAP_USAGE_ANY ? CSSM_KEYUSE_ANY :
+ CSSM_KEYUSE_WRAP | CSSM_KEYUSE_UNWRAP,
+ wrapKeySizeBits,
+ CSSM_TRUE);
+ if(wrapKeyPtr == NULL) {
+ rtn = 1;
+ goto testDone;
+ }
+ break;
+ case WT_Asymmetric:
+ wrapKeySizeBits = randKeySizeBits(wrapInfo->keyGenAlg,
+ OT_KeyExch);
+ genSeed = CSSM_FALSE;
+ switch(privWrapAlg) {
+ case ALG_RSA:
+ if(wrapKeySizeBits > maxRsaKeySize) {
+ wrapKeySizeBits = maxRsaKeySize;
+ }
+ break;
+ case ALG_FEEDEXP:
+ if(wrapKeySizeBits > maxFeeKeySize) {
+ wrapKeySizeBits = maxFeeKeySize;
+ }
+ if(loop & 2) {
+ genSeed = CSSM_TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+ crtn = cspGenKeyPair(cspHand,
+ wrapInfo->keyGenAlg,
+ WRAP_LABEL,
+ WRAP_LABEL_LEN,
+ wrapKeySizeBits,
+ &pubWrapKey,
+ CSSM_TRUE, // pubIsRef
+ WRAP_USAGE_ANY ? CSSM_KEYUSE_ANY : CSSM_KEYUSE_WRAP,
+ CSSM_KEYBLOB_RAW_FORMAT_NONE,
+ &privWrapKey,
+ CSSM_TRUE, // privIsRef
+ WRAP_USAGE_ANY ? CSSM_KEYUSE_ANY : CSSM_KEYUSE_UNWRAP,
+ CSSM_KEYBLOB_RAW_FORMAT_NONE,
+ genSeed);
+ if(crtn) {
+ rtn = testError(quiet);
+ goto testDone;
+ }
+ wrapKeyPtr = &pubWrapKey;
+ unwrapKeyPtr = &privWrapKey;
+ break;
+ case WT_Null:
+ #if !SYMM_NULL_WRAP_ENABLE
+ if(encrInfo->wtype == WT_Symmetric) {
+ /* can't do null wrap of symmetric key */
+ continue;
+ }
+ #endif
+ wrapKeySizeBits = 0;
+ wrapKeyPtr = NULL;
+ unwrapKeyPtr = NULL;
+ break;
+ }
+
+ /* special case for 3DES/3DES */
+ #if 0
+ if((wrapKeyPtr != NULL) &&
+ (wrapKeyPtr->KeyHeader.AlgorithmId == CSSM_ALGID_3DES_3KEY) &&
+ (decrKeyPtr->KeyHeader.AlgorithmId == CSSM_ALGID_3DES_3KEY)) {
+ isAppleCustom = CSSM_TRUE;
+ }
+ else {
+ isAppleCustom = CSSM_FALSE;
+ }
+ #endif
+
+ /* cook up a wrapFormat - every other loop use default, others
+ * specify a reasonable one */
+ if(wrapInfo->wtype == WT_Null) {
+ wrapFormat = expectFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_NONE;
+ }
+ else if((loop & 1)) {
+ /*
+ * FORMAT_NONE - default - figure out expected format;
+ * this has to track CSP behavior
+ */
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_NONE;
+ switch(encrInfo->wtype) {
+ case WT_Symmetric:
+ expectFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7;
+ break;
+ case WT_Asymmetric:
+ if(privEncrAlg == ALG_FEEDEXP) {
+ expectFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM;
+ }
+ else {
+ expectFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS8;
+ }
+ break;
+ default:
+ /* NULL encr not done */
+ printf("**GAK! Internal error\n");
+ }
+ }
+ else {
+ /* pick a good explicit one - this encapsulates the
+ * range of legal wrap formats per wrap/encrypt alg */
+ int die = loop & 2;
+ switch(encrInfo->wtype) {
+ case WT_Symmetric:
+ if(privWrapAlg == ALG_AES) {
+ /* can't do APPLE_CUSTOM - 16 byte IV */
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7;
+ }
+ else if(die) {
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7;
+ }
+ else {
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM;
+ }
+ break;
+ case WT_Asymmetric:
+ /* Can't wrap FEE key with AES no way, no how -
+ * this is detected at the top of the privWrapAlg
+ * loop
+ */
+ if(privEncrAlg == ALG_FEEDEXP) {
+ /* FEE doesn't do PKCS8 private key format */
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM;
+ }
+ else if(die) {
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS8;
+ }
+ else if(privWrapAlg == ALG_AES) {
+ /* AES can't do APPLE_CUSTOM - 16 byte IV */
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS8;
+ }
+ else {
+ wrapFormat = CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM;
+ }
+ break;
+ default:
+ /* NULL encr not done */
+ printf("***GAK! Internal error\n");
+ exit(1);
+ }
+ expectFormat = wrapFormat;
+ }
+
+ /*
+ * If wrapping with apple custom - either by default or
+ * explicitly - generate some descriptive data.
+ */
+ if(expectFormat == CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM) {
+ simpleGenData(&descData, 1, MAX_DESC_DATA_SIZE);
+ descDataP = &descData;
+ }
+ else {
+ descDataP = NULL;
+ }
+
+ if(verbose) {
+ printf(" ...wrapAlg = %s size %u bits format %s expect %s\n",
+ wrapInfo->algName, (unsigned)wrapKeySizeBits, formatString(wrapFormat),
+ formatString(expectFormat));
+ }
+ /* OK, here we go! */
+ if(doTest(cspHand,
+ encrKeyPtr,
+ wrapEncrKey,
+ decrKeyPtr,
+ wrapKeyPtr,
+ unwrapKeyPtr,
+ wrapInfo->encrAlg,
+ wrapInfo->encrMode,
+ wrapFormat,
+ expectFormat,
+ wrapInfo->encrPad,
+ wrapInfo->ivSize,
+ encrInfo->encrAlg,
+ encrInfo->encrMode,
+ encrInfo->encrPad,
+ encrInfo->ivSize,
+ effectiveKeySizeInBits,
+ &ptext,
+ descDataP,
+ quiet,
+ bareCsp)) {
+ rtn = 1;
+ goto testDone;
+ }
+ /* end of wrap alg loop - free/delete wrap key(s) */
+ switch(wrapInfo->wtype) {
+ case WT_Symmetric:
+ cspFreeKey(cspHand, wrapKeyPtr);
+ /* mallocd by cspGenSymKey */
+ CSSM_FREE(wrapKeyPtr);
+ break;
+ case WT_Asymmetric:
+ cspFreeKey(cspHand, wrapKeyPtr);
+ cspFreeKey(cspHand, unwrapKeyPtr);
+ break;
+ default:
+ break;
+ }
+ } /* for wrapAlg */
+ /* end of encr alg loop - free encr key(s) */
+ cspFreeKey(cspHand, encrKeyPtr);
+ if(encrInfo->wtype == WT_Symmetric) {
+ /* mallocd by cspGenSymKey */
+ CSSM_FREE(decrKeyPtr);
+ }
+ else {
+ cspFreeKey(cspHand, decrKeyPtr);
+ }
+ }
+ }
+testDone:
+ cspShutdown(cspHand, bareCsp);
+ if(pause) {
+ fpurge(stdin);
+ printf("ModuleDetach/Unload complete; hit CR to exit: ");
+ getchar();
+ }
+ if((rtn == 0) && !quiet) {
+ printf("%s test complete\n", argv[0]);
+ }
+ return rtn;
+}
projects / apple / security.git / blobdiff