1/*
2 * Copyright (c) 2000-2001,2011,2014 Apple Inc. All Rights Reserved.
3 *
4 * The contents of this file constitute Original Code as defined in and are
5 * subject to the Apple Public Source License Version 1.2 (the 'License').
6 * You may not use this file except in compliance with the License. Please obtain
7 * a copy of the License at http://www.apple.com/publicsource and read it before
8 * using this file.
9 *
10 * This Original Code and all software distributed under the License are
11 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
12 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
13 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
14 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
15 * specific language governing rights and limitations under the License.
16 */
17
18
19//
20// cryptkitcsp - top C++ implementation layer for CryptKit
21//
22
23#ifdef	CRYPTKIT_CSP_ENABLE
24
25#include "cryptkitcsp.h"
26#include "FEESignatureObject.h"			/* raw signer */
27#include <SignatureContext.h>
28#include "FEEKeys.h"
29#include "FEEAsymmetricContext.h"
30#include <Security/cssmapple.h>
31#include <security_cryptkit/falloc.h>
32#include <security_cryptkit/feeFunctions.h>
33#include <SHA1_MD5_Object.h>
34#include <SHA2_Object.h>
35#include <security_cdsa_utilities/digestobject.h>
36
37Allocator *CryptKitFactory::normAllocator;
38Allocator *CryptKitFactory::privAllocator;
39
40/*
41 * CryptKit-style memory allocator callbacks
42 */
43static void *ckMalloc(unsigned size)
44{
45	return CryptKitFactory::privAllocator->malloc(size);
46}
47static void ckFree(void *data)
48{
49	CryptKitFactory::privAllocator->free(data);
50}
51static void *ckRealloc(void *oldPtr, unsigned newSize)
52{
53	return CryptKitFactory::privAllocator->realloc(oldPtr, newSize);
54}
55
56//
57// Manage the CryptKit algorithm factory
58//
59
60CryptKitFactory::CryptKitFactory(Allocator *normAlloc, Allocator *privAlloc)
61{
62	setNormAllocator(normAlloc);
63	setPrivAllocator(privAlloc);
64	/* once-per-address space */
65	initCryptKit();
66	fallocRegister(ckMalloc, ckFree, ckRealloc);
67}
68
69CryptKitFactory::~CryptKitFactory()
70{
71	terminateCryptKit();
72}
73
74bool CryptKitFactory::setup(
75	AppleCSPSession &session,
76	CSPFullPluginSession::CSPContext * &cspCtx,
77	const Context &context)
78{
79	switch(context.type()) {
80		case CSSM_ALGCLASS_SIGNATURE:
81			switch(context.algorithm()) {
82				case CSSM_ALGID_FEE_MD5:
83					if(cspCtx == NULL) {
84						cspCtx = new SignatureContext(session,
85							*(new MD5Object()),
86							*(new FEERawSigner(feeRandCallback,
87								&session,
88								session,
89								*privAllocator)));
90					}
91					return true;
92				case CSSM_ALGID_FEE_SHA1:
93					if(cspCtx == NULL) {
94						cspCtx = new SignatureContext(session,
95							*(new SHA1Object()),
96							*(new FEERawSigner(feeRandCallback,
97								&session,
98								session,
99								*privAllocator)));
100					}
101					return true;
102				case CSSM_ALGID_SHA1WithECDSA:
103					if(cspCtx == NULL) {
104						cspCtx = new SignatureContext(session,
105							*(new SHA1Object()),
106							*(new FEEECDSASigner(feeRandCallback,
107								&session,
108								session,
109								*privAllocator)));
110					}
111					return true;
112				case CSSM_ALGID_SHA224WithECDSA:
113					if(cspCtx == NULL) {
114						cspCtx = new SignatureContext(session,
115							*(new SHA224Object()),
116							*(new FEEECDSASigner(feeRandCallback,
117								&session,
118								session,
119								*privAllocator)));
120					}
121					return true;
122				case CSSM_ALGID_SHA256WithECDSA:
123					if(cspCtx == NULL) {
124						cspCtx = new SignatureContext(session,
125							*(new SHA256Object()),
126							*(new FEEECDSASigner(feeRandCallback,
127								&session,
128								session,
129								*privAllocator)));
130					}
131					return true;
132				case CSSM_ALGID_SHA384WithECDSA:
133					if(cspCtx == NULL) {
134						cspCtx = new SignatureContext(session,
135							*(new SHA384Object()),
136							*(new FEEECDSASigner(feeRandCallback,
137								&session,
138								session,
139								*privAllocator)));
140					}
141					return true;
142				case CSSM_ALGID_SHA512WithECDSA:
143					if(cspCtx == NULL) {
144						cspCtx = new SignatureContext(session,
145							*(new SHA512Object()),
146							*(new FEEECDSASigner(feeRandCallback,
147								&session,
148								session,
149								*privAllocator)));
150					}
151					return true;
152
153				case CSSM_ALGID_FEE:
154					if(cspCtx == NULL) {
155						cspCtx = new SignatureContext(session,
156							*(new NullDigest()),
157							*(new FEERawSigner(feeRandCallback,
158								&session,
159								session,
160								*privAllocator)));
161					}
162					return true;
163				case CSSM_ALGID_ECDSA:
164					if(cspCtx == NULL) {
165						cspCtx = new SignatureContext(session,
166							*(new NullDigest()),
167							*(new FEEECDSASigner(feeRandCallback,
168								&session,
169								session,
170								*privAllocator)));
171					}
172					return true;
173				default:
174					break;
175			}
176			break;
177
178		case CSSM_ALGCLASS_KEYGEN:
179			switch(context.algorithm()) {
180				case CSSM_ALGID_FEE:
181				case CSSM_ALGID_ECDSA:
182					if(cspCtx == NULL) {
183						cspCtx = new CryptKit::FEEKeyPairGenContext(session, context);
184					}
185					return true;
186				default:
187					break;
188			}
189			break;
190
191		case CSSM_ALGCLASS_ASYMMETRIC:
192			switch(context.algorithm()) {
193				case CSSM_ALGID_FEEDEXP:
194					if(cspCtx == NULL) {
195						cspCtx = new CryptKit::FEEDExpContext(session);
196					}
197					return true;
198				case CSSM_ALGID_FEED:
199					if(cspCtx == NULL) {
200						cspCtx = new CryptKit::FEEDContext(session);
201					}
202					return true;
203				default:
204					break;
205			}
206			break;
207
208		/* more here - symmetric, etc. */
209		default:
210			break;
211	}
212	/* not implemented here */
213	return false;
214}
215
216#endif	/* CRYPTKIT_CSP_ENABLE */
217
218
219