[331] | 1 | /*
|
---|
| 2 | * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
---|
| 3 | *
|
---|
| 4 | * Licensed under the OpenSSL license (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 "internal/cryptlib.h"
|
---|
| 12 | #include <openssl/buffer.h>
|
---|
| 13 | #include <openssl/objects.h>
|
---|
| 14 | #include <openssl/evp.h>
|
---|
| 15 | #include <openssl/x509.h>
|
---|
| 16 | #include <openssl/pkcs12.h>
|
---|
| 17 | #include <openssl/pem.h>
|
---|
| 18 |
|
---|
| 19 | static int do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder,
|
---|
| 20 | int nid, const EVP_CIPHER *enc,
|
---|
| 21 | char *kstr, int klen, pem_password_cb *cb, void *u);
|
---|
| 22 |
|
---|
| 23 | #ifndef OPENSSL_NO_STDIO
|
---|
| 24 | static int do_pk8pkey_fp(FILE *bp, EVP_PKEY *x, int isder,
|
---|
| 25 | int nid, const EVP_CIPHER *enc,
|
---|
| 26 | char *kstr, int klen, pem_password_cb *cb, void *u);
|
---|
| 27 | #endif
|
---|
| 28 | /*
|
---|
| 29 | * These functions write a private key in PKCS#8 format: it is a "drop in"
|
---|
| 30 | * replacement for PEM_write_bio_PrivateKey() and friends. As usual if 'enc'
|
---|
| 31 | * is NULL then it uses the unencrypted private key form. The 'nid' versions
|
---|
| 32 | * uses PKCS#5 v1.5 PBE algorithms whereas the others use PKCS#5 v2.0.
|
---|
| 33 | */
|
---|
| 34 |
|
---|
| 35 | int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
|
---|
| 36 | char *kstr, int klen,
|
---|
| 37 | pem_password_cb *cb, void *u)
|
---|
| 38 | {
|
---|
| 39 | return do_pk8pkey(bp, x, 0, nid, NULL, kstr, klen, cb, u);
|
---|
| 40 | }
|
---|
| 41 |
|
---|
| 42 | int PEM_write_bio_PKCS8PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
|
---|
| 43 | char *kstr, int klen,
|
---|
| 44 | pem_password_cb *cb, void *u)
|
---|
| 45 | {
|
---|
| 46 | return do_pk8pkey(bp, x, 0, -1, enc, kstr, klen, cb, u);
|
---|
| 47 | }
|
---|
| 48 |
|
---|
| 49 | int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
|
---|
| 50 | char *kstr, int klen,
|
---|
| 51 | pem_password_cb *cb, void *u)
|
---|
| 52 | {
|
---|
| 53 | return do_pk8pkey(bp, x, 1, -1, enc, kstr, klen, cb, u);
|
---|
| 54 | }
|
---|
| 55 |
|
---|
| 56 | int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
|
---|
| 57 | char *kstr, int klen,
|
---|
| 58 | pem_password_cb *cb, void *u)
|
---|
| 59 | {
|
---|
| 60 | return do_pk8pkey(bp, x, 1, nid, NULL, kstr, klen, cb, u);
|
---|
| 61 | }
|
---|
| 62 |
|
---|
| 63 | static int do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder, int nid,
|
---|
| 64 | const EVP_CIPHER *enc, char *kstr, int klen,
|
---|
| 65 | pem_password_cb *cb, void *u)
|
---|
| 66 | {
|
---|
| 67 | X509_SIG *p8;
|
---|
| 68 | PKCS8_PRIV_KEY_INFO *p8inf;
|
---|
| 69 | char buf[PEM_BUFSIZE];
|
---|
| 70 | int ret;
|
---|
| 71 |
|
---|
| 72 | if ((p8inf = EVP_PKEY2PKCS8(x)) == NULL) {
|
---|
| 73 | PEMerr(PEM_F_DO_PK8PKEY, PEM_R_ERROR_CONVERTING_PRIVATE_KEY);
|
---|
| 74 | return 0;
|
---|
| 75 | }
|
---|
| 76 | if (enc || (nid != -1)) {
|
---|
| 77 | if (!kstr) {
|
---|
| 78 | if (!cb)
|
---|
| 79 | klen = PEM_def_callback(buf, PEM_BUFSIZE, 1, u);
|
---|
| 80 | else
|
---|
| 81 | klen = cb(buf, PEM_BUFSIZE, 1, u);
|
---|
| 82 | if (klen <= 0) {
|
---|
| 83 | PEMerr(PEM_F_DO_PK8PKEY, PEM_R_READ_KEY);
|
---|
| 84 | PKCS8_PRIV_KEY_INFO_free(p8inf);
|
---|
| 85 | return 0;
|
---|
| 86 | }
|
---|
| 87 |
|
---|
| 88 | kstr = buf;
|
---|
| 89 | }
|
---|
| 90 | p8 = PKCS8_encrypt(nid, enc, kstr, klen, NULL, 0, 0, p8inf);
|
---|
| 91 | if (kstr == buf)
|
---|
| 92 | OPENSSL_cleanse(buf, klen);
|
---|
| 93 | PKCS8_PRIV_KEY_INFO_free(p8inf);
|
---|
| 94 | if (p8 == NULL)
|
---|
| 95 | return 0;
|
---|
| 96 | if (isder)
|
---|
| 97 | ret = i2d_PKCS8_bio(bp, p8);
|
---|
| 98 | else
|
---|
| 99 | ret = PEM_write_bio_PKCS8(bp, p8);
|
---|
| 100 | X509_SIG_free(p8);
|
---|
| 101 | return ret;
|
---|
| 102 | } else {
|
---|
| 103 | if (isder)
|
---|
| 104 | ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
|
---|
| 105 | else
|
---|
| 106 | ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(bp, p8inf);
|
---|
| 107 | PKCS8_PRIV_KEY_INFO_free(p8inf);
|
---|
| 108 | return ret;
|
---|
| 109 | }
|
---|
| 110 | }
|
---|
| 111 |
|
---|
| 112 | EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
|
---|
| 113 | void *u)
|
---|
| 114 | {
|
---|
| 115 | PKCS8_PRIV_KEY_INFO *p8inf = NULL;
|
---|
| 116 | X509_SIG *p8 = NULL;
|
---|
| 117 | int klen;
|
---|
| 118 | EVP_PKEY *ret;
|
---|
| 119 | char psbuf[PEM_BUFSIZE];
|
---|
| 120 | p8 = d2i_PKCS8_bio(bp, NULL);
|
---|
| 121 | if (!p8)
|
---|
| 122 | return NULL;
|
---|
| 123 | if (cb)
|
---|
| 124 | klen = cb(psbuf, PEM_BUFSIZE, 0, u);
|
---|
| 125 | else
|
---|
| 126 | klen = PEM_def_callback(psbuf, PEM_BUFSIZE, 0, u);
|
---|
| 127 | if (klen <= 0) {
|
---|
| 128 | PEMerr(PEM_F_D2I_PKCS8PRIVATEKEY_BIO, PEM_R_BAD_PASSWORD_READ);
|
---|
| 129 | X509_SIG_free(p8);
|
---|
| 130 | return NULL;
|
---|
| 131 | }
|
---|
| 132 | p8inf = PKCS8_decrypt(p8, psbuf, klen);
|
---|
| 133 | X509_SIG_free(p8);
|
---|
| 134 | if (!p8inf)
|
---|
| 135 | return NULL;
|
---|
| 136 | ret = EVP_PKCS82PKEY(p8inf);
|
---|
| 137 | PKCS8_PRIV_KEY_INFO_free(p8inf);
|
---|
| 138 | if (!ret)
|
---|
| 139 | return NULL;
|
---|
| 140 | if (x) {
|
---|
| 141 | EVP_PKEY_free(*x);
|
---|
| 142 | *x = ret;
|
---|
| 143 | }
|
---|
| 144 | return ret;
|
---|
| 145 | }
|
---|
| 146 |
|
---|
| 147 | #ifndef OPENSSL_NO_STDIO
|
---|
| 148 |
|
---|
| 149 | int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
|
---|
| 150 | char *kstr, int klen, pem_password_cb *cb, void *u)
|
---|
| 151 | {
|
---|
| 152 | return do_pk8pkey_fp(fp, x, 1, -1, enc, kstr, klen, cb, u);
|
---|
| 153 | }
|
---|
| 154 |
|
---|
| 155 | int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,
|
---|
| 156 | char *kstr, int klen,
|
---|
| 157 | pem_password_cb *cb, void *u)
|
---|
| 158 | {
|
---|
| 159 | return do_pk8pkey_fp(fp, x, 1, nid, NULL, kstr, klen, cb, u);
|
---|
| 160 | }
|
---|
| 161 |
|
---|
| 162 | int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
|
---|
| 163 | char *kstr, int klen,
|
---|
| 164 | pem_password_cb *cb, void *u)
|
---|
| 165 | {
|
---|
| 166 | return do_pk8pkey_fp(fp, x, 0, nid, NULL, kstr, klen, cb, u);
|
---|
| 167 | }
|
---|
| 168 |
|
---|
| 169 | int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
|
---|
| 170 | char *kstr, int klen, pem_password_cb *cb,
|
---|
| 171 | void *u)
|
---|
| 172 | {
|
---|
| 173 | return do_pk8pkey_fp(fp, x, 0, -1, enc, kstr, klen, cb, u);
|
---|
| 174 | }
|
---|
| 175 |
|
---|
| 176 | static int do_pk8pkey_fp(FILE *fp, EVP_PKEY *x, int isder, int nid,
|
---|
| 177 | const EVP_CIPHER *enc, char *kstr, int klen,
|
---|
| 178 | pem_password_cb *cb, void *u)
|
---|
| 179 | {
|
---|
| 180 | BIO *bp;
|
---|
| 181 | int ret;
|
---|
| 182 |
|
---|
| 183 | if ((bp = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
|
---|
| 184 | PEMerr(PEM_F_DO_PK8PKEY_FP, ERR_R_BUF_LIB);
|
---|
| 185 | return (0);
|
---|
| 186 | }
|
---|
| 187 | ret = do_pk8pkey(bp, x, isder, nid, enc, kstr, klen, cb, u);
|
---|
| 188 | BIO_free(bp);
|
---|
| 189 | return ret;
|
---|
| 190 | }
|
---|
| 191 |
|
---|
| 192 | EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
|
---|
| 193 | void *u)
|
---|
| 194 | {
|
---|
| 195 | BIO *bp;
|
---|
| 196 | EVP_PKEY *ret;
|
---|
| 197 |
|
---|
| 198 | if ((bp = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
|
---|
| 199 | PEMerr(PEM_F_D2I_PKCS8PRIVATEKEY_FP, ERR_R_BUF_LIB);
|
---|
| 200 | return NULL;
|
---|
| 201 | }
|
---|
| 202 | ret = d2i_PKCS8PrivateKey_bio(bp, x, cb, u);
|
---|
| 203 | BIO_free(bp);
|
---|
| 204 | return ret;
|
---|
| 205 | }
|
---|
| 206 |
|
---|
| 207 | #endif
|
---|
| 208 |
|
---|
| 209 | IMPLEMENT_PEM_rw(PKCS8, X509_SIG, PEM_STRING_PKCS8, X509_SIG)
|
---|
| 210 |
|
---|
| 211 |
|
---|
| 212 | IMPLEMENT_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF,
|
---|
| 213 | PKCS8_PRIV_KEY_INFO)
|
---|