Some whitespace fixes.
[strongswan.git] / src / libstrongswan / plugins / openssl / openssl_rsa_private_key.c
1 /*
2 * Copyright (C) 2009 Martin Willi
3 * Copyright (C) 2008 Tobias Brunner
4 * Hochschule fuer Technik Rapperswil
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * for more details.
15 */
16
17 #include "openssl_rsa_private_key.h"
18 #include "openssl_rsa_public_key.h"
19
20 #include <debug.h>
21
22 #include <openssl/evp.h>
23 #include <openssl/rsa.h>
24 #include <openssl/engine.h>
25
26 /**
27 * Public exponent to use for key generation.
28 */
29 #define PUBLIC_EXPONENT 0x10001
30
31 typedef struct private_openssl_rsa_private_key_t private_openssl_rsa_private_key_t;
32
33 /**
34 * Private data of a openssl_rsa_private_key_t object.
35 */
36 struct private_openssl_rsa_private_key_t {
37 /**
38 * Public interface for this signer.
39 */
40 openssl_rsa_private_key_t public;
41
42 /**
43 * RSA object from OpenSSL
44 */
45 RSA *rsa;
46
47 /**
48 * TRUE if the key is from an OpenSSL ENGINE and might not be readable
49 */
50 bool engine;
51
52 /**
53 * reference count
54 */
55 refcount_t ref;
56 };
57
58 /* implemented in rsa public key */
59 bool openssl_rsa_fingerprint(RSA *rsa, key_encoding_type_t type, chunk_t *fp);
60
61 /**
62 * Build an EMPSA PKCS1 signature described in PKCS#1
63 */
64 static bool build_emsa_pkcs1_signature(private_openssl_rsa_private_key_t *this,
65 int type, chunk_t data, chunk_t *sig)
66 {
67 bool success = FALSE;
68
69 *sig = chunk_alloc(RSA_size(this->rsa));
70
71 if (type == NID_undef)
72 {
73 if (RSA_private_encrypt(data.len, data.ptr, sig->ptr, this->rsa,
74 RSA_PKCS1_PADDING) == sig->len)
75 {
76 success = TRUE;
77 }
78 }
79 else
80 {
81 EVP_MD_CTX *ctx;
82 EVP_PKEY *key;
83 const EVP_MD *hasher;
84 u_int len;
85
86 hasher = EVP_get_digestbynid(type);
87 if (!hasher)
88 {
89 return FALSE;
90 }
91
92 ctx = EVP_MD_CTX_create();
93 key = EVP_PKEY_new();
94 if (!ctx || !key)
95 {
96 goto error;
97 }
98 if (!EVP_PKEY_set1_RSA(key, this->rsa))
99 {
100 goto error;
101 }
102 if (!EVP_SignInit_ex(ctx, hasher, NULL))
103 {
104 goto error;
105 }
106 if (!EVP_SignUpdate(ctx, data.ptr, data.len))
107 {
108 goto error;
109 }
110 if (EVP_SignFinal(ctx, sig->ptr, &len, key))
111 {
112 success = TRUE;
113 }
114
115 error:
116 if (key)
117 {
118 EVP_PKEY_free(key);
119 }
120 if (ctx)
121 {
122 EVP_MD_CTX_destroy(ctx);
123 }
124 }
125 if (!success)
126 {
127 free(sig->ptr);
128 }
129 return success;
130 }
131
132 /**
133 * Implementation of openssl_rsa_private_key.get_type.
134 */
135 static key_type_t get_type(private_openssl_rsa_private_key_t *this)
136 {
137 return KEY_RSA;
138 }
139
140 /**
141 * Implementation of openssl_rsa_private_key.sign.
142 */
143 static bool sign(private_openssl_rsa_private_key_t *this, signature_scheme_t scheme,
144 chunk_t data, chunk_t *signature)
145 {
146 switch (scheme)
147 {
148 case SIGN_RSA_EMSA_PKCS1_NULL:
149 return build_emsa_pkcs1_signature(this, NID_undef, data, signature);
150 case SIGN_RSA_EMSA_PKCS1_SHA1:
151 return build_emsa_pkcs1_signature(this, NID_sha1, data, signature);
152 case SIGN_RSA_EMSA_PKCS1_SHA224:
153 return build_emsa_pkcs1_signature(this, NID_sha224, data, signature);
154 case SIGN_RSA_EMSA_PKCS1_SHA256:
155 return build_emsa_pkcs1_signature(this, NID_sha256, data, signature);
156 case SIGN_RSA_EMSA_PKCS1_SHA384:
157 return build_emsa_pkcs1_signature(this, NID_sha384, data, signature);
158 case SIGN_RSA_EMSA_PKCS1_SHA512:
159 return build_emsa_pkcs1_signature(this, NID_sha512, data, signature);
160 case SIGN_RSA_EMSA_PKCS1_MD5:
161 return build_emsa_pkcs1_signature(this, NID_md5, data, signature);
162 default:
163 DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
164 signature_scheme_names, scheme);
165 return FALSE;
166 }
167 }
168
169 /**
170 * Implementation of openssl_rsa_private_key.decrypt.
171 */
172 static bool decrypt(private_openssl_rsa_private_key_t *this,
173 chunk_t crypto, chunk_t *plain)
174 {
175 DBG1(DBG_LIB, "RSA private key decryption not implemented");
176 return FALSE;
177 }
178
179 /**
180 * Implementation of openssl_rsa_private_key.get_keysize.
181 */
182 static size_t get_keysize(private_openssl_rsa_private_key_t *this)
183 {
184 return RSA_size(this->rsa);
185 }
186
187 /**
188 * Implementation of openssl_rsa_private_key.get_public_key.
189 */
190 static public_key_t* get_public_key(private_openssl_rsa_private_key_t *this)
191 {
192 chunk_t enc;
193 public_key_t *key;
194 u_char *p;
195
196 enc = chunk_alloc(i2d_RSAPublicKey(this->rsa, NULL));
197 p = enc.ptr;
198 i2d_RSAPublicKey(this->rsa, &p);
199 key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_RSA,
200 BUILD_BLOB_ASN1_DER, enc, BUILD_END);
201 free(enc.ptr);
202 return key;
203 }
204
205 /**
206 * Implementation of public_key_t.get_fingerprint.
207 */
208 static bool get_fingerprint(private_openssl_rsa_private_key_t *this,
209 key_encoding_type_t type, chunk_t *fingerprint)
210 {
211 return openssl_rsa_fingerprint(this->rsa, type, fingerprint);
212 }
213
214 /*
215 * Implementation of public_key_t.get_encoding.
216 */
217 static bool get_encoding(private_openssl_rsa_private_key_t *this,
218 key_encoding_type_t type, chunk_t *encoding)
219 {
220 u_char *p;
221
222 if (this->engine)
223 {
224 return FALSE;
225 }
226 switch (type)
227 {
228 case KEY_PRIV_ASN1_DER:
229 case KEY_PRIV_PEM:
230 {
231 bool success = TRUE;
232
233 *encoding = chunk_alloc(i2d_RSAPrivateKey(this->rsa, NULL));
234 p = encoding->ptr;
235 i2d_RSAPrivateKey(this->rsa, &p);
236
237 if (type == KEY_PRIV_PEM)
238 {
239 chunk_t asn1_encoding = *encoding;
240
241 success = lib->encoding->encode(lib->encoding, KEY_PRIV_PEM,
242 NULL, encoding, KEY_PART_RSA_PRIV_ASN1_DER,
243 asn1_encoding, KEY_PART_END);
244 chunk_clear(&asn1_encoding);
245 }
246 return success;
247 }
248 default:
249 return FALSE;
250 }
251 }
252
253 /**
254 * Implementation of openssl_rsa_private_key.get_ref.
255 */
256 static private_openssl_rsa_private_key_t* get_ref(private_openssl_rsa_private_key_t *this)
257 {
258 ref_get(&this->ref);
259 return this;
260 }
261
262 /**
263 * Implementation of openssl_rsa_private_key.destroy.
264 */
265 static void destroy(private_openssl_rsa_private_key_t *this)
266 {
267 if (ref_put(&this->ref))
268 {
269 if (this->rsa)
270 {
271 lib->encoding->clear_cache(lib->encoding, this->rsa);
272 RSA_free(this->rsa);
273 }
274 free(this);
275 }
276 }
277
278 /**
279 * Internal generic constructor
280 */
281 static private_openssl_rsa_private_key_t *create_empty(void)
282 {
283 private_openssl_rsa_private_key_t *this = malloc_thing(private_openssl_rsa_private_key_t);
284
285 this->public.interface.get_type = (key_type_t (*) (private_key_t*))get_type;
286 this->public.interface.sign = (bool (*) (private_key_t*, signature_scheme_t, chunk_t, chunk_t*))sign;
287 this->public.interface.decrypt = (bool (*) (private_key_t*, chunk_t, chunk_t*))decrypt;
288 this->public.interface.get_keysize = (size_t (*) (private_key_t*))get_keysize;
289 this->public.interface.get_public_key = (public_key_t* (*) (private_key_t*))get_public_key;
290 this->public.interface.equals = private_key_equals;
291 this->public.interface.belongs_to = private_key_belongs_to;
292 this->public.interface.get_fingerprint = (bool(*)(private_key_t*, key_encoding_type_t type, chunk_t *fp))get_fingerprint;
293 this->public.interface.has_fingerprint = (bool(*)(private_key_t*, chunk_t fp))private_key_has_fingerprint;
294 this->public.interface.get_encoding = (bool(*)(private_key_t*, key_encoding_type_t type, chunk_t *encoding))get_encoding;
295 this->public.interface.get_ref = (private_key_t* (*) (private_key_t*))get_ref;
296 this->public.interface.destroy = (void (*) (private_key_t*))destroy;
297
298 this->engine = FALSE;
299 this->ref = 1;
300
301 return this;
302 }
303
304 /**
305 * See header.
306 */
307 openssl_rsa_private_key_t *openssl_rsa_private_key_gen(key_type_t type,
308 va_list args)
309 {
310 private_openssl_rsa_private_key_t *this;
311 u_int key_size = 0;
312 RSA *rsa = NULL;
313 BIGNUM *e = NULL;
314
315 while (TRUE)
316 {
317 switch (va_arg(args, builder_part_t))
318 {
319 case BUILD_KEY_SIZE:
320 key_size = va_arg(args, u_int);
321 continue;
322 case BUILD_END:
323 break;
324 default:
325 return NULL;
326 }
327 break;
328 }
329 if (!key_size)
330 {
331 return NULL;
332 }
333 e = BN_new();
334 if (!e || !BN_set_word(e, PUBLIC_EXPONENT))
335 {
336 goto error;
337 }
338 rsa = RSA_new();
339 if (!rsa || !RSA_generate_key_ex(rsa, key_size, e, NULL))
340 {
341 goto error;
342 }
343 this = create_empty();
344 this->rsa = rsa;
345 BN_free(e);
346 return &this->public;
347
348 error:
349 if (e)
350 {
351 BN_free(e);
352 }
353 if (rsa)
354 {
355 RSA_free(rsa);
356 }
357 return NULL;
358 }
359
360 /**
361 * See header
362 */
363 openssl_rsa_private_key_t *openssl_rsa_private_key_load(key_type_t type,
364 va_list args)
365 {
366 private_openssl_rsa_private_key_t *this;
367 chunk_t blob, n, e, d, p, q, exp1, exp2, coeff;
368
369 blob = n = e = d = p = q = exp1 = exp2 = coeff = chunk_empty;
370 while (TRUE)
371 {
372 switch (va_arg(args, builder_part_t))
373 {
374 case BUILD_BLOB_ASN1_DER:
375 blob = va_arg(args, chunk_t);
376 continue;
377 case BUILD_RSA_MODULUS:
378 n = va_arg(args, chunk_t);
379 continue;
380 case BUILD_RSA_PUB_EXP:
381 e = va_arg(args, chunk_t);
382 continue;
383 case BUILD_RSA_PRIV_EXP:
384 d = va_arg(args, chunk_t);
385 continue;
386 case BUILD_RSA_PRIME1:
387 p = va_arg(args, chunk_t);
388 continue;
389 case BUILD_RSA_PRIME2:
390 q = va_arg(args, chunk_t);
391 continue;
392 case BUILD_RSA_EXP1:
393 exp1 = va_arg(args, chunk_t);
394 continue;
395 case BUILD_RSA_EXP2:
396 exp2 = va_arg(args, chunk_t);
397 continue;
398 case BUILD_RSA_COEFF:
399 coeff = va_arg(args, chunk_t);
400 continue;
401 case BUILD_END:
402 break;
403 default:
404 return NULL;
405 }
406 break;
407 }
408
409 this = create_empty();
410 if (blob.ptr)
411 {
412 this->rsa = d2i_RSAPrivateKey(NULL, (const u_char**)&blob.ptr, blob.len);
413 if (this->rsa && RSA_check_key(this->rsa))
414 {
415 return &this->public;
416 }
417 }
418 else if (n.ptr && e.ptr && d.ptr && p.ptr && q.ptr && coeff.ptr)
419 {
420 this->rsa = RSA_new();
421 this->rsa->n = BN_bin2bn((const u_char*)n.ptr, n.len, NULL);
422 this->rsa->e = BN_bin2bn((const u_char*)e.ptr, e.len, NULL);
423 this->rsa->d = BN_bin2bn((const u_char*)d.ptr, d.len, NULL);
424 this->rsa->p = BN_bin2bn((const u_char*)p.ptr, p.len, NULL);
425 this->rsa->q = BN_bin2bn((const u_char*)q.ptr, q.len, NULL);
426 if (exp1.ptr)
427 {
428 this->rsa->dmp1 = BN_bin2bn((const u_char*)exp1.ptr, exp1.len, NULL);
429 }
430 if (exp2.ptr)
431 {
432 this->rsa->dmq1 = BN_bin2bn((const u_char*)exp2.ptr, exp2.len, NULL);
433 }
434 this->rsa->iqmp = BN_bin2bn((const u_char*)coeff.ptr, coeff.len, NULL);
435 if (RSA_check_key(this->rsa))
436 {
437 return &this->public;
438 }
439 }
440 destroy(this);
441 return NULL;
442 }
443
444 /**
445 * See header.
446 */
447 openssl_rsa_private_key_t *openssl_rsa_private_key_connect(key_type_t type,
448 va_list args)
449 {
450 private_openssl_rsa_private_key_t *this;
451 char *keyid = NULL, *pin = NULL;
452 EVP_PKEY *key;
453 char *engine_id;
454 ENGINE *engine;
455
456 while (TRUE)
457 {
458 switch (va_arg(args, builder_part_t))
459 {
460 case BUILD_SMARTCARD_KEYID:
461 keyid = va_arg(args, char*);
462 continue;
463 case BUILD_SMARTCARD_PIN:
464 pin = va_arg(args, char*);
465 continue;
466 case BUILD_END:
467 break;
468 default:
469 return NULL;
470 }
471 break;
472 }
473 if (!keyid || !pin)
474 {
475 return NULL;
476 }
477
478 engine_id = lib->settings->get_str(lib->settings,
479 "library.plugins.openssl.engine_id", "pkcs11");
480 engine = ENGINE_by_id(engine_id);
481 if (!engine)
482 {
483 DBG1(DBG_LIB, "engine '%s' is not available", engine_id);
484 return NULL;
485 }
486 if (!ENGINE_init(engine))
487 {
488 DBG1(DBG_LIB, "failed to initialize engine '%s'", engine_id);
489 ENGINE_free(engine);
490 return NULL;
491 }
492 if (!ENGINE_ctrl_cmd_string(engine, "PIN", pin, 0))
493 {
494 DBG1(DBG_LIB, "failed to set PIN on engine '%s'", engine_id);
495 ENGINE_free(engine);
496 return NULL;
497 }
498
499 key = ENGINE_load_private_key(engine, keyid, NULL, NULL);
500 if (!key)
501 {
502 DBG1(DBG_LIB, "failed to load private key with ID '%s' from "
503 "engine '%s'", keyid, engine_id);
504 ENGINE_free(engine);
505 return NULL;
506 }
507 ENGINE_free(engine);
508
509 this = create_empty();
510 this->rsa = EVP_PKEY_get1_RSA(key);
511 this->engine = TRUE;
512
513 return &this->public;
514 }
515