crypto/pem/pem_all.c

   1 /* crypto/pem/pem_all.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111
 112 #include <stdio.h>
 113 #undef SSLEAY_MACROS
 114 #include "cryptlib.h"
 115 #include <openssl/bio.h>
 116 #include <openssl/evp.h>
 117 #include <openssl/x509.h>
 118 #include <openssl/pkcs7.h>
 119 #include <openssl/pem.h>
 120 #ifndef OPENSSL_NO_RSA
 121 # include <openssl/rsa.h>
 122 #endif
 123 #ifndef OPENSSL_NO_DSA
 124 # include <openssl/dsa.h>
 125 #endif
 126 #ifndef OPENSSL_NO_DH
 127 # include <openssl/dh.h>
 128 #endif
 129
 130 #ifndef OPENSSL_NO_RSA
 131 static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa);
 132 #endif
 133 #ifndef OPENSSL_NO_DSA
 134 static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa);
 135 #endif
 136
 137 #ifndef OPENSSL_NO_EC
 138 static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey);
 139 #endif
 140
 141 IMPLEMENT_PEM_rw(X509_REQ, X509_REQ, PEM_STRING_X509_REQ, X509_REQ)
 142
 143 IMPLEMENT_PEM_write(X509_REQ_NEW, X509_REQ, PEM_STRING_X509_REQ_OLD, X509_REQ)
 144 IMPLEMENT_PEM_rw(X509_CRL, X509_CRL, PEM_STRING_X509_CRL, X509_CRL)
 145 IMPLEMENT_PEM_rw(PKCS7, PKCS7, PEM_STRING_PKCS7, PKCS7)
 146
 147 IMPLEMENT_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE,
 148                  PEM_STRING_X509, NETSCAPE_CERT_SEQUENCE)
 149 #ifndef OPENSSL_NO_RSA
 150 /*
 151  * We treat RSA or DSA private keys as a special case. For private keys we
 152  * read in an EVP_PKEY structure with PEM_read_bio_PrivateKey() and extract
 153  * the relevant private key: this means can handle "traditional" and PKCS#8
 154  * formats transparently.
 155  */
 156 static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa)
 157 {
 158     RSA *rtmp;
 159     if (!key)
 160         return NULL;
 161     rtmp = EVP_PKEY_get1_RSA(key);
 162     EVP_PKEY_free(key);
 163     if (!rtmp)
 164         return NULL;
 165     if (rsa) {
 166         RSA_free(*rsa);
 167         *rsa = rtmp;
 168     }
 169     return rtmp;
 170 }
 171
 172 RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **rsa, pem_password_cb *cb,
 173                                 void *u)
 174 {
 175     EVP_PKEY *pktmp;
 176     pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
 177     return pkey_get_rsa(pktmp, rsa);
 178 }
 179
 180 # ifndef OPENSSL_NO_FP_API
 181
 182 RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **rsa, pem_password_cb *cb, void *u)
 183 {
 184     EVP_PKEY *pktmp;
 185     pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
 186     return pkey_get_rsa(pktmp, rsa);
 187 }
 188
 189 # endif
 190
 191 # ifdef OPENSSL_FIPS
 192
 193 int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc,
 194                                 unsigned char *kstr, int klen,
 195                                 pem_password_cb *cb, void *u)
 196 {
 197     EVP_PKEY *k;
 198     int ret;
 199     k = EVP_PKEY_new();
 200     if (!k)
 201         return 0;
 202     EVP_PKEY_set1_RSA(k, x);
 203
 204     ret = PEM_write_bio_PrivateKey(bp, k, enc, kstr, klen, cb, u);
 205     EVP_PKEY_free(k);
 206     return ret;
 207 }
 208
 209 #  ifndef OPENSSL_NO_FP_API
 210 int PEM_write_RSAPrivateKey(FILE *fp, RSA *x, const EVP_CIPHER *enc,
 211                             unsigned char *kstr, int klen,
 212                             pem_password_cb *cb, void *u)
 213 {
 214     EVP_PKEY *k;
 215     int ret;
 216     k = EVP_PKEY_new();
 217     if (!k)
 218         return 0;
 219
 220     EVP_PKEY_set1_RSA(k, x);
 221
 222     ret = PEM_write_PrivateKey(fp, k, enc, kstr, klen, cb, u);
 223     EVP_PKEY_free(k);
 224     return ret;
 225 }
 226 #  endif
 227
 228 # else
 229
 230 IMPLEMENT_PEM_write_cb_const(RSAPrivateKey, RSA, PEM_STRING_RSA,
 231                              RSAPrivateKey)
 232 # endif
 233 IMPLEMENT_PEM_rw_const(RSAPublicKey, RSA, PEM_STRING_RSA_PUBLIC,
 234                        RSAPublicKey) IMPLEMENT_PEM_rw(RSA_PUBKEY, RSA,
 235                                                       PEM_STRING_PUBLIC,
 236                                                       RSA_PUBKEY)
 237 #endif
 238 #ifndef OPENSSL_NO_DSA
 239 static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa)
 240 {
 241     DSA *dtmp;
 242     if (!key)
 243         return NULL;
 244     dtmp = EVP_PKEY_get1_DSA(key);
 245     EVP_PKEY_free(key);
 246     if (!dtmp)
 247         return NULL;
 248     if (dsa) {
 249         DSA_free(*dsa);
 250         *dsa = dtmp;
 251     }
 252     return dtmp;
 253 }
 254
 255 DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **dsa, pem_password_cb *cb,
 256                                 void *u)
 257 {
 258     EVP_PKEY *pktmp;
 259     pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
 260     return pkey_get_dsa(pktmp, dsa);
 261 }
 262
 263 # ifdef OPENSSL_FIPS
 264
 265 int PEM_write_bio_DSAPrivateKey(BIO *bp, DSA *x, const EVP_CIPHER *enc,
 266                                 unsigned char *kstr, int klen,
 267                                 pem_password_cb *cb, void *u)
 268 {
 269     EVP_PKEY *k;
 270     int ret;
 271     k = EVP_PKEY_new();
 272     if (!k)
 273         return 0;
 274     EVP_PKEY_set1_DSA(k, x);
 275
 276     ret = PEM_write_bio_PrivateKey(bp, k, enc, kstr, klen, cb, u);
 277     EVP_PKEY_free(k);
 278     return ret;
 279 }
 280
 281 #  ifndef OPENSSL_NO_FP_API
 282 int PEM_write_DSAPrivateKey(FILE *fp, DSA *x, const EVP_CIPHER *enc,
 283                             unsigned char *kstr, int klen,
 284                             pem_password_cb *cb, void *u)
 285 {
 286     EVP_PKEY *k;
 287     int ret;
 288     k = EVP_PKEY_new();
 289     if (!k)
 290         return 0;
 291     EVP_PKEY_set1_DSA(k, x);
 292     ret = PEM_write_PrivateKey(fp, k, enc, kstr, klen, cb, u);
 293     EVP_PKEY_free(k);
 294     return ret;
 295 }
 296 #  endif
 297
 298 # else
 299
 300 IMPLEMENT_PEM_write_cb_const(DSAPrivateKey, DSA, PEM_STRING_DSA,
 301                              DSAPrivateKey)
 302 # endif
 303     IMPLEMENT_PEM_rw(DSA_PUBKEY, DSA, PEM_STRING_PUBLIC, DSA_PUBKEY)
 304 # ifndef OPENSSL_NO_FP_API
 305 DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **dsa, pem_password_cb *cb, void *u)
 306 {
 307     EVP_PKEY *pktmp;
 308     pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
 309     return pkey_get_dsa(pktmp, dsa);
 310 }
 311
 312 # endif
 313
 314 IMPLEMENT_PEM_rw_const(DSAparams, DSA, PEM_STRING_DSAPARAMS, DSAparams)
 315 #endif
 316 #ifndef OPENSSL_NO_EC
 317 static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey)
 318 {
 319     EC_KEY *dtmp;
 320     if (!key)
 321         return NULL;
 322     dtmp = EVP_PKEY_get1_EC_KEY(key);
 323     EVP_PKEY_free(key);
 324     if (!dtmp)
 325         return NULL;
 326     if (eckey) {
 327         EC_KEY_free(*eckey);
 328         *eckey = dtmp;
 329     }
 330     return dtmp;
 331 }
 332
 333 EC_KEY *PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **key, pem_password_cb *cb,
 334                                   void *u)
 335 {
 336     EVP_PKEY *pktmp;
 337     pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
 338     return pkey_get_eckey(pktmp, key);
 339 }
 340
 341 IMPLEMENT_PEM_rw_const(ECPKParameters, EC_GROUP, PEM_STRING_ECPARAMETERS,
 342                        ECPKParameters)
 343 # ifdef OPENSSL_FIPS
 344 int PEM_write_bio_ECPrivateKey(BIO *bp, EC_KEY *x, const EVP_CIPHER *enc,
 345                                unsigned char *kstr, int klen,
 346                                pem_password_cb *cb, void *u)
 347 {
 348     EVP_PKEY *k;
 349     int ret;
 350     k = EVP_PKEY_new();
 351     if (!k)
 352         return 0;
 353     EVP_PKEY_set1_EC_KEY(k, x);
 354
 355     ret = PEM_write_bio_PrivateKey(bp, k, enc, kstr, klen, cb, u);
 356     EVP_PKEY_free(k);
 357     return ret;
 358 }
 359
 360 #  ifndef OPENSSL_NO_FP_API
 361 int PEM_write_ECPrivateKey(FILE *fp, EC_KEY *x, const EVP_CIPHER *enc,
 362                            unsigned char *kstr, int klen,
 363                            pem_password_cb *cb, void *u)
 364 {
 365     EVP_PKEY *k;
 366     int ret;
 367     k = EVP_PKEY_new();
 368     if (!k)
 369         return 0;
 370     EVP_PKEY_set1_EC_KEY(k, x);
 371     ret = PEM_write_PrivateKey(fp, k, enc, kstr, klen, cb, u);
 372     EVP_PKEY_free(k);
 373     return ret;
 374 }
 375 #  endif
 376
 377 # else
 378     IMPLEMENT_PEM_write_cb(ECPrivateKey, EC_KEY, PEM_STRING_ECPRIVATEKEY,
 379                        ECPrivateKey)
 380 # endif
 381 IMPLEMENT_PEM_rw(EC_PUBKEY, EC_KEY, PEM_STRING_PUBLIC, EC_PUBKEY)
 382 # ifndef OPENSSL_NO_FP_API
 383 EC_KEY *PEM_read_ECPrivateKey(FILE *fp, EC_KEY **eckey, pem_password_cb *cb,
 384                               void *u)
 385 {
 386     EVP_PKEY *pktmp;
 387     pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
 388     return pkey_get_eckey(pktmp, eckey);
 389 }
 390
 391 # endif
 392
 393 #endif
 394
 395 #ifndef OPENSSL_NO_DH
 396
 397 IMPLEMENT_PEM_rw_const(DHparams, DH, PEM_STRING_DHPARAMS, DHparams)
 398 #endif
 399 /*-
 400  * The PrivateKey case is not that straightforward.
 401  *   IMPLEMENT_PEM_rw_cb(PrivateKey, EVP_PKEY, PEM_STRING_EVP_PKEY, PrivateKey)
 402  * does not work, RSA and DSA keys have specific strings.
 403  * (When reading, parameter PEM_STRING_EVP_PKEY is a wildcard for anything
 404  * appropriate.)
 405  */
 406 #ifdef OPENSSL_FIPS
 407 static const char *pkey_str(EVP_PKEY *x)
 408 {
 409     switch (x->type) {
 410     case EVP_PKEY_RSA:
 411         return PEM_STRING_RSA;
 412
 413     case EVP_PKEY_DSA:
 414         return PEM_STRING_DSA;
 415
 416     case EVP_PKEY_EC:
 417         return PEM_STRING_ECPRIVATEKEY;
 418
 419     default:
 420         return NULL;
 421     }
 422 }
 423
 424 int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
 425                              unsigned char *kstr, int klen,
 426                              pem_password_cb *cb, void *u)
 427 {
 428     if (FIPS_mode())
 429         return PEM_write_bio_PKCS8PrivateKey(bp, x, enc,
 430                                              (char *)kstr, klen, cb, u);
 431     else
 432         return PEM_ASN1_write_bio((i2d_of_void *)i2d_PrivateKey,
 433                                   pkey_str(x), bp, (char *)x, enc, kstr, klen,
 434                                   cb, u);
 435 }
 436
 437 # ifndef OPENSSL_NO_FP_API
 438 int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
 439                          unsigned char *kstr, int klen,
 440                          pem_password_cb *cb, void *u)
 441 {
 442     if (FIPS_mode())
 443         return PEM_write_PKCS8PrivateKey(fp, x, enc,
 444                                          (char *)kstr, klen, cb, u);
 445     else
 446         return PEM_ASN1_write((i2d_of_void *)i2d_PrivateKey,
 447                               pkey_str(x), fp, (char *)x, enc, kstr, klen, cb,
 448                               u);
 449 }
 450 # endif
 451
 452 #else
 453 IMPLEMENT_PEM_write_cb(PrivateKey, EVP_PKEY,
 454                        ((x->type ==
 455                          EVP_PKEY_DSA) ? PEM_STRING_DSA : (x->type ==
 456                                                            EVP_PKEY_RSA) ?
 457                         PEM_STRING_RSA : PEM_STRING_ECPRIVATEKEY), PrivateKey)
 458 #endif
 459     IMPLEMENT_PEM_rw(PUBKEY, EVP_PKEY, PEM_STRING_PUBLIC, PUBKEY)