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