[apple/security.git] / SecurityTests / cspxutils / ecdhTest / ecdhTest.cpp

/*
 * Copyright (c) 2008 Apple Inc. All Rights Reserved.
 * 
 * ecdhTest.cpp - Test Elliptic Curve Diffie-Hellman key exchange.
 *
 * Created Jan. 1 2008 by Doug Mitchell. 
 */
 
#include <stdlib.h>
#include <strings.h>
#include <stdio.h>
#include <unistd.h>
#include <Security/cssm.h>
#include "cspwrap.h"
#include "common.h"

#define LOOPS_DEF			32
#define KEY_SIZE_DEF		256

static void usage(char **argv)
{
	printf("usage: %s [options]\n", argv[0]);
	printf("Options:\n");
	printf("  k=keySize (default = %d)\n", KEY_SIZE_DEF);
	printf("  X (X9.63 key derivation)\n");
	printf("  l=loops (0=forever)\n");
	printf("  D (CSP/DL; default = bare CSP)\n");
	printf("  q(uiet)\n");
	printf("  v(erbose))\n");
	exit(1);
}

#define LABEL_DEF				"noLabel"
#define MAX_SHARED_INFO_LEN		400
#define MAX_DERIVED_SIZE		1024

static int doECDH(
	CSSM_CSP_HANDLE cspHand,
	CSSM_KEY_PTR	privKey,
	/* 
	 * pubKey:
	 *   Ref form - use key as pubKey as is
	 *   X509 form - use as is
	 *   OCTET_STRING form - use key data as Param
	 */
	CSSM_KEY_PTR	pubKey,
	CSSM_BOOL		bareCsp,	// false --> derive ref key and NULL-wrap it
	CSSM_BOOL		x963KDF,
	CSSM_DATA		*sharedInfo,
	uint32			deriveSizeInBits,
	CSSM_BOOL		quiet,
	CSSM_BOOL		verbose,
	
	/* result RETURNED here */
	CSSM_KEY_PTR	derivedKey)
	
{
	CSSM_DATA paramData = {0, NULL};
	CSSM_KEY_PTR contextPubKey = NULL;
	CSSM_KEYHEADER_PTR hdr = &pubKey->KeyHeader;
	
	if((hdr->BlobType == CSSM_KEYBLOB_RAW) && 
	   (hdr->Format == CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING)) {
		paramData = pubKey->KeyData;
	}
	else {
		contextPubKey = pubKey;
	}
	
	/* create key derivation context */
	CSSM_RETURN 			crtn;
	CSSM_ACCESS_CREDENTIALS	creds;
	CSSM_CC_HANDLE			ccHand;
	
	memset(&creds, 0, sizeof(CSSM_ACCESS_CREDENTIALS));
	
	CSSM_ALGORITHMS deriveAlg;
	if(x963KDF) {
		deriveAlg = CSSM_ALGID_ECDH_X963_KDF;
	}
	else {
		deriveAlg = CSSM_ALGID_ECDH;
	}
	
	crtn = CSSM_CSP_CreateDeriveKeyContext(cspHand,
		deriveAlg,
		CSSM_ALGID_RC4,	// doesn't matter, just give us the bits
		deriveSizeInBits,
		&creds,
		privKey,		// BaseKey
		0,				// IterationCount
		sharedInfo,		// Salt
		0,				// Seed
		&ccHand);
	if(crtn) {
		printError("CSSM_CSP_CreateDeriveKeyContext", crtn);
		return testError(quiet);
	}
	
	if(contextPubKey != NULL) {
		/* add pub key as a context attr */
		crtn = AddContextAttribute(ccHand,
			CSSM_ATTRIBUTE_PUBLIC_KEY,
			sizeof(CSSM_KEY),	
			CAT_Ptr,
			(void *)contextPubKey,
			0);
		if(crtn) {
			printError("AddContextAttribute(CSSM_ATTRIBUTE_PUBLIC_KEY)",
				crtn);
			return crtn;
		}
	}
	
	/* D-H derive key */
	CSSM_DATA	labelData = { strlen(LABEL_DEF), (uint8 *)LABEL_DEF };
	CSSM_KEYATTR_FLAGS keyAttr = bareCsp ? 
		(CSSM_KEYATTR_RETURN_DATA | CSSM_KEYATTR_EXTRACTABLE) :
		(CSSM_KEYATTR_RETURN_REF | CSSM_KEYATTR_EXTRACTABLE);
	memset(derivedKey, 0, sizeof(CSSM_KEY));
	crtn = CSSM_DeriveKey(ccHand,
		&paramData,
		CSSM_KEYUSE_ANY,
		keyAttr,
		&labelData,
		NULL,				// cread/acl
		derivedKey);
	if(crtn) {
		printError("CSSM_DeriveKey", crtn);
	}
	CSSM_DeleteContext(ccHand);
	if(crtn) {
		return testError(quiet);
	}
	
	if(!bareCsp) {
		/* Got a ref key, give caller raw */
		CSSM_KEY refKey = *derivedKey;
		crtn = cspRefKeyToRaw(cspHand, &refKey, derivedKey);
		cspFreeKey(cspHand, &refKey);
	}
	return 0;
}

/* define public key style */
typedef enum {
	PKT_Ref,		/* ref key */
	PKT_Wrap,		/* generate ref key, wrap to OCTET_STRING */
	PKT_X509,		/* raw key X509 format */
	PKT_Octet		/* generate to OCTET_STRING form */
} PubKeyType;

#define BoolStr(v)	(v ? "true " : "false")

static const char *KeyStypeStr(
	PubKeyType keyType)
{
	switch(keyType) {
		case PKT_Ref:	return "Ref";
		case PKT_Wrap:	return "Ref->Wrap";
		case PKT_X509:	return "X509";
		case PKT_Octet:	return "X9.62";
		default:		return "BRRZAP";
	}
}

static int doTest(
	CSSM_CSP_HANDLE cspHand,
	CSSM_BOOL		ourKeysRef,			/* our keys are reference */
	CSSM_BOOL		theirPrivKeyRef,	/* their private key is reference */
	PubKeyType		theirPubKeyType,
	unsigned		keySizeBits,
	CSSM_BOOL		bareCsp,
	CSSM_BOOL		x963KDF,
	CSSM_BOOL		useSharedInfo,		/* use the optional SharedInfo for x963KDF */
	CSSM_BOOL		verbose,
	CSSM_BOOL		quiet)
{
	
	CSSM_RETURN crtn;
	CSSM_KEY ourPriv;
	CSSM_KEY ourPub;
	bool ourKeysGend = false;
	bool theirKeysGend = false;
	bool wrappedTheirPub = false;
	bool wrappedOurPub = false;
	bool derivedKey1 = false;
	bool derivedKey2 = false;
	CSSM_DATA sharedInfo = {0, NULL};
	uint32 deriveSizeInBits;

	if(x963KDF) {
		/* arbitrary derived size */
		deriveSizeInBits = genRand(1, MAX_DERIVED_SIZE);
	}
	else {
		deriveSizeInBits = keySizeBits;
	}
	if(useSharedInfo) {
		/* length should be totally arbitrary */
		appSetupCssmData(&sharedInfo, MAX_SHARED_INFO_LEN);
		simpleGenData(&sharedInfo, 1, MAX_SHARED_INFO_LEN);
	}
	
	
	if(!quiet) {
		if(x963KDF) {
			printf("...sharedInfoLen %4lu deriveSize %4lu ",
				(unsigned long)sharedInfo.Length, (unsigned long)deriveSizeInBits);
		}
		else {
			printf("...");
		}
		printf("ourRef %s theirPrivRef %s theirPub %s\n",
			BoolStr(ourKeysRef), BoolStr(theirPrivKeyRef), 
			KeyStypeStr(theirPubKeyType));
	}
	
	crtn = cspGenKeyPair(cspHand, CSSM_ALGID_ECDSA, 
		LABEL_DEF, strlen(LABEL_DEF), keySizeBits, 
		&ourPub, ourKeysRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
		&ourPriv, ourKeysRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
		CSSM_FALSE);
	if(crtn) {
		return testError(quiet);
	}
	ourKeysGend = true;
	
	CSSM_KEY theirPriv;
	CSSM_KEY theirPub;			/* the generated one */
	CSSM_KEY theirWrappedPub;	/* optional NULL unwrap */
	CSSM_KEY_PTR theirPubPtr;
	CSSM_KEY ourWrappedPub;	/* optional NULL unwrap */
	CSSM_KEY_PTR ourPubPtr;
	CSSM_KEY derived1;
	CSSM_KEY derived2;
	CSSM_BOOL pubIsRef = CSSM_FALSE;
	CSSM_KEYBLOB_FORMAT blobForm = CSSM_KEYBLOB_RAW_FORMAT_NONE;
	int ourRtn = 0;
	
	switch(theirPubKeyType) {
		case PKT_Ref:
		case PKT_Wrap:
			pubIsRef = CSSM_TRUE;
			break;
		case PKT_X509:
			pubIsRef = CSSM_FALSE;
			break;
		case PKT_Octet:
			pubIsRef = CSSM_FALSE;
			blobForm = CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING;
			break;
	}
	
	crtn = cspGenKeyPair(cspHand, CSSM_ALGID_ECDSA, 
		LABEL_DEF, strlen(LABEL_DEF), keySizeBits, 
		&theirPub, pubIsRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
		&theirPriv, theirPrivKeyRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
		CSSM_FALSE);
	if(crtn) {
		ourRtn = testError(quiet);
		goto errOut;
	}

	if(theirPubKeyType == PKT_Wrap) {
		/* 
		 * This test mode is here mainly to ring out the key wrap and 
		 * OCTET_STRING format functionality in the CrypkitCSP, it's
		 * not really relevant to ECDH...
		 */
		crtn = cspRefKeyToRawWithFormat(cspHand, &theirPub,
			CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING, &theirWrappedPub);
		if(crtn) {
			ourRtn = testError(quiet);
			goto errOut;
		}
		theirPubPtr = &theirWrappedPub;
		wrappedTheirPub = true;
	}
	else {
		theirPubPtr = &theirPub;
	}
	
	if(!bareCsp) {
		/*
		 * For CSPDL, convert our pub key to OCTET_STRING format so it
		 * is sent as a Param - can't send a ref key (or any other pub 
		 * key) in the context
		 */
		crtn = cspRefKeyToRawWithFormat(cspHand, &ourPub,
			CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING, &ourWrappedPub);
		if(crtn) {
			ourRtn = testError(quiet);
			goto errOut;
		}
		ourPubPtr = &ourWrappedPub;
		wrappedOurPub = true;
	}
	else {
		ourPubPtr = &ourPub;
	}

	/* 
	 * Here we go, do the two sides of D-H key agreement, results to 
	 * to CSSM_KEYs.
	 */
	ourRtn = doECDH(cspHand, &ourPriv, theirPubPtr, bareCsp, 
		x963KDF, useSharedInfo ? &sharedInfo : NULL,
		deriveSizeInBits, quiet, verbose, &derived1);
	if(ourRtn) {
		goto errOut;
	}
	ourRtn = doECDH(cspHand, &theirPriv, ourPubPtr, bareCsp, 
		x963KDF, useSharedInfo ? &sharedInfo : NULL,	
		deriveSizeInBits, quiet, verbose, &derived2);
	if(ourRtn) {
		goto errOut;
	}

	if(!appCompareCssmData(&derived1.KeyData, &derived2.KeyData)) {
		printf("***Data Miscompare on ECDH key derivation\n");
	}
errOut:
	if(ourKeysGend) {
		cspFreeKey(cspHand, &ourPub);
		cspFreeKey(cspHand, &ourPriv);
	}
	if(theirKeysGend) {
		cspFreeKey(cspHand, &theirPub);
		cspFreeKey(cspHand, &theirPriv);
	}
	if(wrappedTheirPub) {
		cspFreeKey(cspHand, &theirWrappedPub);
	}
	if(wrappedOurPub) {
		cspFreeKey(cspHand, &ourWrappedPub);
	}
	if(derivedKey1) {
		cspFreeKey(cspHand, &derived1);
	}
	if(derivedKey2) {
		cspFreeKey(cspHand, &derived2);
	}
	if(sharedInfo.Data != NULL) {
		appFreeCssmData(&sharedInfo, CSSM_FALSE);
	}
	return ourRtn;
}

int main(int argc, char **argv)
{
	int		 		arg;
	char			*argp;
	CSSM_CSP_HANDLE cspHand;
	unsigned		loop;
	int				ourRtn = 0;
	
	unsigned	keySize = KEY_SIZE_DEF;
	unsigned	loops = LOOPS_DEF;
	CSSM_BOOL	quiet = CSSM_FALSE;
	CSSM_BOOL	verbose = CSSM_FALSE;
	CSSM_BOOL	bareCsp = CSSM_TRUE;
	CSSM_BOOL	x963KDF = CSSM_FALSE;
	
	for(arg=1; arg<argc; arg++) { 
		argp = argv[arg];
	    switch(argp[0]) {
			case 'k':
				keySize = atoi(&argp[2]);
				break;
			case 'X':
				x963KDF = true;
				break;
		    case 'l':
				loops = atoi(&argp[2]);
				break;
			case 'D':
				bareCsp = CSSM_FALSE;
				break;
			case 'q':
				quiet = CSSM_TRUE;
				break;
		    case 'v':
		    	verbose = CSSM_TRUE;
				break;
			default:
				usage(argv);
		}
	}
	testStartBanner("ecdhTest", argc, argv);	

	cspHand = cspDlDbStartup(bareCsp, NULL);
	if(cspHand == 0) {
		exit(1);
	}
	
	for(loop=1; ; loop++) {
		if(!quiet) {
			printf("...Loop %d\n", loop);
		}
		
		/* test mode from l.s. bits of loop counter */

		CSSM_BOOL ourKeysRef = (loop & 0x04) ? CSSM_TRUE : CSSM_FALSE;
		CSSM_BOOL theirPrivKeyRef = (loop & 0x08) ? CSSM_TRUE : CSSM_FALSE;
		PubKeyType theirPubKeyType;
		switch(loop & 0x03) {
			case 0:
				theirPubKeyType = PKT_Ref;
				break;
			case 1:
				theirPubKeyType = PKT_Wrap;
				break;
			case 2:
				theirPubKeyType = PKT_X509;
				break;
			default:
				theirPubKeyType = PKT_Octet;
				break;
		}
		
		if(!bareCsp) {
			/* 
			 * Generated keys have to be reference
			 * pub keys have to be passed as Param
			 */
			ourKeysRef = CSSM_TRUE;
			theirPrivKeyRef = CSSM_TRUE;
			theirPubKeyType = PKT_Wrap;
		}
		
		CSSM_BOOL useSharedInfo = CSSM_FALSE;
		if(x963KDF & ((loop & 0x01) == 0)) {
			useSharedInfo = CSSM_TRUE;
		}
		ourRtn = doTest(cspHand, ourKeysRef, theirPrivKeyRef, theirPubKeyType,
			keySize, bareCsp, x963KDF, useSharedInfo, verbose, quiet);
		if(ourRtn) {
			break;
		}
		if(loops && (loop == loops)) {
			break;
		}
	}
	CSSM_ModuleDetach(cspHand);
	if((ourRtn == 0) && !quiet) {
		printf("OK\n");
	}

	return ourRtn;
}
Commit	Line	Data
d8f41ccd A	1	/*
	2	* Copyright (c) 2008 Apple Inc. All Rights Reserved.
	3	*
	4	* ecdhTest.cpp - Test Elliptic Curve Diffie-Hellman key exchange.
	5	*
	6	* Created Jan. 1 2008 by Doug Mitchell.
	7	*/
	8
	9	#include <stdlib.h>
	10	#include <strings.h>
	11	#include <stdio.h>
	12	#include <unistd.h>
	13	#include <Security/cssm.h>
	14	#include "cspwrap.h"
	15	#include "common.h"
	16
	17	#define LOOPS_DEF 32
	18	#define KEY_SIZE_DEF 256
	19
	20	static void usage(char **argv)
	21	{
	22	printf("usage: %s [options]\n", argv[0]);
	23	printf("Options:\n");
	24	printf(" k=keySize (default = %d)\n", KEY_SIZE_DEF);
	25	printf(" X (X9.63 key derivation)\n");
	26	printf(" l=loops (0=forever)\n");
	27	printf(" D (CSP/DL; default = bare CSP)\n");
	28	printf(" q(uiet)\n");
	29	printf(" v(erbose))\n");
	30	exit(1);
	31	}
	32
	33	#define LABEL_DEF "noLabel"
	34	#define MAX_SHARED_INFO_LEN 400
	35	#define MAX_DERIVED_SIZE 1024
	36
	37	static int doECDH(
	38	CSSM_CSP_HANDLE cspHand,
	39	CSSM_KEY_PTR privKey,
	40	/*
	41	* pubKey:
	42	* Ref form - use key as pubKey as is
	43	* X509 form - use as is
	44	* OCTET_STRING form - use key data as Param
	45	*/
	46	CSSM_KEY_PTR pubKey,
	47	CSSM_BOOL bareCsp, // false --> derive ref key and NULL-wrap it
	48	CSSM_BOOL x963KDF,
	49	CSSM_DATA *sharedInfo,
	50	uint32 deriveSizeInBits,
	51	CSSM_BOOL quiet,
	52	CSSM_BOOL verbose,
	53
	54	/* result RETURNED here */
	55	CSSM_KEY_PTR derivedKey)
	56
	57	{
	58	CSSM_DATA paramData = {0, NULL};
	59	CSSM_KEY_PTR contextPubKey = NULL;
	60	CSSM_KEYHEADER_PTR hdr = &pubKey->KeyHeader;
	61
	62	if((hdr->BlobType == CSSM_KEYBLOB_RAW) &&
	63	(hdr->Format == CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING)) {
	64	paramData = pubKey->KeyData;
65	}
66	else {
67	contextPubKey = pubKey;
68	}
69
70	/* create key derivation context */
71	CSSM_RETURN crtn;
72	CSSM_ACCESS_CREDENTIALS creds;
73	CSSM_CC_HANDLE ccHand;
74
75	memset(&creds, 0, sizeof(CSSM_ACCESS_CREDENTIALS));
76
77	CSSM_ALGORITHMS deriveAlg;
78	if(x963KDF) {
79	deriveAlg = CSSM_ALGID_ECDH_X963_KDF;
80	}
81	else {
82	deriveAlg = CSSM_ALGID_ECDH;
83	}
84
85	crtn = CSSM_CSP_CreateDeriveKeyContext(cspHand,
86	deriveAlg,
87	CSSM_ALGID_RC4, // doesn't matter, just give us the bits
88	deriveSizeInBits,
89	&creds,
90	privKey, // BaseKey
91	0, // IterationCount
92	sharedInfo, // Salt
93	0, // Seed
94	&ccHand);
95	if(crtn) {
96	printError("CSSM_CSP_CreateDeriveKeyContext", crtn);
97	return testError(quiet);
98	}
99
100	if(contextPubKey != NULL) {
101	/* add pub key as a context attr */
102	crtn = AddContextAttribute(ccHand,
103	CSSM_ATTRIBUTE_PUBLIC_KEY,
104	sizeof(CSSM_KEY),
105	CAT_Ptr,
106	(void *)contextPubKey,
107	0);
108	if(crtn) {
109	printError("AddContextAttribute(CSSM_ATTRIBUTE_PUBLIC_KEY)",
110	crtn);
111	return crtn;
112	}
113	}
114
115	/* D-H derive key */
116	CSSM_DATA labelData = { strlen(LABEL_DEF), (uint8 *)LABEL_DEF };
117	CSSM_KEYATTR_FLAGS keyAttr = bareCsp ?
118	(CSSM_KEYATTR_RETURN_DATA \| CSSM_KEYATTR_EXTRACTABLE) :
119	(CSSM_KEYATTR_RETURN_REF \| CSSM_KEYATTR_EXTRACTABLE);
120	memset(derivedKey, 0, sizeof(CSSM_KEY));
121	crtn = CSSM_DeriveKey(ccHand,
122	&paramData,
123	CSSM_KEYUSE_ANY,
124	keyAttr,
125	&labelData,
126	NULL, // cread/acl
127	derivedKey);
128	if(crtn) {
129	printError("CSSM_DeriveKey", crtn);
130	}
131	CSSM_DeleteContext(ccHand);
132	if(crtn) {
133	return testError(quiet);
134	}
135
136	if(!bareCsp) {
137	/* Got a ref key, give caller raw */
138	CSSM_KEY refKey = *derivedKey;
139	crtn = cspRefKeyToRaw(cspHand, &refKey, derivedKey);
140	cspFreeKey(cspHand, &refKey);
141	}
142	return 0;
143	}
144
145	/* define public key style */
146	typedef enum {
147	PKT_Ref, /* ref key */
148	PKT_Wrap, /* generate ref key, wrap to OCTET_STRING */
149	PKT_X509, /* raw key X509 format */
150	PKT_Octet /* generate to OCTET_STRING form */
151	} PubKeyType;
152
153	#define BoolStr(v) (v ? "true " : "false")
154
155	static const char *KeyStypeStr(
156	PubKeyType keyType)
157	{
158	switch(keyType) {
159	case PKT_Ref: return "Ref";
160	case PKT_Wrap: return "Ref->Wrap";
161	case PKT_X509: return "X509";
162	case PKT_Octet: return "X9.62";
163	default: return "BRRZAP";
164	}
165	}
166
167	static int doTest(
168	CSSM_CSP_HANDLE cspHand,
169	CSSM_BOOL ourKeysRef, /* our keys are reference */
170	CSSM_BOOL theirPrivKeyRef, /* their private key is reference */
171	PubKeyType theirPubKeyType,
172	unsigned keySizeBits,
173	CSSM_BOOL bareCsp,
174	CSSM_BOOL x963KDF,
175	CSSM_BOOL useSharedInfo, /* use the optional SharedInfo for x963KDF */
176	CSSM_BOOL verbose,
177	CSSM_BOOL quiet)
178	{
179
180	CSSM_RETURN crtn;
181	CSSM_KEY ourPriv;
182	CSSM_KEY ourPub;
183	bool ourKeysGend = false;
184	bool theirKeysGend = false;
185	bool wrappedTheirPub = false;
186	bool wrappedOurPub = false;
187	bool derivedKey1 = false;
188	bool derivedKey2 = false;
189	CSSM_DATA sharedInfo = {0, NULL};
190	uint32 deriveSizeInBits;
191
192	if(x963KDF) {
193	/* arbitrary derived size */
194	deriveSizeInBits = genRand(1, MAX_DERIVED_SIZE);
195	}
196	else {
197	deriveSizeInBits = keySizeBits;
198	}
199	if(useSharedInfo) {
200	/* length should be totally arbitrary */
201	appSetupCssmData(&sharedInfo, MAX_SHARED_INFO_LEN);
202	simpleGenData(&sharedInfo, 1, MAX_SHARED_INFO_LEN);
203	}
204
205
206	if(!quiet) {
207	if(x963KDF) {
208	printf("...sharedInfoLen %4lu deriveSize %4lu ",
209	(unsigned long)sharedInfo.Length, (unsigned long)deriveSizeInBits);
210	}
211	else {
212	printf("...");
213	}
214	printf("ourRef %s theirPrivRef %s theirPub %s\n",
215	BoolStr(ourKeysRef), BoolStr(theirPrivKeyRef),
216	KeyStypeStr(theirPubKeyType));
217	}
218
219	crtn = cspGenKeyPair(cspHand, CSSM_ALGID_ECDSA,
220	LABEL_DEF, strlen(LABEL_DEF), keySizeBits,
221	&ourPub, ourKeysRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
222	&ourPriv, ourKeysRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
223	CSSM_FALSE);
224	if(crtn) {
225	return testError(quiet);
226	}
227	ourKeysGend = true;
228
229	CSSM_KEY theirPriv;
230	CSSM_KEY theirPub; /* the generated one */
231	CSSM_KEY theirWrappedPub; /* optional NULL unwrap */
232	CSSM_KEY_PTR theirPubPtr;
233	CSSM_KEY ourWrappedPub; /* optional NULL unwrap */
234	CSSM_KEY_PTR ourPubPtr;
235	CSSM_KEY derived1;
236	CSSM_KEY derived2;
237	CSSM_BOOL pubIsRef = CSSM_FALSE;
238	CSSM_KEYBLOB_FORMAT blobForm = CSSM_KEYBLOB_RAW_FORMAT_NONE;
239	int ourRtn = 0;
240
241	switch(theirPubKeyType) {
242	case PKT_Ref:
243	case PKT_Wrap:
244	pubIsRef = CSSM_TRUE;
245	break;
246	case PKT_X509:
247	pubIsRef = CSSM_FALSE;
248	break;
249	case PKT_Octet:
250	pubIsRef = CSSM_FALSE;
251	blobForm = CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING;
252	break;
253	}
254
255	crtn = cspGenKeyPair(cspHand, CSSM_ALGID_ECDSA,
256	LABEL_DEF, strlen(LABEL_DEF), keySizeBits,
257	&theirPub, pubIsRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
258	&theirPriv, theirPrivKeyRef, CSSM_KEYUSE_DERIVE, CSSM_KEYBLOB_RAW_FORMAT_NONE,
259	CSSM_FALSE);
260	if(crtn) {
261	ourRtn = testError(quiet);
262	goto errOut;
263	}
264
265	if(theirPubKeyType == PKT_Wrap) {
266	/*
267	* This test mode is here mainly to ring out the key wrap and
268	* OCTET_STRING format functionality in the CrypkitCSP, it's
269	* not really relevant to ECDH...
270	*/
271	crtn = cspRefKeyToRawWithFormat(cspHand, &theirPub,
272	CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING, &theirWrappedPub);
273	if(crtn) {
274	ourRtn = testError(quiet);
275	goto errOut;
276	}
277	theirPubPtr = &theirWrappedPub;
278	wrappedTheirPub = true;
279	}
280	else {
281	theirPubPtr = &theirPub;
282	}
283
284	if(!bareCsp) {
285	/*
286	* For CSPDL, convert our pub key to OCTET_STRING format so it
287	* is sent as a Param - can't send a ref key (or any other pub
288	* key) in the context
289	*/
290	crtn = cspRefKeyToRawWithFormat(cspHand, &ourPub,
291	CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING, &ourWrappedPub);
292	if(crtn) {
293	ourRtn = testError(quiet);
294	goto errOut;
295	}
296	ourPubPtr = &ourWrappedPub;
297	wrappedOurPub = true;
298	}
299	else {
300	ourPubPtr = &ourPub;
301	}
302
303	/*
304	* Here we go, do the two sides of D-H key agreement, results to
305	* to CSSM_KEYs.
306	*/
307	ourRtn = doECDH(cspHand, &ourPriv, theirPubPtr, bareCsp,
308	x963KDF, useSharedInfo ? &sharedInfo : NULL,
309	deriveSizeInBits, quiet, verbose, &derived1);
310	if(ourRtn) {
311	goto errOut;
312	}
313	ourRtn = doECDH(cspHand, &theirPriv, ourPubPtr, bareCsp,
314	x963KDF, useSharedInfo ? &sharedInfo : NULL,
315	deriveSizeInBits, quiet, verbose, &derived2);
316	if(ourRtn) {
317	goto errOut;
318	}
319
320	if(!appCompareCssmData(&derived1.KeyData, &derived2.KeyData)) {
321	printf("***Data Miscompare on ECDH key derivation\n");
322	}
323	errOut:
324	if(ourKeysGend) {
325	cspFreeKey(cspHand, &ourPub);
326	cspFreeKey(cspHand, &ourPriv);
327	}
328	if(theirKeysGend) {
329	cspFreeKey(cspHand, &theirPub);
330	cspFreeKey(cspHand, &theirPriv);
331	}
332	if(wrappedTheirPub) {
333	cspFreeKey(cspHand, &theirWrappedPub);
334	}
335	if(wrappedOurPub) {
336	cspFreeKey(cspHand, &ourWrappedPub);
337	}
338	if(derivedKey1) {
339	cspFreeKey(cspHand, &derived1);
340	}
341	if(derivedKey2) {
342	cspFreeKey(cspHand, &derived2);
343	}
344	if(sharedInfo.Data != NULL) {
345	appFreeCssmData(&sharedInfo, CSSM_FALSE);
346	}
347	return ourRtn;
348	}
349
350	int main(int argc, char **argv)
351	{
352	int arg;
353	char *argp;
354	CSSM_CSP_HANDLE cspHand;
355	unsigned loop;
356	int ourRtn = 0;
357
358	unsigned keySize = KEY_SIZE_DEF;
359	unsigned loops = LOOPS_DEF;
360	CSSM_BOOL quiet = CSSM_FALSE;
361	CSSM_BOOL verbose = CSSM_FALSE;
362	CSSM_BOOL bareCsp = CSSM_TRUE;
363	CSSM_BOOL x963KDF = CSSM_FALSE;
364
365	for(arg=1; arg<argc; arg++) {
366	argp = argv[arg];
367	switch(argp[0]) {
368	case 'k':
369	keySize = atoi(&argp[2]);
370	break;
371	case 'X':
372	x963KDF = true;
373	break;
374	case 'l':
375	loops = atoi(&argp[2]);
376	break;
377	case 'D':
378	bareCsp = CSSM_FALSE;
379	break;
380	case 'q':
381	quiet = CSSM_TRUE;
382	break;
383	case 'v':
384	verbose = CSSM_TRUE;
385	break;
386	default:
387	usage(argv);
388	}
389	}
390	testStartBanner("ecdhTest", argc, argv);
391
392	cspHand = cspDlDbStartup(bareCsp, NULL);
393	if(cspHand == 0) {
394	exit(1);
395	}
396
397	for(loop=1; ; loop++) {
398	if(!quiet) {
399	printf("...Loop %d\n", loop);
400	}
401
402	/* test mode from l.s. bits of loop counter */
403
404	CSSM_BOOL ourKeysRef = (loop & 0x04) ? CSSM_TRUE : CSSM_FALSE;
405	CSSM_BOOL theirPrivKeyRef = (loop & 0x08) ? CSSM_TRUE : CSSM_FALSE;
406	PubKeyType theirPubKeyType;
407	switch(loop & 0x03) {
408	case 0:
409	theirPubKeyType = PKT_Ref;
410	break;
411	case 1:
412	theirPubKeyType = PKT_Wrap;
413	break;
414	case 2:
415	theirPubKeyType = PKT_X509;
416	break;
417	default:
418	theirPubKeyType = PKT_Octet;
419	break;
420	}
421
422	if(!bareCsp) {
423	/*
424	* Generated keys have to be reference
425	* pub keys have to be passed as Param
426	*/
427	ourKeysRef = CSSM_TRUE;
428	theirPrivKeyRef = CSSM_TRUE;
429	theirPubKeyType = PKT_Wrap;
430	}
431
432	CSSM_BOOL useSharedInfo = CSSM_FALSE;
433	if(x963KDF & ((loop & 0x01) == 0)) {
434	useSharedInfo = CSSM_TRUE;
435	}
436	ourRtn = doTest(cspHand, ourKeysRef, theirPrivKeyRef, theirPubKeyType,
437	keySize, bareCsp, x963KDF, useSharedInfo, verbose, quiet);
438	if(ourRtn) {
439	break;
440	}
441	if(loops && (loop == loops)) {
442	break;
443	}
444	}
445	CSSM_ModuleDetach(cspHand);
446	if((ourRtn == 0) && !quiet) {
447	printf("OK\n");
448	}
449
450	return ourRtn;
451	}