Annotation of embedaddon/axTLS/ssl/p12.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 2007, Cameron Rich
3: *
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions are met:
8: *
9: * * Redistributions of source code must retain the above copyright notice,
10: * this list of conditions and the following disclaimer.
11: * * Redistributions in binary form must reproduce the above copyright notice,
12: * this list of conditions and the following disclaimer in the documentation
13: * and/or other materials provided with the distribution.
14: * * Neither the name of the axTLS project nor the names of its contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
22: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29: */
30:
31: /**
32: * Process PKCS#8/PKCS#12 keys.
33: *
34: * The decoding of a PKCS#12 key is fairly specific - this code was tested on a
35: * key generated with:
36: *
37: * openssl pkcs12 -export -in axTLS.x509_1024.pem -inkey axTLS.key_1024.pem
38: * -keypbe PBE-SHA1-RC4-128 -certpbe PBE-SHA1-RC4-128
39: * -name "p12_withoutCA" -out axTLS.withoutCA.p12 -password pass:abcd
40: *
41: * or with a certificate chain:
42: *
43: * openssl pkcs12 -export -in axTLS.x509_1024.pem -inkey axTLS.key_1024.pem
44: * -certfile axTLS.ca_x509.pem -keypbe PBE-SHA1-RC4-128 -certpbe
45: * PBE-SHA1-RC4-128 -name "p12_withCA" -out axTLS.withCA.p12 -password pass:abcd
46: *
47: * Note that the PBE has to be specified with PBE-SHA1-RC4-128. The
48: * private/public keys/certs have to use RSA encryption. Both the integrity
49: * and privacy passwords are the same.
50: *
51: * The PKCS#8 files were generated with something like:
52: *
53: * PEM format:
54: * openssl pkcs8 -in axTLS.key_512.pem -passout pass:abcd -topk8 -v1
55: * PBE-SHA1-RC4-128 -out axTLS.encrypted_pem.p8
56: *
57: * DER format:
58: * openssl pkcs8 -in axTLS.key_512.pem -passout pass:abcd -topk8 -outform DER
59: * -v1 PBE-SHA1-RC4-128 -out axTLS.encrypted.p8
60: */
61:
62: #include <stdlib.h>
63: #include <string.h>
64: #include <stdio.h>
65: #include "os_port.h"
66: #include "ssl.h"
67:
68: /* all commented out if not used */
69: #ifdef CONFIG_SSL_USE_PKCS12
70:
71: #define BLOCK_SIZE 64
72: #define PKCS12_KEY_ID 1
73: #define PKCS12_IV_ID 2
74: #define PKCS12_MAC_ID 3
75:
76: static char *make_uni_pass(const char *password, int *uni_pass_len);
77: static int p8_decrypt(const char *uni_pass, int uni_pass_len,
78: const uint8_t *salt, int iter,
79: uint8_t *priv_key, int priv_key_len, int id);
80: static int p8_add_key(SSL_CTX *ssl_ctx, uint8_t *priv_key);
81: static int get_pbe_params(uint8_t *buf, int *offset,
82: const uint8_t **salt, int *iterations);
83:
84: /*
85: * Take a raw pkcs8 block and then decrypt it and turn it into a normal key.
86: */
87: int pkcs8_decode(SSL_CTX *ssl_ctx, SSLObjLoader *ssl_obj, const char *password)
88: {
89: uint8_t *buf = ssl_obj->buf;
90: int len, offset = 0;
91: int iterations;
92: int ret = SSL_NOT_OK;
93: uint8_t *version = NULL;
94: const uint8_t *salt;
95: uint8_t *priv_key;
96: int uni_pass_len;
97: char *uni_pass = make_uni_pass(password, &uni_pass_len);
98:
99: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0)
100: {
101: #ifdef CONFIG_SSL_FULL_MODE
102: printf("Error: Invalid p8 ASN.1 file\n");
103: #endif
104: goto error;
105: }
106:
107: /* unencrypted key? */
108: if (asn1_get_int(buf, &offset, &version) > 0 && *version == 0)
109: {
110: ret = p8_add_key(ssl_ctx, buf);
111: goto error;
112: }
113:
114: if (get_pbe_params(buf, &offset, &salt, &iterations) < 0)
115: goto error;
116:
117: if ((len = asn1_next_obj(buf, &offset, ASN1_OCTET_STRING)) < 0)
118: goto error;
119:
120: priv_key = &buf[offset];
121:
122: p8_decrypt(uni_pass, uni_pass_len, salt,
123: iterations, priv_key, len, PKCS12_KEY_ID);
124: ret = p8_add_key(ssl_ctx, priv_key);
125:
126: error:
127: free(version);
128: free(uni_pass);
129: return ret;
130: }
131:
132: /*
133: * Take the unencrypted pkcs8 and turn it into a private key
134: */
135: static int p8_add_key(SSL_CTX *ssl_ctx, uint8_t *priv_key)
136: {
137: uint8_t *buf = priv_key;
138: int len, offset = 0;
139: int ret = SSL_NOT_OK;
140:
141: /* Skip the preamble and go straight to the private key.
142: We only support rsaEncryption (1.2.840.113549.1.1.1) */
143: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
144: asn1_skip_obj(buf, &offset, ASN1_INTEGER) < 0 ||
145: asn1_skip_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
146: (len = asn1_next_obj(buf, &offset, ASN1_OCTET_STRING)) < 0)
147: goto error;
148:
149: ret = asn1_get_private_key(&buf[offset], len, &ssl_ctx->rsa_ctx);
150:
151: error:
152: return ret;
153: }
154:
155: /*
156: * Create the unicode password
157: */
158: static char *make_uni_pass(const char *password, int *uni_pass_len)
159: {
160: int pass_len = 0, i;
161: char *uni_pass;
162:
163: if (password == NULL)
164: {
165: password = "";
166: }
167:
168: uni_pass = (char *)malloc((strlen(password)+1)*2);
169:
170: /* modify the password into a unicode version */
171: for (i = 0; i < (int)strlen(password); i++)
172: {
173: uni_pass[pass_len++] = 0;
174: uni_pass[pass_len++] = password[i];
175: }
176:
177: uni_pass[pass_len++] = 0; /* null terminate */
178: uni_pass[pass_len++] = 0;
179: *uni_pass_len = pass_len;
180: return uni_pass;
181: }
182:
183: /*
184: * Decrypt a pkcs8 block.
185: */
186: static int p8_decrypt(const char *uni_pass, int uni_pass_len,
187: const uint8_t *salt, int iter,
188: uint8_t *priv_key, int priv_key_len, int id)
189: {
190: uint8_t p[BLOCK_SIZE*2];
191: uint8_t d[BLOCK_SIZE];
192: uint8_t Ai[SHA1_SIZE];
193: SHA1_CTX sha_ctx;
194: RC4_CTX rc4_ctx;
195: int i;
196:
197: for (i = 0; i < BLOCK_SIZE; i++)
198: {
199: p[i] = salt[i % SALT_SIZE];
200: p[BLOCK_SIZE+i] = uni_pass[i % uni_pass_len];
201: d[i] = id;
202: }
203:
204: /* get the key - no IV since we are using RC4 */
205: SHA1_Init(&sha_ctx);
206: SHA1_Update(&sha_ctx, d, sizeof(d));
207: SHA1_Update(&sha_ctx, p, sizeof(p));
208: SHA1_Final(Ai, &sha_ctx);
209:
210: for (i = 1; i < iter; i++)
211: {
212: SHA1_Init(&sha_ctx);
213: SHA1_Update(&sha_ctx, Ai, SHA1_SIZE);
214: SHA1_Final(Ai, &sha_ctx);
215: }
216:
217: /* do the decryption */
218: if (id == PKCS12_KEY_ID)
219: {
220: RC4_setup(&rc4_ctx, Ai, 16);
221: RC4_crypt(&rc4_ctx, priv_key, priv_key, priv_key_len);
222: }
223: else /* MAC */
224: memcpy(priv_key, Ai, SHA1_SIZE);
225:
226: return 0;
227: }
228:
229: /*
230: * Take a raw pkcs12 block and the decrypt it and turn it into a certificate(s)
231: * and keys.
232: */
233: int pkcs12_decode(SSL_CTX *ssl_ctx, SSLObjLoader *ssl_obj, const char *password)
234: {
235: uint8_t *buf = ssl_obj->buf;
236: int len, iterations, auth_safes_start,
237: auth_safes_end, auth_safes_len, key_offset, offset = 0;
238: int all_certs = 0;
239: uint8_t *version = NULL, *auth_safes = NULL, *cert, *orig_mac;
240: uint8_t key[SHA1_SIZE];
241: uint8_t mac[SHA1_SIZE];
242: const uint8_t *salt;
243: int uni_pass_len, ret = SSL_OK;
244: char *uni_pass = make_uni_pass(password, &uni_pass_len);
245: static const uint8_t pkcs_data[] = /* pkc7 data */
246: { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01 };
247: static const uint8_t pkcs_encrypted[] = /* pkc7 encrypted */
248: { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x06 };
249: static const uint8_t pkcs8_key_bag[] = /* 1.2.840.113549.1.12.10.1.2 */
250: { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x0c, 0x0a, 0x01, 0x02 };
251:
252: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0)
253: {
254: #ifdef CONFIG_SSL_FULL_MODE
255: printf("Error: Invalid p12 ASN.1 file\n");
256: #endif
257: goto error;
258: }
259:
260: if (asn1_get_int(buf, &offset, &version) < 0 || *version != 3)
261: {
262: ret = SSL_ERROR_INVALID_VERSION;
263: goto error;
264: }
265:
266: /* remove all the boring pcks7 bits */
267: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
268: (len = asn1_next_obj(buf, &offset, ASN1_OID)) < 0 ||
269: len != sizeof(pkcs_data) ||
270: memcmp(&buf[offset], pkcs_data, sizeof(pkcs_data)))
271: goto error;
272:
273: offset += len;
274:
275: if (asn1_next_obj(buf, &offset, ASN1_EXPLICIT_TAG) < 0 ||
276: asn1_next_obj(buf, &offset, ASN1_OCTET_STRING) < 0)
277: goto error;
278:
279: /* work out the MAC start/end points (done on AuthSafes) */
280: auth_safes_start = offset;
281: auth_safes_end = offset;
282: if (asn1_skip_obj(buf, &auth_safes_end, ASN1_SEQUENCE) < 0)
283: goto error;
284:
285: auth_safes_len = auth_safes_end - auth_safes_start;
286: auth_safes = malloc(auth_safes_len);
287:
288: memcpy(auth_safes, &buf[auth_safes_start], auth_safes_len);
289:
290: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
291: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
292: (len = asn1_next_obj(buf, &offset, ASN1_OID)) < 0 ||
293: (len != sizeof(pkcs_encrypted) ||
294: memcmp(&buf[offset], pkcs_encrypted, sizeof(pkcs_encrypted))))
295: goto error;
296:
297: offset += len;
298:
299: if (asn1_next_obj(buf, &offset, ASN1_EXPLICIT_TAG) < 0 ||
300: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
301: asn1_skip_obj(buf, &offset, ASN1_INTEGER) < 0 ||
302: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
303: (len = asn1_next_obj(buf, &offset, ASN1_OID)) < 0 ||
304: len != sizeof(pkcs_data) ||
305: memcmp(&buf[offset], pkcs_data, sizeof(pkcs_data)))
306: goto error;
307:
308: offset += len;
309:
310: /* work out the salt for the certificate */
311: if (get_pbe_params(buf, &offset, &salt, &iterations) < 0 ||
312: (len = asn1_next_obj(buf, &offset, ASN1_IMPLICIT_TAG)) < 0)
313: goto error;
314:
315: /* decrypt the certificate */
316: cert = &buf[offset];
317: if ((ret = p8_decrypt(uni_pass, uni_pass_len, salt, iterations, cert,
318: len, PKCS12_KEY_ID)) < 0)
319: goto error;
320:
321: offset += len;
322:
323: /* load the certificate */
324: key_offset = 0;
325: all_certs = asn1_next_obj(cert, &key_offset, ASN1_SEQUENCE);
326:
327: /* keep going until all certs are loaded */
328: while (key_offset < all_certs)
329: {
330: int cert_offset = key_offset;
331:
332: if (asn1_skip_obj(cert, &cert_offset, ASN1_SEQUENCE) < 0 ||
333: asn1_next_obj(cert, &key_offset, ASN1_SEQUENCE) < 0 ||
334: asn1_skip_obj(cert, &key_offset, ASN1_OID) < 0 ||
335: asn1_next_obj(cert, &key_offset, ASN1_EXPLICIT_TAG) < 0 ||
336: asn1_next_obj(cert, &key_offset, ASN1_SEQUENCE) < 0 ||
337: asn1_skip_obj(cert, &key_offset, ASN1_OID) < 0 ||
338: asn1_next_obj(cert, &key_offset, ASN1_EXPLICIT_TAG) < 0 ||
339: (len = asn1_next_obj(cert, &key_offset, ASN1_OCTET_STRING)) < 0)
340: goto error;
341:
342: if ((ret = add_cert(ssl_ctx, &cert[key_offset], len)) < 0)
343: goto error;
344:
345: key_offset = cert_offset;
346: }
347:
348: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
349: (len = asn1_next_obj(buf, &offset, ASN1_OID)) < 0 ||
350: len != sizeof(pkcs_data) ||
351: memcmp(&buf[offset], pkcs_data, sizeof(pkcs_data)))
352: goto error;
353:
354: offset += len;
355:
356: if (asn1_next_obj(buf, &offset, ASN1_EXPLICIT_TAG) < 0 ||
357: asn1_next_obj(buf, &offset, ASN1_OCTET_STRING) < 0 ||
358: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
359: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
360: (len = asn1_next_obj(buf, &offset, ASN1_OID)) < 0 ||
361: (len != sizeof(pkcs8_key_bag)) ||
362: memcmp(&buf[offset], pkcs8_key_bag, sizeof(pkcs8_key_bag)))
363: goto error;
364:
365: offset += len;
366:
367: /* work out the salt for the private key */
368: if (asn1_next_obj(buf, &offset, ASN1_EXPLICIT_TAG) < 0 ||
369: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
370: get_pbe_params(buf, &offset, &salt, &iterations) < 0 ||
371: (len = asn1_next_obj(buf, &offset, ASN1_OCTET_STRING)) < 0)
372: goto error;
373:
374: /* decrypt the private key */
375: cert = &buf[offset];
376: if ((ret = p8_decrypt(uni_pass, uni_pass_len, salt, iterations, cert,
377: len, PKCS12_KEY_ID)) < 0)
378: goto error;
379:
380: offset += len;
381:
382: /* load the private key */
383: if ((ret = p8_add_key(ssl_ctx, cert)) < 0)
384: goto error;
385:
386: /* miss out on friendly name, local key id etc */
387: if (asn1_skip_obj(buf, &offset, ASN1_SET) < 0)
388: goto error;
389:
390: /* work out the MAC */
391: if (asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
392: asn1_next_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
393: asn1_skip_obj(buf, &offset, ASN1_SEQUENCE) < 0 ||
394: (len = asn1_next_obj(buf, &offset, ASN1_OCTET_STRING)) < 0 ||
395: len != SHA1_SIZE)
396: goto error;
397:
398: orig_mac = &buf[offset];
399: offset += len;
400:
401: /* get the salt */
402: if ((len = asn1_next_obj(buf, &offset, ASN1_OCTET_STRING)) < 0 || len != 8)
403: goto error;
404:
405: salt = &buf[offset];
406:
407: /* work out what the mac should be */
408: if ((ret = p8_decrypt(uni_pass, uni_pass_len, salt, iterations,
409: key, SHA1_SIZE, PKCS12_MAC_ID)) < 0)
410: goto error;
411:
412: hmac_sha1(auth_safes, auth_safes_len, key, SHA1_SIZE, mac);
413:
414: if (memcmp(mac, orig_mac, SHA1_SIZE))
415: {
416: ret = SSL_ERROR_INVALID_HMAC;
417: goto error;
418: }
419:
420: error:
421: free(version);
422: free(uni_pass);
423: free(auth_safes);
424: return ret;
425: }
426:
427: /*
428: * Retrieve the salt/iteration details from a PBE block.
429: */
430: static int get_pbe_params(uint8_t *buf, int *offset,
431: const uint8_t **salt, int *iterations)
432: {
433: static const uint8_t pbeSH1RC4[] = /* pbeWithSHAAnd128BitRC4 */
434: { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x0c, 0x01, 0x01 };
435:
436: int i, len;
437: uint8_t *iter = NULL;
438: int error_code = SSL_ERROR_NOT_SUPPORTED;
439:
440: /* Get the PBE type */
441: if (asn1_next_obj(buf, offset, ASN1_SEQUENCE) < 0 ||
442: (len = asn1_next_obj(buf, offset, ASN1_OID)) < 0)
443: goto error;
444:
445: /* we expect pbeWithSHAAnd128BitRC4 (1.2.840.113549.1.12.1.1)
446: which is the only algorithm we support */
447: if (len != sizeof(pbeSH1RC4) ||
448: memcmp(&buf[*offset], pbeSH1RC4, sizeof(pbeSH1RC4)))
449: {
450: #ifdef CONFIG_SSL_FULL_MODE
451: printf("Error: pkcs8/pkcs12 must use \"PBE-SHA1-RC4-128\"\n");
452: #endif
453: goto error;
454: }
455:
456: *offset += len;
457:
458: if (asn1_next_obj(buf, offset, ASN1_SEQUENCE) < 0 ||
459: (len = asn1_next_obj(buf, offset, ASN1_OCTET_STRING)) < 0 ||
460: len != 8)
461: goto error;
462:
463: *salt = &buf[*offset];
464: *offset += len;
465:
466: if ((len = asn1_get_int(buf, offset, &iter)) < 0)
467: goto error;
468:
469: *iterations = 0;
470: for (i = 0; i < len; i++)
471: {
472: (*iterations) <<= 8;
473: (*iterations) += iter[i];
474: }
475:
476: free(iter);
477: error_code = SSL_OK; /* got here - we are ok */
478:
479: error:
480: return error_code;
481: }
482:
483: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to p12.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / axTLS / ssl