--- /dev/null
+/*
+ * badattr.c - verify proper rejection of bad key attribute bits
+ */
+
+#ifdef pcode
+
+partial description...
+
+for each asymmetric alg {
+ gen pub key with KEYUSE_ENCRYPT
+ make sure you cannot use it for vfy or decrypt
+ make sure you cannot use it for encrypting with other alg
+ gen priv key with KEYUSE_DECRYPT
+ make sure you cannot use it for sign or decrypt
+ make sure you cannot use it for decrypting with other alg
+ gen priv key with KEYUSE_SIGN
+ make sure you cannot use it for encrypt or decrypt
+ gen pub with KEYUSE_VERIFY
+ make sure you cannot use it for encrypt or decrypt
+
+}
+
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <Security/cssm.h>
+#include <Security/cssmapple.h>
+#include "cspwrap.h"
+#include "common.h"
+#include "cspdlTesting.h"
+/*
+ * Enumerate algs our own way to allow iteration.
+ */
+typedef unsigned privAlg;
+enum {
+ ALG_ASC = 1,
+ ALG_DES,
+ ALG_RC2,
+ ALG_RC4,
+ ALG_RC5,
+ ALG_3DES,
+ ALG_AES,
+ ALG_RSA,
+ ALG_FEE,
+ ALG_ECDSA,
+ ALG_DSA
+};
+
+#define SYM_FIRST ALG_ASC
+#define SYM_LAST ALG_AES
+#define ASYM_FIRST ALG_RSA
+#define ASYM_LAST ALG_ECDSA /* DSA if we're patient */
+
+/*
+ * ops expressed at bitfields
+ */
+#define OP_SIGN 0x0001
+#define OP_VERIFY 0x0002
+#define OP_ENCRYPT 0x0004
+#define OP_DECRYPT 0x0008
+#define OP_GENMAC 0x0010
+#define OP_VFYMAC 0x0020
+
+static void usage(char **argv)
+{
+ printf("usage: %s [options]\n", argv[0]);
+ printf(" Options:\n");
+ printf(" s(ymmetric only)\n");
+ printf(" a(symmetric only)\n");
+ printf(" q(uiet)\n");
+ printf(" h(elp)\n");
+ exit(1);
+}
+
+/*
+ * Common, flexible, error-tolerant symmetric key generator.
+ */
+static int genSymKey(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR symKey,
+ uint32 alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_KEYATTR_FLAGS keyAttr,
+ CSSM_KEYUSE keyUsage,
+ CSSM_RETURN expectRtn,
+ CSSM_BOOL quiet,
+ CSSM_BOOL freeKey, // true: free the key on exit
+ const char *testStr)
+{
+ CSSM_RETURN crtn;
+ CSSM_CC_HANDLE ccHand;
+ CSSM_DATA dummyLabel = {4, (uint8 *)"foo"};
+ int irtn;
+
+ memset(symKey, 0, sizeof(CSSM_KEY));
+ crtn = CSSM_CSP_CreateKeyGenContext(cspHand,
+ alg,
+ keySizeInBits, // keySizeInBits
+ NULL, // Seed
+ NULL, // Salt
+ NULL, // StartDate
+ NULL, // EndDate
+ NULL, // Params
+ &ccHand);
+ if(crtn) {
+ printError("CSSM_CSP_CreateKeyGenContext", crtn);
+ return testError(quiet);
+ }
+ crtn = CSSM_GenerateKey(ccHand,
+ keyUsage,
+ keyAttr,
+ &dummyLabel,
+ NULL, // ACL
+ symKey);
+ if(crtn != expectRtn) {
+ printf("***Testing %s for alg %s:\n", testStr, keyAlgStr);
+ printf(" CSSM_GenerateKey: expect %s\n", cssmErrToStr(expectRtn));
+ printf(" CSSM_GenerateKey: got %s\n", cssmErrToStr(crtn));
+ irtn = testError(quiet);
+ }
+ else {
+ irtn = 0;
+ }
+ CSSM_DeleteContext(ccHand);
+ if(freeKey && (crtn == CSSM_OK)) {
+ cspFreeKey(cspHand, symKey);
+ }
+ return irtn;
+}
+
+/*
+ * Common, flexible, error-tolerant key pair generator.
+ */
+static int genKeyPair(
+ CSSM_CSP_HANDLE cspHand,
+ uint32 algorithm,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_KEY_PTR pubKey,
+ CSSM_KEYATTR_FLAGS pubKeyAttr,
+ CSSM_KEYUSE pubKeyUsage,
+ CSSM_KEY_PTR privKey,
+ CSSM_KEYATTR_FLAGS privKeyAttr,
+ CSSM_KEYUSE privKeyUsage,
+ CSSM_RETURN expectRtn,
+ CSSM_BOOL quiet,
+ CSSM_BOOL freeKeys, // true: free the keys on exit
+ const char *testStr)
+{
+ CSSM_RETURN crtn;
+ CSSM_CC_HANDLE ccHand;
+ CSSM_DATA keyLabelData = {4, (uint8 *)"foo"};
+ int irtn;
+
+ memset(pubKey, 0, sizeof(CSSM_KEY));
+ memset(privKey, 0, sizeof(CSSM_KEY));
+
+ crtn = CSSM_CSP_CreateKeyGenContext(cspHand,
+ algorithm,
+ keySizeInBits,
+ NULL, // Seed
+ NULL, // Salt
+ NULL, // StartDate
+ NULL, // EndDate
+ NULL, // Params
+ &ccHand);
+ if(crtn) {
+ printError("CSSM_CSP_CreateKeyGenContext", crtn);
+ return testError(quiet);
+ }
+
+ /* post-context-create algorithm-specific stuff */
+ switch(algorithm) {
+ case CSSM_ALGID_RSA:
+ break;
+
+ case CSSM_ALGID_DSA:
+ /*
+ * extra step - generate params - this just adds some
+ * info to the context
+ */
+ {
+ CSSM_DATA dummy = {0, NULL};
+ crtn = CSSM_GenerateAlgorithmParams(ccHand,
+ keySizeInBits, &dummy);
+ if(crtn) {
+ printError("CSSM_GenerateAlgorithmParams", crtn);
+ return testError(quiet);
+ }
+ appFreeCssmData(&dummy, CSSM_FALSE);
+ }
+ break;
+ default:
+ break;
+ }
+
+ crtn = CSSM_GenerateKeyPair(ccHand,
+ pubKeyUsage,
+ pubKeyAttr,
+ &keyLabelData,
+ pubKey,
+ privKeyUsage,
+ privKeyAttr,
+ &keyLabelData, // same labels
+ NULL, // CredAndAclEntry
+ privKey);
+ if(crtn != expectRtn) {
+ printf("***Testing %s for alg %s:\n", testStr, keyAlgStr);
+ printf(" CSSM_GenerateKeyPair: expect %s\n", cssmErrToStr(expectRtn));
+ printf(" CSSM_GenerateKeyPair: got %s\n", cssmErrToStr(crtn));
+ irtn = testError(quiet);
+ }
+ else {
+ irtn = 0;
+ }
+ CSSM_DeleteContext(ccHand);
+ if(freeKeys && (crtn == CSSM_OK)) {
+ cspFreeKey(cspHand, pubKey);
+ cspFreeKey(cspHand, privKey);
+ }
+ return irtn;
+}
+
+/*
+ * Perform NULL wrap, generally expecting an error (either
+ * CSSMERR_CSP_INVALID_KEYATTR_MASK, if the raw key bits should be inaccessible,
+ * or CSSMERR_CSP_INVALID_KEY_REFERENCE, if the key's header has been munged.)
+ */
+int nullWrapTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR key,
+ CSSM_BOOL quiet,
+ CSSM_RETURN expectRtn,
+ const char *keyAlgStr,
+ const char *testStr)
+{
+ CSSM_CC_HANDLE ccHand;
+ CSSM_RETURN crtn;
+ CSSM_ACCESS_CREDENTIALS creds;
+ CSSM_KEY wrappedKey; // should not get created
+ int irtn;
+
+ memset(&wrappedKey, 0, sizeof(CSSM_KEY));
+ memset(&creds, 0, sizeof(CSSM_ACCESS_CREDENTIALS));
+ crtn = CSSM_CSP_CreateSymmetricContext(cspHand,
+ CSSM_ALGID_NONE,
+ CSSM_ALGMODE_NONE,
+ &creds, // passPhrase,
+ NULL, // wrappingKey,
+ NULL, // IV
+ CSSM_PADDING_NONE,
+ 0, // Params
+ &ccHand);
+ if(crtn) {
+ printError("cspWrapKey/CreateContext", crtn);
+ return testError(quiet);
+ }
+ crtn = CSSM_WrapKey(ccHand,
+ &creds,
+ key,
+ NULL, // DescriptiveData
+ &wrappedKey);
+ if(crtn != expectRtn) {
+ printf("***Testing %s for alg %s:\n", testStr, keyAlgStr);
+ printf(" CSSM_WrapKey: expect %s\n", cssmErrToStr(expectRtn));
+ printf(" CSSM_WrapKey: got %s\n", cssmErrToStr(crtn));
+ irtn = testError(quiet);
+ }
+ else {
+ irtn = 0;
+ }
+ CSSM_DeleteContext(ccHand);
+ return irtn;
+}
+
+/*
+ * Attempt to wrap incoming key with a DES key that we generate. Expect
+ * CSSMERR_CSP_INVALID_KEYATTR_MASK since the unwrapped key is marked
+ * !EXTRACTABLE.
+ */
+#define WRAPPING_KEY_ALG CSSM_ALGID_DES
+#define WRAPPING_KEY_SIZE CSP_DES_KEY_SIZE_DEFAULT
+
+static int badWrapTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR unwrappedKey,
+ CSSM_KEYBLOB_FORMAT wrapForm,
+ CSSM_BOOL quiet,
+ const char *keyAlgStr,
+ const char *testStr)
+{
+ CSSM_CC_HANDLE ccHand;
+ CSSM_RETURN crtn;
+ CSSM_ACCESS_CREDENTIALS creds;
+ CSSM_KEY wrappedKey; // should not get created
+ CSSM_KEY wrappingKey;
+ int irtn;
+
+ /* first generate a DES wrapping key */
+ if(genSymKey(cspHand, &wrappingKey, CSSM_ALGID_DES, "DES",
+ CSP_DES_KEY_SIZE_DEFAULT,
+ CSSM_KEYATTR_RETURN_REF,
+ CSSM_KEYUSE_ANY, CSSM_OK, quiet,
+ CSSM_FALSE, "not a test case")) {
+ return 1;
+ }
+
+ memset(&wrappedKey, 0, sizeof(CSSM_KEY));
+ memset(&creds, 0, sizeof(CSSM_ACCESS_CREDENTIALS));
+
+ /* symmetric wrapping context */
+ crtn = CSSM_CSP_CreateSymmetricContext(cspHand,
+ CSSM_ALGID_DES,
+ CSSM_ALGMODE_CBCPadIV8,
+ &creds, // passPhrase,
+ &wrappingKey,
+ NULL, // IV
+ CSSM_PADDING_PKCS5,
+ 0, // Params
+ &ccHand);
+ if(crtn) {
+ printError("cspWrapKey/CreateContext", crtn);
+ return testError(quiet);
+ }
+
+ /* do it, demand error */
+ crtn = CSSM_WrapKey(ccHand,
+ &creds,
+ unwrappedKey,
+ NULL, // DescriptiveData
+ &wrappedKey);
+ if(crtn != CSSMERR_CSP_INVALID_KEYATTR_MASK) {
+ printf("***Testing %s for alg %s:\n", testStr, keyAlgStr);
+ printf(" CSSM_WrapKey: expect CSSMERR_CSP_INVALID_KEYATTR_MASK, got %s\n",
+ cssmErrToStr(crtn));
+ irtn = testError(quiet);
+ }
+ else {
+ irtn = 0;
+ }
+ CSSM_DeleteContext(ccHand);
+ cspFreeKey(cspHand, &wrappingKey);
+ return irtn;
+}
+
+
+/*
+ * Note for these op stubs, the data, mode, padding, etc. are unimportant as
+ * the ops are expected to fail during key extraction.
+ */
+static int badEncrypt(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR key,
+ const char *keyAlgStr,
+ CSSM_ALGORITHMS opAlg,
+ CSSM_RETURN expectRtn,
+ CSSM_BOOL quiet,
+ const char *goodUseStr,
+ const char *badUseStr)
+{
+ CSSM_CC_HANDLE cryptHand;
+ CSSM_DATA ptext = {4, (uint8 *)"foo"};
+ CSSM_DATA ctext = {0, NULL};
+ CSSM_DATA remData = {0, NULL};
+ CSSM_RETURN crtn;
+ CSSM_SIZE bytesEncrypted;
+ int irtn;
+
+ cryptHand = genCryptHandle(cspHand, opAlg, CSSM_ALGMODE_NONE, CSSM_PADDING_NONE,
+ key, NULL /* key2 */, NULL /* iv */, 0, 0);
+ if(cryptHand == 0) {
+ return testError(quiet);
+ }
+ crtn = CSSM_EncryptData(cryptHand, &ptext, 1, &ctext, 1, &bytesEncrypted, &remData);
+ if(crtn != expectRtn) {
+ printf("***Testing %s key w/%s during %s:\n", keyAlgStr, goodUseStr, badUseStr);
+ printf(" CSSM_EncryptData: expect %s\n", cssmErrToStr(expectRtn));
+ printf(" CSSM_EncryptData: got %s\n", cssmErrToStr(crtn));
+ irtn = testError(quiet);
+ }
+ else {
+ irtn = 0;
+ }
+ /* assume no ctext or remdata - OK? */
+ CSSM_DeleteContext(cryptHand);
+ return irtn;
+}
+
+static int badDecrypt(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR key,
+ const char *keyAlgStr,
+ CSSM_ALGORITHMS opAlg,
+ CSSM_RETURN expectRtn,
+ CSSM_BOOL quiet,
+ const char *goodUseStr,
+ const char *badUseStr)
+{
+ CSSM_CC_HANDLE cryptHand;
+ CSSM_DATA ctext = {4, (uint8 *)"foo"};
+ CSSM_DATA ptext = {0, NULL};
+ CSSM_DATA remData = {0, NULL};
+ CSSM_RETURN crtn;
+ CSSM_SIZE bytesDecrypted;
+ int irtn;
+
+
+ cryptHand = genCryptHandle(cspHand, opAlg, CSSM_ALGMODE_NONE, CSSM_PADDING_NONE,
+ key, NULL /* key2 */, NULL /* iv */, 0, 0);
+ if(cryptHand == 0) {
+ return testError(quiet);
+ }
+ crtn = CSSM_DecryptData(cryptHand, &ctext, 1, &ptext, 1, &bytesDecrypted, &remData);
+ if(crtn != expectRtn) {
+ printf("***Testing %s key w/%s during %s:\n", keyAlgStr, goodUseStr, badUseStr);
+ printf(" CSSM_DecryptData: expect %s\n", cssmErrToStr(expectRtn));
+ printf(" CSSM_DecryptData: got %s\n", cssmErrToStr(crtn));
+ irtn = testError(quiet);
+ }
+ else {
+ irtn = 0;
+ }
+ /* assume no ptext or remdata - OK? */
+ CSSM_DeleteContext(cryptHand);
+ return irtn;
+}
+
+/*
+ * Given a reference key (any class, any alg), attempt to perform null wrap after
+ * munging various fields in the header. Every attempt should result in
+ * CSSMERR_CSP_INVALID_KEY_REFERENCE.
+ */
+static int badHdrTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_KEY_PTR key,
+ CSSM_BOOL quiet,
+ const char *keyAlgStr)
+{
+ CSSM_KEYHEADER *hdr = &key->KeyHeader;
+ CSSM_KEYHEADER savedHdr = *hdr;
+
+ hdr->HeaderVersion++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(HeaderVersion)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->CspId.Data1++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(CspId.Data1)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ /* can't test BlobType for Format, they're known to differ */
+
+ hdr->AlgorithmId++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(AlgorithmId)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ /* have to come up with valid KeyClass here */
+ switch(hdr->KeyClass) {
+ case CSSM_KEYCLASS_PUBLIC_KEY:
+ hdr->KeyClass = CSSM_KEYCLASS_PRIVATE_KEY; break;
+ case CSSM_KEYCLASS_PRIVATE_KEY:
+ hdr->KeyClass = CSSM_KEYCLASS_SESSION_KEY; break;
+ case CSSM_KEYCLASS_SESSION_KEY:
+ hdr->KeyClass = CSSM_KEYCLASS_PUBLIC_KEY; break;
+ default:
+ printf("***BRZZAP! badHdrTest needs work\n");
+ exit(1);
+ }
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(KeyClass)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->LogicalKeySizeInBits++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(LogicalKeySizeInBits)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->KeyAttr++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(KeyAttr)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->StartDate.Day[0]++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(StartDate.Day)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->EndDate.Year[1]++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(EndDate.Year)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->WrapAlgorithmId++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(WrapAlgorithmId)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ hdr->WrapMode++;
+ if(nullWrapTest(cspHand, key, quiet, CSSMERR_CSP_INVALID_KEY_REFERENCE,
+ keyAlgStr, "Munged hdr(WrapMode)")) {
+ return 1;
+ }
+ *hdr = savedHdr;
+
+ return 0;
+}
+
+/*
+ * Given some op alg, return a different op alg which is of the same class
+ * but should not work with an opAlg-related key.
+ */
+CSSM_ALGORITHMS badOpAlg(
+ CSSM_ALGORITHMS opAlg)
+{
+ switch(opAlg) {
+ /* symmetric block ciphers */
+ case CSSM_ALGID_DES: return CSSM_ALGID_3DES_3KEY_EDE;
+ case CSSM_ALGID_3DES_3KEY_EDE: return CSSM_ALGID_RC2;
+ case CSSM_ALGID_RC2: return CSSM_ALGID_RC5;
+ case CSSM_ALGID_RC5: return CSSM_ALGID_AES;
+ case CSSM_ALGID_AES: return CSSM_ALGID_DES;
+
+ /* symmetric stream ciphers */
+ case CSSM_ALGID_ASC: return CSSM_ALGID_RC4;
+ case CSSM_ALGID_RC4: return CSSM_ALGID_ASC;
+
+ /* asymmetric ciphers */
+ case CSSM_ALGID_RSA: return CSSM_ALGID_FEEDEXP;
+ case CSSM_ALGID_FEEDEXP: return CSSM_ALGID_RSA;
+
+ /* digital signature */
+ case CSSM_ALGID_SHA1WithRSA: return CSSM_ALGID_SHA1WithDSA;
+ case CSSM_ALGID_SHA1WithDSA: return CSSM_ALGID_SHA1WithECDSA;
+ case CSSM_ALGID_SHA1WithECDSA: return CSSM_ALGID_SHA1WithRSA;
+
+ default: printf("***BRRZAP! badOpAlg needs work.\n"); exit(1);
+ }
+ /* NOT REACHED */
+ return 0;
+}
+
+/*
+ * -- Generate symmetric key with specified alg and usage;
+ * -- Verify that it can't be used for any of the ops specified
+ * in badOpFlags using goodEncrAlg/goodSignAlg;
+ * -- Verify that it can't be used for goodOp/badAlg;
+ *
+ * Used by symUsageTest().
+ *
+ */
+#define SYM_USAGE_ENABLE 1
+
+static int badSymUsage(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS keyAlg, // alg of the key
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_KEYUSE keyUse, // gen key with this usage
+ CSSM_ALGORITHMS goodEncrAlg, // key is good for this encryption alg
+ CSSM_ALGORITHMS goodSignAlg, // key is good for this sign alg (may not be used)
+ unsigned badOpFlags, // array of (OP_DECRYPT,...)
+ unsigned goodOp, // one good op...
+ CSSM_ALGORITHMS badAlg, // ..which fails for this alg
+ CSSM_BOOL quiet,
+ const char *useStr)
+{
+ CSSM_KEY symKey;
+ int irtn;
+
+ if(genSymKey(cspHand, &symKey, keyAlg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF, keyUse, CSSM_OK, quiet, CSSM_FALSE, useStr)) {
+ return 1;
+ }
+ #if SYM_USAGE_ENABLE
+ if(!quiet) {
+ printf(" ...testing key usage\n");
+ }
+ if(badOpFlags & OP_ENCRYPT) {
+ irtn = badEncrypt(cspHand, &symKey, keyAlgStr, goodEncrAlg,
+ CSSMERR_CSP_KEY_USAGE_INCORRECT, quiet, useStr, "ENCRYPT");
+ if(irtn) {
+ goto abort;
+ }
+ }
+ if(badOpFlags & OP_DECRYPT) {
+ irtn = badDecrypt(cspHand, &symKey, keyAlgStr, goodEncrAlg,
+ CSSMERR_CSP_KEY_USAGE_INCORRECT, quiet, useStr, "DECRYPT");
+ if(irtn) {
+ goto abort;
+ }
+ }
+ #endif /* SYM_USAGE_ENABLE */
+
+ /* now do a good op with an incorrect algorithm */
+ if(!quiet) {
+ printf(" ...testing key/algorithm match\n");
+ }
+ if(goodOp & OP_ENCRYPT) {
+ irtn = badEncrypt(cspHand, &symKey, keyAlgStr, badAlg,
+ CSSMERR_CSP_ALGID_MISMATCH, quiet, useStr, "ENCRYPT w/bad alg");
+ if(irtn) {
+ goto abort;
+ }
+ }
+ if(goodOp & OP_DECRYPT) {
+ irtn = badDecrypt(cspHand, &symKey, keyAlgStr, badAlg,
+ CSSMERR_CSP_ALGID_MISMATCH, quiet, useStr, "DECRYPT w/bad alg");
+ if(irtn) {
+ goto abort;
+ }
+ }
+abort:
+ cspFreeKey(cspHand, &symKey);
+ return irtn;
+}
+
+/*
+ * Verify symmetric key usage behavior:
+ *
+ * gen key with KEYUSE_ENCRYPT
+ * make sure you can't use it for decrypt
+ * make sure you can't use it for encrypting with other alg
+ * gen key with KEYUSE_DECRYPT
+ * make sure you can't use it for encrypt
+ * make sure you can't use it for decrypting with other alg
+ * gen key with KEYUSE_SIGN (mac)
+ * make sure you can't use it for encrypt or decrypt
+ * gen key with KEYUSE_VERIFY (mac verify)
+ * make sure you can't use it for encrypt or decrypt
+ */
+int symUsageTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS keyAlg,
+ const char *keyAlgStr,
+ CSSM_ALGORITHMS encrAlg,
+ CSSM_ALGORITHMS signAlg,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ if(!quiet) {
+ printf(" ...testing encrypt-enabled key\n");
+ }
+ if(badSymUsage(cspHand, keyAlg, keyAlgStr, keySizeInBits, CSSM_KEYUSE_ENCRYPT,
+ encrAlg, signAlg, OP_DECRYPT, OP_ENCRYPT, badOpAlg(encrAlg),
+ quiet, "ENCRYPT")) {
+ return 1;
+ }
+ if(!quiet) {
+ printf(" ...testing decrypt-enabled key\n");
+ }
+ if(badSymUsage(cspHand, keyAlg, keyAlgStr, keySizeInBits, CSSM_KEYUSE_DECRYPT,
+ encrAlg, signAlg, OP_ENCRYPT, OP_DECRYPT, badOpAlg(encrAlg),
+ quiet, "DECRYPT")) {
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Verify symmetric key attribute behavior:
+ *
+ * check that you can not gen a key with {
+ * CSSM_KEYATTR_ALWAYS_SENSITIVE
+ * CSSM_KEYATTR_NEVER_EXTRACTABLE
+ * CSSM_KEYATTR_PERMANENT
+ * CSSM_KEYATTR_PRIVATE
+ * CSSM_KEYATTR_RETURN_DATA | !CSSM_KEYATTR_EXTRACTABLE
+ * CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_SENSITIVE
+ * CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_RETURN_REF
+ * }
+ */
+int symAttrTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_BOOL bareCsp,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY key;
+
+ if(!quiet) {
+ printf(" ...testing key attr\n");
+ }
+ if(bareCsp || CSPDL_ALWAYS_SENSITIVE_CHECK) {
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_ALWAYS_SENSITIVE,
+ CSSM_KEYUSE_ANY, CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ CSSM_TRUE, "ALWAYS_SENSITIVE")) {
+ return 1;
+ }
+ }
+ if(bareCsp || CSPDL_NEVER_EXTRACTABLE_CHECK) {
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_NEVER_EXTRACTABLE,
+ CSSM_KEYUSE_ANY, CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ CSSM_TRUE, "NEVER_EXTRACTABLE")) {
+ return 1;
+ }
+ }
+ /*
+ * bare CSP : CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK
+ * CSPDL : CSSMERR_CSP_MISSING_ATTR_DL_DB_HANDLE
+ */
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_PERMANENT,
+ CSSM_KEYUSE_ANY,
+ bareCsp ? CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK :
+ CSSMERR_CSP_MISSING_ATTR_DL_DB_HANDLE,
+ quiet,
+ CSSM_TRUE, "PERMANENT")) {
+ return 1;
+ }
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_PRIVATE,
+ CSSM_KEYUSE_ANY, CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK, quiet,
+ CSSM_TRUE, "PRIVATE")) {
+ return 1;
+ }
+ if(bareCsp) {
+ /* CSPDL doesn't support RETURN_DATA */
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA /* and !extractable */,
+ CSSM_KEYUSE_ANY,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ CSSM_TRUE, "RETURN_DATA | !EXTRACTABLE")) {
+ return 1;
+ }
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_SENSITIVE,
+ CSSM_KEYUSE_ANY, CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ CSSM_TRUE, "RETURN_DATA | SENSITIVE")) {
+ return 1;
+ }
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_RETURN_REF,
+ CSSM_KEYUSE_ANY, CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ CSSM_TRUE, "RETURN_DATA | RETURN_REF")) {
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/*
+ * Verify proper symmetric key null wrap operation.
+ *
+ * gen ref key, CSSM_KEYATTR_SENSITIVE, vfy you can't do null wrap;
+ * gen ref key, !CSSM_KEYATTR_EXTRACTABLE, vfy you can't do null wrap;
+ */
+int symNullWrapTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY key;
+
+ if(!quiet) {
+ printf(" ...testing access to inaccessible key bits via NULL wrap\n");
+ }
+
+ /* gen ref key, CSSM_KEYATTR_SENSITIVE, vfy you can't do null wrap */
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE,
+ CSSM_KEYUSE_ANY, CSSM_OK, quiet,
+ CSSM_FALSE, "SENSITIVE | RETURN_REF")) {
+ return 1;
+ }
+ if(nullWrapTest(cspHand, &key, quiet, CSSMERR_CSP_INVALID_KEYATTR_MASK,
+ keyAlgStr, "KEYATTR_SENSITIVE")) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &key);
+
+ /* gen ref key, !CSSM_KEYATTR_EXTRACTABLE, vfy you can't do null wrap */
+ if(genSymKey(cspHand, &key, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF /* !CSSM_KEYATTR_EXTRACTABLE */,
+ CSSM_KEYUSE_ANY, CSSM_OK, quiet,
+ CSSM_FALSE, "!EXTRACTABLE | RETURN_REF")) {
+ return 1;
+ }
+ if(nullWrapTest(cspHand, &key, quiet, CSSMERR_CSP_INVALID_KEYATTR_MASK,
+ keyAlgStr, "!EXTRACTABLE")) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &key);
+
+ return 0;
+}
+
+/*
+ * Verify proper symmetric key wrap !EXTRACTABLE handling.
+ *
+ * Gen unwrapped ref key, !CSSM_KEYATTR_EXTRACTABLE;
+ * Gen wrapping key - a simple DES key;
+ * vfy you can't wrap unwrappedKey with wrappingKey;
+ */
+int symBadWrapTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY unwrappedKey;
+
+ if(!quiet) {
+ printf(" ...testing access to !EXTRACTABLE key bits via PKCS7 wrap\n");
+ }
+
+ /* gen ref key, CSSM_KEYATTR_SENSITIVE, !EXTRACTABLE */
+ if(genSymKey(cspHand, &unwrappedKey, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE,
+ CSSM_KEYUSE_ANY, CSSM_OK, quiet,
+ CSSM_FALSE, "SENSITIVE | RETURN_REF")) {
+ return 1;
+ }
+ if(badWrapTest(cspHand,
+ &unwrappedKey,
+ CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7,
+ quiet, keyAlgStr,
+ "!EXTRACTABLE wrap")) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &unwrappedKey);
+ return 0;
+}
+
+/*
+ * Verify proper asymmetric key wrap !EXTRACTABLE handling.
+ *
+ * Gen unwrapped ref key, !CSSM_KEYATTR_EXTRACTABLE;
+ * Gen wrapping key - a simple DES key;
+ * vfy you can't wrap unwrappedKey with wrappingKey;
+ */
+int asymBadWrapTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY pubKey;
+ CSSM_KEY privKey;
+
+ if(!quiet) {
+ printf(" ...testing access to !EXTRACTABLE key bits via CUSTOM wrap\n");
+ }
+
+ /* gen ref key, CSSM_KEYATTR_SENSITIVE, !EXTRACTABLE */
+ if(genKeyPair(cspHand, alg, keyAlgStr, keySizeInBits,
+ &pubKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY,
+ &privKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE,
+ CSSM_KEYUSE_ANY,
+ CSSM_OK, quiet, CSSM_FALSE, "RETURN_REF | SENSITIVE")) {
+ return 1;
+ }
+ if(badWrapTest(cspHand,
+ &privKey,
+ CSSM_KEYBLOB_WRAPPED_FORMAT_APPLE_CUSTOM,
+ quiet, keyAlgStr,
+ "!EXTRACTABLE wrap")) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &privKey);
+ cspFreeKey(cspHand, &pubKey);
+ return 0;
+}
+
+/*
+ * Generate a ref key, munge various fields in the header, verify that attempts
+ * to use the munged key result in CSSMERR_CSP_INVALID_KEY_REFERENCE.
+ */
+int symHeaderTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS keyAlg,
+ const char *keyAlgStr,
+ CSSM_ALGORITHMS encrAlg,
+ CSSM_ALGORITHMS signAlg,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY key;
+
+ if(!quiet) {
+ printf(" ...testing munged ref key header\n");
+ }
+ if(genSymKey(cspHand, &key, keyAlg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY, CSSM_OK, quiet,
+ CSSM_FALSE, "RETURN_REF")) {
+ return 1;
+ }
+ if(badHdrTest(cspHand, &key, quiet, keyAlgStr)) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &key);
+ return 0;
+}
+
+/*
+ * Generate key pair, specified pub key attr and expected result, standard
+ * "good" priv key attr. Used by asymAttrTest().
+ */
+static int pubKeyAttrTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_KEYATTR_FLAGS pubKeyAttr,
+ CSSM_RETURN expectRtn,
+ CSSM_BOOL quiet,
+ const char *testStr)
+{
+ CSSM_KEY pubKey;
+ CSSM_KEY privKey;
+
+ return genKeyPair(cspHand, alg, keyAlgStr, keySizeInBits,
+ &pubKey, pubKeyAttr, CSSM_KEYUSE_ANY,
+ &privKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE, CSSM_KEYUSE_ANY,
+ expectRtn, quiet, CSSM_TRUE, testStr);
+}
+
+/*
+ * Generate key pair, specified priv key attr and expected result, standard
+ * "good" pub key attr. Used by asymAttrTest().
+ */
+static int privKeyAttrTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_KEYATTR_FLAGS privKeyAttr,
+ CSSM_RETURN expectRtn,
+ CSSM_BOOL quiet,
+ const char *testStr)
+{
+ CSSM_KEY pubKey;
+ CSSM_KEY privKey;
+
+ return genKeyPair(cspHand, alg, keyAlgStr, keySizeInBits,
+ &pubKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY,
+ &privKey, privKeyAttr, CSSM_KEYUSE_ANY,
+ expectRtn, quiet, CSSM_TRUE, testStr);
+}
+
+/*
+ * Verify asymmetric key attribute behavior.
+ *
+ * check that you can't gen pub key with {
+ * CSSM_KEYATTR_ALWAYS_SENSITIVE
+ * CSSM_KEYATTR_NEVER_EXTRACTABLE
+ * CSSM_KEYATTR_PERMANENT
+ * CSSM_KEYATTR_PRIVATE
+ * CSSM_KEYATTR_RETURN_DATA | !CSSM_KEYATTR_EXTRACTABLE
+ * CSSM_KEYATTR_RETURN_REF | !CSSM_KEYATTR_EXTRACTABLE
+ * CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_SENSITIVE
+ * CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE
+ * }
+ * check that you can't gen priv key with {
+ * CSSM_KEYATTR_ALWAYS_SENSITIVE
+ * CSSM_KEYATTR_NEVER_EXTRACTABLE
+ * CSSM_KEYATTR_PERMANENT
+ * CSSM_KEYATTR_PRIVATE
+ * CSSM_KEYATTR_RETURN_DATA | !CSSM_KEYATTR_EXTRACTABLE
+ * CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_SENSITIVE
+ * }
+ */
+static int asymAttrTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_BOOL bareCsp,
+ CSSM_BOOL quiet)
+{
+ #if CSPDL_ALL_KEYS_ARE_PERMANENT
+ printf(" ...SKIPING asymAttrTest due to Radar 3732910\n");
+ return 0;
+ #endif
+ if(!quiet) {
+ printf(" ...testing key attr\n");
+ }
+ if(bareCsp || CSPDL_ALWAYS_SENSITIVE_CHECK) {
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_ALWAYS_SENSITIVE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "ALWAYS_SENSITIVE pub")) {
+ return 1;
+ }
+ }
+ if(bareCsp || CSPDL_NEVER_EXTRACTABLE_CHECK) {
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_NEVER_EXTRACTABLE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "NEVER_EXTRACTABLE pub")) {
+ return 1;
+ }
+ }
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_PERMANENT |
+ CSSM_KEYATTR_EXTRACTABLE,
+ bareCsp ?
+ /* bare CSP - permanent is checked first, this is the error */
+ CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK :
+ /* CSPDL - SS strips off permanent, then does key gen (so we'd
+ * better specify EXTRACTABLE!), *then* checks for DLDB. */
+ CSSMERR_CSP_MISSING_ATTR_DL_DB_HANDLE,
+ quiet, "PERMANENT pub")) {
+ return 1;
+ }
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_PRIVATE |
+ CSSM_KEYATTR_EXTRACTABLE,
+ CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK, quiet, "PRIVATE pub")) {
+ return 1;
+ }
+ if(bareCsp) {
+ /* CSPDL doesn't support RETURN_DATA */
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA /* | !CSSM_KEYATTR_EXTRACTABLE */,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ "RETURN_DATA | !EXTRACTABLE pub")) {
+ return 1;
+ }
+ }
+ /* pub key should always be extractable */
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF /* | !CSSM_KEYATTR_EXTRACTABLE */,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ "RETURN_REF | !EXTRACTABLE pub")) {
+ return 1;
+ }
+ /* pub keys can't be sensitive */
+ if(bareCsp) {
+ /* CSPDL doesn't support RETURN_DATA */
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_SENSITIVE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "RETURN_DATA | SENSITIVE pub")) {
+ return 1;
+ }
+ }
+ if(pubKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "RETURN_REF | !SENSITIVE pub")) {
+ return 1;
+ }
+
+ /* priv key attr tests */
+ if(bareCsp || CSPDL_ALWAYS_SENSITIVE_CHECK) {
+ if(privKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_ALWAYS_SENSITIVE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "ALWAYS_SENSITIVE priv")) {
+ return 1;
+ }
+ }
+ if(bareCsp || CSPDL_NEVER_EXTRACTABLE_CHECK) {
+ if(privKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_NEVER_EXTRACTABLE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "NEVER_EXTRACTABLE priv")) {
+ return 1;
+ }
+ }
+ if(privKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_PERMANENT,
+ bareCsp ? CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK :
+ CSSMERR_CSP_MISSING_ATTR_DL_DB_HANDLE,
+ quiet, "PERMANENT priv")) {
+ return 1;
+ }
+ if(privKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_PRIVATE,
+ CSSMERR_CSP_UNSUPPORTED_KEYATTR_MASK, quiet, "PRIVATE priv")) {
+ return 1;
+ }
+ if(bareCsp) {
+ /* CSPDL doesn't support RETURN_DATA */
+ if(privKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA /* | CSSM_KEYATTR_EXTRACTABLE */,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet,
+ "RETURN_DATA | !EXTRACTABLE priv")) {
+ return 1;
+ }
+ if(privKeyAttrTest(cspHand, alg, keyAlgStr, keySizeInBits,
+ CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_SENSITIVE,
+ CSSMERR_CSP_INVALID_KEYATTR_MASK, quiet, "RETURN_DATA | SENSITIVE priv")) {
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/*
+ * Verify asymmetric key null wrap behavior:
+ * gen ref key, CSSM_KEYATTR_SENSITIVE, vfy you can't do null wrap;
+ * gen ref key, !CSSM_KEYATTR_EXTRACTABLE, vfy you can't do null wrap;
+ */
+static int asymNullWrapTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS alg,
+ const char *keyAlgStr,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY pubKey;
+ CSSM_KEY privKey;
+
+ if(!quiet) {
+ printf(" ...testing access to inaccessible key bits via NULL wrap\n");
+ }
+ /* gen priv ref key, CSSM_KEYATTR_SENSITIVE, vfy you can't do null wrap */
+ if(genKeyPair(cspHand, alg, keyAlgStr, keySizeInBits,
+ &pubKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY,
+ &privKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_SENSITIVE,
+ CSSM_KEYUSE_ANY,
+ CSSM_OK, quiet, CSSM_FALSE, "RETURN_REF | SENSITIVE")) {
+ return 1;
+ }
+ if(nullWrapTest(cspHand, &privKey, quiet, CSSMERR_CSP_INVALID_KEYATTR_MASK,
+ keyAlgStr, "SENSITIVE")) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &privKey);
+ cspFreeKey(cspHand, &pubKey);
+
+ /* gen priv ref key, !CSSM_KEYATTR_EXTRACTABLE, vfy you can't do null wrap */
+ if(genKeyPair(cspHand, alg, keyAlgStr, keySizeInBits,
+ &pubKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY,
+ &privKey, CSSM_KEYATTR_RETURN_REF /* | !EXTRACTABLE */, CSSM_KEYUSE_ANY,
+ CSSM_OK, quiet, CSSM_FALSE, "RETURN_REF | !EXTRACTABLE")) {
+ return 1;
+ }
+ if(nullWrapTest(cspHand, &privKey, quiet, CSSMERR_CSP_INVALID_KEYATTR_MASK,
+ keyAlgStr, "!EXTRACTABLE")) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &privKey);
+ cspFreeKey(cspHand, &pubKey);
+ return 0;
+}
+
+/*
+ * Generate public and private ref keys, munge various fields in the header,
+ * verify that attempts to use the munged key result in
+ * CSSMERR_CSP_INVALID_KEY_REFERENCE.
+ */
+int asymHeaderTest(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_ALGORITHMS keyAlg,
+ const char *keyAlgStr,
+ CSSM_ALGORITHMS encrAlg,
+ CSSM_ALGORITHMS signAlg,
+ uint32 keySizeInBits,
+ CSSM_BOOL quiet)
+{
+ CSSM_KEY privKey;
+ CSSM_KEY pubKey;
+
+ if(!quiet) {
+ printf(" ...testing munged ref key header\n");
+ }
+ if(genKeyPair(cspHand, keyAlg, keyAlgStr, keySizeInBits,
+ &pubKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY,
+ &privKey, CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE,
+ CSSM_KEYUSE_ANY,
+ CSSM_OK, quiet, CSSM_FALSE, "RETURN_REF")) {
+ return 1;
+ }
+ if(badHdrTest(cspHand, &privKey, quiet, keyAlgStr)) {
+ return 1;
+ }
+ if(badHdrTest(cspHand, &pubKey, quiet, keyAlgStr)) {
+ return 1;
+ }
+ cspFreeKey(cspHand, &privKey);
+ cspFreeKey(cspHand, &pubKey);
+ return 0;
+}
+
+/* map one of our private privAlgs (ALG_DES, etc.) to associated CSSM info. */
+void privAlgToCssm(
+ privAlg palg,
+ CSSM_ALGORITHMS *keyAlg,
+ CSSM_ALGORITHMS *signAlg, // CSSM_ALGID_NONE means incapable (e.g., DES)
+ CSSM_ALGORITHMS *encrAlg, // CSSM_ALGID_NONE means incapable (e.g., DSA)
+ uint32 *keySizeInBits,
+ const char **keyAlgStr)
+{
+ *signAlg = *encrAlg = CSSM_ALGID_NONE; // default
+ switch(palg) {
+ case ALG_ASC:
+ *encrAlg = *keyAlg = CSSM_ALGID_ASC;
+ *keySizeInBits = CSP_ASC_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "ASC";
+ break;
+ case ALG_DES:
+ *encrAlg = *keyAlg = CSSM_ALGID_DES;
+ *keySizeInBits = CSP_DES_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "DES";
+ break;
+ case ALG_3DES:
+ *encrAlg = CSSM_ALGID_3DES_3KEY_EDE;
+ *keyAlg = CSSM_ALGID_3DES_3KEY;
+ *keySizeInBits = CSP_DES3_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "3DES";
+ break;
+ case ALG_RC2:
+ *encrAlg = *keyAlg = CSSM_ALGID_RC2;
+ *keySizeInBits = CSP_RC2_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "RC2";
+ break;
+ case ALG_RC4:
+ *encrAlg = *keyAlg = CSSM_ALGID_RC4;
+ *keySizeInBits = CSP_RC4_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "RC4";
+ break;
+ case ALG_RC5:
+ *encrAlg = *keyAlg = CSSM_ALGID_RC5;
+ *keySizeInBits = CSP_RC5_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "RC5";
+ break;
+ case ALG_AES:
+ *encrAlg = *keyAlg = CSSM_ALGID_AES;
+ *keySizeInBits = CSP_AES_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "AES";
+ break;
+ case ALG_RSA:
+ *keyAlg = CSSM_ALGID_RSA;
+ *encrAlg = CSSM_ALGID_RSA;
+ *signAlg = CSSM_ALGID_SHA1WithRSA;
+ *keySizeInBits = CSP_RSA_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "RSA";
+ break;
+ case ALG_DSA:
+ *keyAlg = CSSM_ALGID_DSA;
+ *signAlg = CSSM_ALGID_SHA1WithDSA;
+ *keySizeInBits = CSP_DSA_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "DSA";
+ break;
+ case ALG_FEE:
+ *keyAlg = CSSM_ALGID_FEE;
+ *signAlg = CSSM_ALGID_SHA1WithECDSA;
+ *encrAlg = CSSM_ALGID_FEEDEXP;
+ *keySizeInBits = CSP_FEE_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "FEE";
+ break;
+ case ALG_ECDSA:
+ *keyAlg = CSSM_ALGID_ECDSA;
+ *signAlg = CSSM_ALGID_SHA1WithECDSA;
+ *keySizeInBits = CSP_ECDSA_KEY_SIZE_DEFAULT;
+ *keyAlgStr = "ECDSA";
+ break;
+ default:
+ printf("***BRRZAP! privAlgToCssm needs work\n");
+ exit(1);
+ }
+ return;
+}
+
+int main(int argc, char **argv)
+{
+ int arg;
+ char *argp;
+ CSSM_CSP_HANDLE cspHand;
+ CSSM_ALGORITHMS keyAlg; // CSSM_ALGID_xxx of the key
+ CSSM_ALGORITHMS signAlg; // CSSM_ALGID_xxx of the associated signing op
+ CSSM_ALGORITHMS encrAlg; // CSSM_ALGID_xxx of the associated encrypt op
+ privAlg palg;
+ uint32 keySizeInBits;
+ int rtn;
+ int i;
+ const char *keyAlgStr;
+
+ /*
+ * User-spec'd params
+ */
+ CSSM_BOOL quiet = CSSM_FALSE;
+ CSSM_BOOL doSym = CSSM_TRUE;
+ CSSM_BOOL doAsym = CSSM_TRUE;
+ CSSM_BOOL bareCsp = CSSM_TRUE;
+
+ for(arg=1; arg<argc; arg++) {
+ argp = argv[arg];
+ switch(argp[0]) {
+ case 'q':
+ quiet = CSSM_TRUE;
+ break;
+ case 's':
+ doAsym = CSSM_FALSE;
+ break;
+ case 'a':
+ doSym = CSSM_FALSE;
+ break;
+ case 'D':
+ bareCsp = CSSM_FALSE;
+ break;
+ case 'h':
+ default:
+ usage(argv);
+ }
+ }
+ cspHand = cspDlDbStartup(bareCsp, NULL);
+ if(cspHand == 0) {
+ exit(1);
+ }
+ printf("Starting badattr; args: ");
+ for(i=1; i<argc; i++) {
+ printf("%s ", argv[i]);
+ }
+ printf("\n");
+
+ if(doSym) {
+ for(palg=SYM_FIRST; palg<=SYM_LAST; palg++) {
+ privAlgToCssm(palg, &keyAlg, &signAlg, &encrAlg, &keySizeInBits, &keyAlgStr);
+ if(!quiet) {
+ printf(" ...alg %s\n", keyAlgStr);
+ }
+ rtn = symAttrTest(cspHand, keyAlg, keyAlgStr, keySizeInBits, bareCsp,
+ quiet);
+ if(rtn) {
+ goto abort;
+ }
+ rtn = symNullWrapTest(cspHand, keyAlg, keyAlgStr, keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ rtn = symBadWrapTest(cspHand, keyAlg, keyAlgStr, keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ rtn = symUsageTest(cspHand, keyAlg, keyAlgStr, encrAlg, signAlg,
+ keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ if(bareCsp || CSPDL_MUNGE_HEADER_CHECK) {
+ rtn = symHeaderTest(cspHand, keyAlg, keyAlgStr, encrAlg, signAlg,
+ keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ }
+ else if(!quiet) {
+ printf(" ...SKIPPING munged ref key header test\n");
+ }
+ }
+ }
+
+ if(doAsym) {
+ for(palg=ASYM_FIRST; palg<=ASYM_LAST; palg++) {
+ privAlgToCssm(palg, &keyAlg, &signAlg, &encrAlg, &keySizeInBits,
+ &keyAlgStr);
+ if(!quiet) {
+ printf(" ...alg %s\n", keyAlgStr);
+ }
+ rtn = asymAttrTest(cspHand, keyAlg, keyAlgStr, keySizeInBits,
+ bareCsp, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ rtn = asymNullWrapTest(cspHand, keyAlg, keyAlgStr, keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ rtn = asymBadWrapTest(cspHand, keyAlg, keyAlgStr, keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ if(bareCsp || CSPDL_MUNGE_HEADER_CHECK) {
+ rtn = asymHeaderTest(cspHand, keyAlg, keyAlgStr, encrAlg, signAlg,
+ keySizeInBits, quiet);
+ if(rtn) {
+ goto abort;
+ }
+ }
+ else if(!quiet) {
+ printf(" ...SKIPPING munged ref key header test\n");
+ }
+ }
+ }
+abort:
+ cspShutdown(cspHand, bareCsp);
+ if((rtn == 0) && !quiet) {
+ printf("%s complete\n", argv[0]);
+ }
+ return rtn;
+}
+
projects / apple / security.git / blobdiff