1/* 2 * Copyright 1995-2022 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/* Necessary for legacy RSA public key export */ 11#define OPENSSL_SUPPRESS_DEPRECATED 12 13#include <openssl/opensslconf.h> 14 15#include <stdio.h> 16#include <stdlib.h> 17#include <string.h> 18#include <time.h> 19#include "apps.h" 20#include "progs.h" 21#include <openssl/bio.h> 22#include <openssl/err.h> 23#include <openssl/rsa.h> 24#include <openssl/evp.h> 25#include <openssl/x509.h> 26#include <openssl/pem.h> 27#include <openssl/bn.h> 28#include <openssl/encoder.h> 29 30/* 31 * This include is to get OSSL_KEYMGMT_SELECT_*, which feels a bit 32 * much just for those macros... they might serve better as EVP macros. 33 */ 34#include <openssl/core_dispatch.h> 35 36#ifndef OPENSSL_NO_RC4 37# define DEFAULT_PVK_ENCR_STRENGTH 2 38#else 39# define DEFAULT_PVK_ENCR_STRENGTH 0 40#endif 41 42typedef enum OPTION_choice { 43 OPT_COMMON, 44 OPT_INFORM, OPT_OUTFORM, OPT_ENGINE, OPT_IN, OPT_OUT, 45 OPT_PUBIN, OPT_PUBOUT, OPT_PASSOUT, OPT_PASSIN, 46 OPT_RSAPUBKEY_IN, OPT_RSAPUBKEY_OUT, 47 /* Do not change the order here; see case statements below */ 48 OPT_PVK_NONE, OPT_PVK_WEAK, OPT_PVK_STRONG, 49 OPT_NOOUT, OPT_TEXT, OPT_MODULUS, OPT_CHECK, OPT_CIPHER, 50 OPT_PROV_ENUM, OPT_TRADITIONAL 51} OPTION_CHOICE; 52 53const OPTIONS rsa_options[] = { 54 OPT_SECTION("General"), 55 {"help", OPT_HELP, '-', "Display this summary"}, 56 {"check", OPT_CHECK, '-', "Verify key consistency"}, 57 {"", OPT_CIPHER, '-', "Any supported cipher"}, 58#ifndef OPENSSL_NO_ENGINE 59 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"}, 60#endif 61 62 OPT_SECTION("Input"), 63 {"in", OPT_IN, 's', "Input file"}, 64 {"inform", OPT_INFORM, 'f', "Input format (DER/PEM/P12/ENGINE)"}, 65 {"pubin", OPT_PUBIN, '-', "Expect a public key in input file"}, 66 {"RSAPublicKey_in", OPT_RSAPUBKEY_IN, '-', "Input is an RSAPublicKey"}, 67 {"passin", OPT_PASSIN, 's', "Input file pass phrase source"}, 68 69 OPT_SECTION("Output"), 70 {"out", OPT_OUT, '>', "Output file"}, 71 {"outform", OPT_OUTFORM, 'f', "Output format, one of DER PEM PVK"}, 72 {"pubout", OPT_PUBOUT, '-', "Output a public key"}, 73 {"RSAPublicKey_out", OPT_RSAPUBKEY_OUT, '-', "Output is an RSAPublicKey"}, 74 {"passout", OPT_PASSOUT, 's', "Output file pass phrase source"}, 75 {"noout", OPT_NOOUT, '-', "Don't print key out"}, 76 {"text", OPT_TEXT, '-', "Print the key in text"}, 77 {"modulus", OPT_MODULUS, '-', "Print the RSA key modulus"}, 78 {"traditional", OPT_TRADITIONAL, '-', 79 "Use traditional format for private keys"}, 80 81#ifndef OPENSSL_NO_RC4 82 OPT_SECTION("PVK"), 83 {"pvk-strong", OPT_PVK_STRONG, '-', "Enable 'Strong' PVK encoding level (default)"}, 84 {"pvk-weak", OPT_PVK_WEAK, '-', "Enable 'Weak' PVK encoding level"}, 85 {"pvk-none", OPT_PVK_NONE, '-', "Don't enforce PVK encoding"}, 86#endif 87 88 OPT_PROV_OPTIONS, 89 {NULL} 90}; 91 92static int try_legacy_encoding(EVP_PKEY *pkey, int outformat, int pubout, 93 BIO *out) 94{ 95 int ret = 0; 96#ifndef OPENSSL_NO_DEPRECATED_3_0 97 const RSA *rsa = EVP_PKEY_get0_RSA(pkey); 98 99 if (rsa == NULL) 100 return 0; 101 102 if (outformat == FORMAT_ASN1) { 103 if (pubout == 2) 104 ret = i2d_RSAPublicKey_bio(out, rsa) > 0; 105 else 106 ret = i2d_RSA_PUBKEY_bio(out, rsa) > 0; 107 } else if (outformat == FORMAT_PEM) { 108 if (pubout == 2) 109 ret = PEM_write_bio_RSAPublicKey(out, rsa) > 0; 110 else 111 ret = PEM_write_bio_RSA_PUBKEY(out, rsa) > 0; 112# ifndef OPENSSL_NO_DSA 113 } else if (outformat == FORMAT_MSBLOB || outformat == FORMAT_PVK) { 114 ret = i2b_PublicKey_bio(out, pkey) > 0; 115# endif 116 } 117#endif 118 119 return ret; 120} 121 122int rsa_main(int argc, char **argv) 123{ 124 ENGINE *e = NULL; 125 BIO *out = NULL; 126 EVP_PKEY *pkey = NULL; 127 EVP_PKEY_CTX *pctx; 128 EVP_CIPHER *enc = NULL; 129 char *infile = NULL, *outfile = NULL, *ciphername = NULL, *prog; 130 char *passin = NULL, *passout = NULL, *passinarg = NULL, *passoutarg = NULL; 131 int private = 0; 132 int informat = FORMAT_UNDEF, outformat = FORMAT_PEM, text = 0, check = 0; 133 int noout = 0, modulus = 0, pubin = 0, pubout = 0, ret = 1; 134 int pvk_encr = DEFAULT_PVK_ENCR_STRENGTH; 135 OPTION_CHOICE o; 136 int traditional = 0; 137 const char *output_type = NULL; 138 const char *output_structure = NULL; 139 int selection = 0; 140 OSSL_ENCODER_CTX *ectx = NULL; 141 142 prog = opt_init(argc, argv, rsa_options); 143 while ((o = opt_next()) != OPT_EOF) { 144 switch (o) { 145 case OPT_EOF: 146 case OPT_ERR: 147 opthelp: 148 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog); 149 goto end; 150 case OPT_HELP: 151 opt_help(rsa_options); 152 ret = 0; 153 goto end; 154 case OPT_INFORM: 155 if (!opt_format(opt_arg(), OPT_FMT_ANY, &informat)) 156 goto opthelp; 157 break; 158 case OPT_IN: 159 infile = opt_arg(); 160 break; 161 case OPT_OUTFORM: 162 if (!opt_format(opt_arg(), OPT_FMT_ANY, &outformat)) 163 goto opthelp; 164 break; 165 case OPT_OUT: 166 outfile = opt_arg(); 167 break; 168 case OPT_PASSIN: 169 passinarg = opt_arg(); 170 break; 171 case OPT_PASSOUT: 172 passoutarg = opt_arg(); 173 break; 174 case OPT_ENGINE: 175 e = setup_engine(opt_arg(), 0); 176 break; 177 case OPT_PUBIN: 178 pubin = 1; 179 break; 180 case OPT_PUBOUT: 181 pubout = 1; 182 break; 183 case OPT_RSAPUBKEY_IN: 184 pubin = 2; 185 break; 186 case OPT_RSAPUBKEY_OUT: 187 pubout = 2; 188 break; 189 case OPT_PVK_STRONG: /* pvk_encr:= 2 */ 190 case OPT_PVK_WEAK: /* pvk_encr:= 1 */ 191 case OPT_PVK_NONE: /* pvk_encr:= 0 */ 192 pvk_encr = (o - OPT_PVK_NONE); 193 break; 194 case OPT_NOOUT: 195 noout = 1; 196 break; 197 case OPT_TEXT: 198 text = 1; 199 break; 200 case OPT_MODULUS: 201 modulus = 1; 202 break; 203 case OPT_CHECK: 204 check = 1; 205 break; 206 case OPT_CIPHER: 207 ciphername = opt_unknown(); 208 break; 209 case OPT_PROV_CASES: 210 if (!opt_provider(o)) 211 goto end; 212 break; 213 case OPT_TRADITIONAL: 214 traditional = 1; 215 break; 216 } 217 } 218 219 /* No extra arguments. */ 220 argc = opt_num_rest(); 221 if (argc != 0) 222 goto opthelp; 223 224 if (ciphername != NULL) { 225 if (!opt_cipher(ciphername, &enc)) 226 goto opthelp; 227 } 228 private = (text && !pubin) || (!pubout && !noout) ? 1 : 0; 229 230 if (!app_passwd(passinarg, passoutarg, &passin, &passout)) { 231 BIO_printf(bio_err, "Error getting passwords\n"); 232 goto end; 233 } 234 if (check && pubin) { 235 BIO_printf(bio_err, "Only private keys can be checked\n"); 236 goto end; 237 } 238 239 if (pubin) { 240 int tmpformat = FORMAT_UNDEF; 241 242 if (pubin == 2) { 243 if (informat == FORMAT_PEM) 244 tmpformat = FORMAT_PEMRSA; 245 else if (informat == FORMAT_ASN1) 246 tmpformat = FORMAT_ASN1RSA; 247 } else { 248 tmpformat = informat; 249 } 250 251 pkey = load_pubkey(infile, tmpformat, 1, passin, e, "public key"); 252 } else { 253 pkey = load_key(infile, informat, 1, passin, e, "private key"); 254 } 255 256 if (pkey == NULL) { 257 ERR_print_errors(bio_err); 258 goto end; 259 } 260 if (!EVP_PKEY_is_a(pkey, "RSA") && !EVP_PKEY_is_a(pkey, "RSA-PSS")) { 261 BIO_printf(bio_err, "Not an RSA key\n"); 262 goto end; 263 } 264 265 out = bio_open_owner(outfile, outformat, private); 266 if (out == NULL) 267 goto end; 268 269 if (text) { 270 assert(pubin || private); 271 if ((pubin && EVP_PKEY_print_public(out, pkey, 0, NULL) <= 0) 272 || (!pubin && EVP_PKEY_print_private(out, pkey, 0, NULL) <= 0)) { 273 perror(outfile); 274 ERR_print_errors(bio_err); 275 goto end; 276 } 277 } 278 279 if (modulus) { 280 BIGNUM *n = NULL; 281 282 /* Every RSA key has an 'n' */ 283 EVP_PKEY_get_bn_param(pkey, "n", &n); 284 BIO_printf(out, "Modulus="); 285 BN_print(out, n); 286 BIO_printf(out, "\n"); 287 BN_free(n); 288 } 289 290 if (check) { 291 int r; 292 293 pctx = EVP_PKEY_CTX_new_from_pkey(NULL, pkey, NULL); 294 if (pctx == NULL) { 295 BIO_printf(bio_err, "RSA unable to create PKEY context\n"); 296 ERR_print_errors(bio_err); 297 goto end; 298 } 299 r = EVP_PKEY_check(pctx); 300 EVP_PKEY_CTX_free(pctx); 301 302 if (r == 1) { 303 BIO_printf(out, "RSA key ok\n"); 304 } else if (r == 0) { 305 BIO_printf(bio_err, "RSA key not ok\n"); 306 ERR_print_errors(bio_err); 307 } else if (r < 0) { 308 ERR_print_errors(bio_err); 309 goto end; 310 } 311 } 312 313 if (noout) { 314 ret = 0; 315 goto end; 316 } 317 BIO_printf(bio_err, "writing RSA key\n"); 318 319 /* Choose output type for the format */ 320 if (outformat == FORMAT_ASN1) { 321 output_type = "DER"; 322 } else if (outformat == FORMAT_PEM) { 323 output_type = "PEM"; 324 } else if (outformat == FORMAT_MSBLOB) { 325 output_type = "MSBLOB"; 326 } else if (outformat == FORMAT_PVK) { 327 if (pubin) { 328 BIO_printf(bio_err, "PVK form impossible with public key input\n"); 329 goto end; 330 } 331 output_type = "PVK"; 332 } else { 333 BIO_printf(bio_err, "bad output format specified for outfile\n"); 334 goto end; 335 } 336 337 /* Select what you want in the output */ 338 if (pubout || pubin) { 339 selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY; 340 } else { 341 assert(private); 342 selection = (OSSL_KEYMGMT_SELECT_KEYPAIR 343 | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS); 344 } 345 346 /* For DER based output, select the desired output structure */ 347 if (outformat == FORMAT_ASN1 || outformat == FORMAT_PEM) { 348 if (pubout || pubin) { 349 if (pubout == 2) 350 output_structure = "pkcs1"; /* "type-specific" would work too */ 351 else 352 output_structure = "SubjectPublicKeyInfo"; 353 } else { 354 assert(private); 355 if (traditional) 356 output_structure = "pkcs1"; /* "type-specific" would work too */ 357 else 358 output_structure = "PrivateKeyInfo"; 359 } 360 } 361 362 /* Now, perform the encoding */ 363 ectx = OSSL_ENCODER_CTX_new_for_pkey(pkey, selection, 364 output_type, output_structure, 365 NULL); 366 if (OSSL_ENCODER_CTX_get_num_encoders(ectx) == 0) { 367 if ((!pubout && !pubin) 368 || !try_legacy_encoding(pkey, outformat, pubout, out)) 369 BIO_printf(bio_err, "%s format not supported\n", output_type); 370 else 371 ret = 0; 372 goto end; 373 } 374 375 /* Passphrase setup */ 376 if (enc != NULL) 377 OSSL_ENCODER_CTX_set_cipher(ectx, EVP_CIPHER_get0_name(enc), NULL); 378 379 /* Default passphrase prompter */ 380 if (enc != NULL || outformat == FORMAT_PVK) { 381 OSSL_ENCODER_CTX_set_passphrase_ui(ectx, get_ui_method(), NULL); 382 if (passout != NULL) 383 /* When passout given, override the passphrase prompter */ 384 OSSL_ENCODER_CTX_set_passphrase(ectx, 385 (const unsigned char *)passout, 386 strlen(passout)); 387 } 388 389 /* PVK is a bit special... */ 390 if (outformat == FORMAT_PVK) { 391 OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END }; 392 393 params[0] = OSSL_PARAM_construct_int("encrypt-level", &pvk_encr); 394 if (!OSSL_ENCODER_CTX_set_params(ectx, params)) { 395 BIO_printf(bio_err, "invalid PVK encryption level\n"); 396 goto end; 397 } 398 } 399 400 if (!OSSL_ENCODER_to_bio(ectx, out)) { 401 BIO_printf(bio_err, "unable to write key\n"); 402 ERR_print_errors(bio_err); 403 goto end; 404 } 405 ret = 0; 406 end: 407 OSSL_ENCODER_CTX_free(ectx); 408 release_engine(e); 409 BIO_free_all(out); 410 EVP_PKEY_free(pkey); 411 EVP_CIPHER_free(enc); 412 OPENSSL_free(passin); 413 OPENSSL_free(passout); 414 return ret; 415} 416