apps/pkcs8.c

   1 /*
   2  * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include "apps.h"
  14 #include "progs.h"
  15 #include <openssl/pem.h>
  16 #include <openssl/err.h>
  17 #include <openssl/evp.h>
  18 #include <openssl/pkcs12.h>
  19
  20 typedef enum OPTION_choice {
  21     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
  22     OPT_INFORM, OPT_OUTFORM, OPT_ENGINE, OPT_IN, OPT_OUT,
  23     OPT_TOPK8, OPT_NOITER, OPT_NOCRYPT,
  24 #ifndef OPENSSL_NO_SCRYPT
  25     OPT_SCRYPT, OPT_SCRYPT_N, OPT_SCRYPT_R, OPT_SCRYPT_P,
  26 #endif
  27     OPT_V2, OPT_V1, OPT_V2PRF, OPT_ITER, OPT_PASSIN, OPT_PASSOUT,
  28     OPT_TRADITIONAL,
  29     OPT_R_ENUM, OPT_PROV_ENUM
  30 } OPTION_CHOICE;
  31
  32 const OPTIONS pkcs8_options[] = {
  33     OPT_SECTION("General"),
  34     {"help", OPT_HELP, '-', "Display this summary"},
  35 #ifndef OPENSSL_NO_ENGINE
  36     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
  37 #endif
  38     {"v1", OPT_V1, 's', "Use PKCS#5 v1.5 and cipher"},
  39     {"v2", OPT_V2, 's', "Use PKCS#5 v2.0 and cipher"},
  40     {"v2prf", OPT_V2PRF, 's', "Set the PRF algorithm to use with PKCS#5 v2.0"},
  41
  42     OPT_SECTION("Input"),
  43     {"in", OPT_IN, '<', "Input file"},
  44     {"inform", OPT_INFORM, 'F', "Input format (DER or PEM)"},
  45     {"passin", OPT_PASSIN, 's', "Input file pass phrase source"},
  46     {"nocrypt", OPT_NOCRYPT, '-', "Use or expect unencrypted private key"},
  47
  48     OPT_SECTION("Output"),
  49     {"out", OPT_OUT, '>', "Output file"},
  50     {"outform", OPT_OUTFORM, 'F', "Output format (DER or PEM)"},
  51     {"topk8", OPT_TOPK8, '-', "Output PKCS8 file"},
  52     {"passout", OPT_PASSOUT, 's', "Output file pass phrase source"},
  53     {"traditional", OPT_TRADITIONAL, '-', "use traditional format private key"},
  54     {"iter", OPT_ITER, 'p', "Specify the iteration count"},
  55     {"noiter", OPT_NOITER, '-', "Use 1 as iteration count"},
  56
  57 #ifndef OPENSSL_NO_SCRYPT
  58     OPT_SECTION("Scrypt"),
  59     {"scrypt", OPT_SCRYPT, '-', "Use scrypt algorithm"},
  60     {"scrypt_N", OPT_SCRYPT_N, 's', "Set scrypt N parameter"},
  61     {"scrypt_r", OPT_SCRYPT_R, 's', "Set scrypt r parameter"},
  62     {"scrypt_p", OPT_SCRYPT_P, 's', "Set scrypt p parameter"},
  63 #endif
  64
  65     OPT_R_OPTIONS,
  66     OPT_PROV_OPTIONS,
  67     {NULL}
  68 };
  69
  70 int pkcs8_main(int argc, char **argv)
  71 {
  72     BIO *in = NULL, *out = NULL;
  73     ENGINE *e = NULL;
  74     EVP_PKEY *pkey = NULL;
  75     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
  76     X509_SIG *p8 = NULL;
  77     const EVP_CIPHER *cipher = NULL;
  78     char *infile = NULL, *outfile = NULL;
  79     char *passinarg = NULL, *passoutarg = NULL, *prog;
  80 #ifndef OPENSSL_NO_UI_CONSOLE
  81     char pass[APP_PASS_LEN];
  82 #endif
  83     char *passin = NULL, *passout = NULL, *p8pass = NULL;
  84     OPTION_CHOICE o;
  85     int nocrypt = 0, ret = 1, iter = PKCS12_DEFAULT_ITER;
  86     int informat = FORMAT_PEM, outformat = FORMAT_PEM, topk8 = 0, pbe_nid = -1;
  87     int private = 0, traditional = 0;
  88 #ifndef OPENSSL_NO_SCRYPT
  89     long scrypt_N = 0, scrypt_r = 0, scrypt_p = 0;
  90 #endif
  91
  92     prog = opt_init(argc, argv, pkcs8_options);
  93     while ((o = opt_next()) != OPT_EOF) {
  94         switch (o) {
  95         case OPT_EOF:
  96         case OPT_ERR:
  97  opthelp:
  98             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
  99             goto end;
 100         case OPT_HELP:
 101             opt_help(pkcs8_options);
 102             ret = 0;
 103             goto end;
 104         case OPT_INFORM:
 105             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
 106                 goto opthelp;
 107             break;
 108         case OPT_IN:
 109             infile = opt_arg();
 110             break;
 111         case OPT_OUTFORM:
 112             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
 113                 goto opthelp;
 114             break;
 115         case OPT_OUT:
 116             outfile = opt_arg();
 117             break;
 118         case OPT_TOPK8:
 119             topk8 = 1;
 120             break;
 121         case OPT_NOITER:
 122             iter = 1;
 123             break;
 124         case OPT_NOCRYPT:
 125             nocrypt = 1;
 126             break;
 127         case OPT_R_CASES:
 128             if (!opt_rand(o))
 129                 goto end;
 130             break;
 131         case OPT_PROV_CASES:
 132             if (!opt_provider(o))
 133                 goto end;
 134             break;
 135         case OPT_TRADITIONAL:
 136             traditional = 1;
 137             break;
 138         case OPT_V2:
 139             if (!opt_cipher(opt_arg(), &cipher))
 140                 goto opthelp;
 141             break;
 142         case OPT_V1:
 143             pbe_nid = OBJ_txt2nid(opt_arg());
 144             if (pbe_nid == NID_undef) {
 145                 BIO_printf(bio_err,
 146                            "%s: Unknown PBE algorithm %s\n", prog, opt_arg());
 147                 goto opthelp;
 148             }
 149             break;
 150         case OPT_V2PRF:
 151             pbe_nid = OBJ_txt2nid(opt_arg());
 152             if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, pbe_nid, NULL, NULL, 0)) {
 153                 BIO_printf(bio_err,
 154                            "%s: Unknown PRF algorithm %s\n", prog, opt_arg());
 155                 goto opthelp;
 156             }
 157             if (cipher == NULL)
 158                 cipher = EVP_aes_256_cbc();
 159             break;
 160         case OPT_ITER:
 161             if (!opt_int(opt_arg(), &iter))
 162                 goto opthelp;
 163             break;
 164         case OPT_PASSIN:
 165             passinarg = opt_arg();
 166             break;
 167         case OPT_PASSOUT:
 168             passoutarg = opt_arg();
 169             break;
 170         case OPT_ENGINE:
 171             e = setup_engine(opt_arg(), 0);
 172             break;
 173 #ifndef OPENSSL_NO_SCRYPT
 174         case OPT_SCRYPT:
 175             scrypt_N = 16384;
 176             scrypt_r = 8;
 177             scrypt_p = 1;
 178             if (cipher == NULL)
 179                 cipher = EVP_aes_256_cbc();
 180             break;
 181         case OPT_SCRYPT_N:
 182             if (!opt_long(opt_arg(), &scrypt_N) || scrypt_N <= 0)
 183                 goto opthelp;
 184             break;
 185         case OPT_SCRYPT_R:
 186             if (!opt_long(opt_arg(), &scrypt_r) || scrypt_r <= 0)
 187                 goto opthelp;
 188             break;
 189         case OPT_SCRYPT_P:
 190             if (!opt_long(opt_arg(), &scrypt_p) || scrypt_p <= 0)
 191                 goto opthelp;
 192             break;
 193 #endif
 194         }
 195     }
 196     argc = opt_num_rest();
 197     if (argc != 0)
 198         goto opthelp;
 199
 200     private = 1;
 201
 202     if (!app_passwd(passinarg, passoutarg, &passin, &passout)) {
 203         BIO_printf(bio_err, "Error getting passwords\n");
 204         goto end;
 205     }
 206
 207     if ((pbe_nid == -1) && cipher == NULL)
 208         cipher = EVP_aes_256_cbc();
 209
 210     in = bio_open_default(infile, 'r', informat);
 211     if (in == NULL)
 212         goto end;
 213     out = bio_open_owner(outfile, outformat, private);
 214     if (out == NULL)
 215         goto end;
 216
 217     if (topk8) {
 218         pkey = load_key(infile, informat, 1, passin, e, "key");
 219         if (pkey == NULL)
 220             goto end;
 221         if ((p8inf = EVP_PKEY2PKCS8(pkey)) == NULL) {
 222             BIO_printf(bio_err, "Error converting key\n");
 223             ERR_print_errors(bio_err);
 224             goto end;
 225         }
 226         if (nocrypt) {
 227             assert(private);
 228             if (outformat == FORMAT_PEM) {
 229                 PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8inf);
 230             } else if (outformat == FORMAT_ASN1) {
 231                 i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8inf);
 232             } else {
 233                 BIO_printf(bio_err, "Bad format specified for key\n");
 234                 goto end;
 235             }
 236         } else {
 237             X509_ALGOR *pbe;
 238             if (cipher) {
 239 #ifndef OPENSSL_NO_SCRYPT
 240                 if (scrypt_N && scrypt_r && scrypt_p)
 241                     pbe = PKCS5_pbe2_set_scrypt(cipher, NULL, 0, NULL,
 242                                                 scrypt_N, scrypt_r, scrypt_p);
 243                 else
 244 #endif
 245                     pbe = PKCS5_pbe2_set_iv(cipher, iter, NULL, 0, NULL,
 246                                             pbe_nid);
 247             } else {
 248                 pbe = PKCS5_pbe_set(pbe_nid, iter, NULL, 0);
 249             }
 250             if (pbe == NULL) {
 251                 BIO_printf(bio_err, "Error setting PBE algorithm\n");
 252                 ERR_print_errors(bio_err);
 253                 goto end;
 254             }
 255             if (passout != NULL) {
 256                 p8pass = passout;
 257             } else if (1) {
 258                 /* To avoid bit rot */
 259 #ifndef OPENSSL_NO_UI_CONSOLE
 260                 p8pass = pass;
 261                 if (EVP_read_pw_string
 262                     (pass, sizeof(pass), "Enter Encryption Password:", 1)) {
 263                     X509_ALGOR_free(pbe);
 264                     goto end;
 265                 }
 266             } else {
 267 #endif
 268                 BIO_printf(bio_err, "Password required\n");
 269                 goto end;
 270             }
 271             p8 = PKCS8_set0_pbe(p8pass, strlen(p8pass), p8inf, pbe);
 272             if (p8 == NULL) {
 273                 X509_ALGOR_free(pbe);
 274                 BIO_printf(bio_err, "Error encrypting key\n");
 275                 ERR_print_errors(bio_err);
 276                 goto end;
 277             }
 278             assert(private);
 279             if (outformat == FORMAT_PEM)
 280                 PEM_write_bio_PKCS8(out, p8);
 281             else if (outformat == FORMAT_ASN1)
 282                 i2d_PKCS8_bio(out, p8);
 283             else {
 284                 BIO_printf(bio_err, "Bad format specified for key\n");
 285                 goto end;
 286             }
 287         }
 288
 289         ret = 0;
 290         goto end;
 291     }
 292
 293     if (nocrypt) {
 294         if (informat == FORMAT_PEM) {
 295             p8inf = PEM_read_bio_PKCS8_PRIV_KEY_INFO(in, NULL, NULL, NULL);
 296         } else if (informat == FORMAT_ASN1) {
 297             p8inf = d2i_PKCS8_PRIV_KEY_INFO_bio(in, NULL);
 298         } else {
 299             BIO_printf(bio_err, "Bad format specified for key\n");
 300             goto end;
 301         }
 302     } else {
 303         if (informat == FORMAT_PEM) {
 304             p8 = PEM_read_bio_PKCS8(in, NULL, NULL, NULL);
 305         } else if (informat == FORMAT_ASN1) {
 306             p8 = d2i_PKCS8_bio(in, NULL);
 307         } else {
 308             BIO_printf(bio_err, "Bad format specified for key\n");
 309             goto end;
 310         }
 311
 312         if (p8 == NULL) {
 313             BIO_printf(bio_err, "Error reading key\n");
 314             ERR_print_errors(bio_err);
 315             goto end;
 316         }
 317         if (passin != NULL) {
 318             p8pass = passin;
 319         } else if (1) {
 320 #ifndef OPENSSL_NO_UI_CONSOLE
 321             p8pass = pass;
 322             if (EVP_read_pw_string(pass, sizeof(pass), "Enter Password:", 0)) {
 323                 BIO_printf(bio_err, "Can't read Password\n");
 324                 goto end;
 325             }
 326         } else {
 327 #endif
 328             BIO_printf(bio_err, "Password required\n");
 329             goto end;
 330         }
 331         p8inf = PKCS8_decrypt(p8, p8pass, strlen(p8pass));
 332     }
 333
 334     if (p8inf == NULL) {
 335         BIO_printf(bio_err, "Error decrypting key\n");
 336         ERR_print_errors(bio_err);
 337         goto end;
 338     }
 339
 340     if ((pkey = EVP_PKCS82PKEY(p8inf)) == NULL) {
 341         BIO_printf(bio_err, "Error converting key\n");
 342         ERR_print_errors(bio_err);
 343         goto end;
 344     }
 345
 346     assert(private);
 347     if (outformat == FORMAT_PEM) {
 348         if (traditional)
 349             PEM_write_bio_PrivateKey_traditional(out, pkey, NULL, NULL, 0,
 350                                                  NULL, passout);
 351         else
 352             PEM_write_bio_PrivateKey(out, pkey, NULL, NULL, 0, NULL, passout);
 353     } else if (outformat == FORMAT_ASN1) {
 354         i2d_PrivateKey_bio(out, pkey);
 355     } else {
 356         BIO_printf(bio_err, "Bad format specified for key\n");
 357         goto end;
 358     }
 359     ret = 0;
 360
 361  end:
 362     X509_SIG_free(p8);
 363     PKCS8_PRIV_KEY_INFO_free(p8inf);
 364     EVP_PKEY_free(pkey);
 365     release_engine(e);
 366     BIO_free_all(out);
 367     BIO_free(in);
 368     OPENSSL_free(passin);
 369     OPENSSL_free(passout);
 370
 371     return ret;
 372 }