grpc 1.53.0 → 1.54.2

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_all.c

@@ -127,126 +127,117 @@ IMPLEMENT_PEM_write(X509_REQ_NEW, X509_REQ, PEM_STRING_X509_REQ_OLD, X509_REQ)
 IMPLEMENT_PEM_rw(X509_CRL, X509_CRL, PEM_STRING_X509_CRL, X509_CRL)
 IMPLEMENT_PEM_rw(PKCS7, PKCS7, PEM_STRING_PKCS7, PKCS7)
 
-/*
- * We treat RSA or DSA private keys as a special case. For private keys we
- * read in an EVP_PKEY structure with PEM_read_bio_PrivateKey() and extract
- * the relevant private key: this means can handle "traditional" and PKCS#8
- * formats transparently.
- */
-static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa)
-{
-    RSA *rtmp;
-    if (!key)
-        return NULL;
-    rtmp = EVP_PKEY_get1_RSA(key);
-    EVP_PKEY_free(key);
-    if (!rtmp)
-        return NULL;
-    if (rsa) {
-        RSA_free(*rsa);
-        *rsa = rtmp;
-    }
-    return rtmp;
+// We treat RSA or DSA private keys as a special case. For private keys we
+// read in an EVP_PKEY structure with PEM_read_bio_PrivateKey() and extract
+// the relevant private key: this means can handle "traditional" and PKCS#8
+// formats transparently.
+static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa) {
+  RSA *rtmp;
+  if (!key) {
+    return NULL;
+  }
+  rtmp = EVP_PKEY_get1_RSA(key);
+  EVP_PKEY_free(key);
+  if (!rtmp) {
+    return NULL;
+  }
+  if (rsa) {
+    RSA_free(*rsa);
+    *rsa = rtmp;
+  }
+  return rtmp;
 }
 
 RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **rsa, pem_password_cb *cb,
-                                void *u)
-{
-    EVP_PKEY *pktmp;
-    pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
-    return pkey_get_rsa(pktmp, rsa);
+                                void *u) {
+  EVP_PKEY *pktmp;
+  pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
+  return pkey_get_rsa(pktmp, rsa);
 }
 
-RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **rsa, pem_password_cb *cb, void *u)
-{
-    EVP_PKEY *pktmp;
-    pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
-    return pkey_get_rsa(pktmp, rsa);
+RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **rsa, pem_password_cb *cb, void *u) {
+  EVP_PKEY *pktmp;
+  pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
+  return pkey_get_rsa(pktmp, rsa);
 }
 
-IMPLEMENT_PEM_write_cb_const(RSAPrivateKey, RSA, PEM_STRING_RSA,
-                             RSAPrivateKey)
+IMPLEMENT_PEM_write_cb_const(RSAPrivateKey, RSA, PEM_STRING_RSA, RSAPrivateKey)
 
 
-IMPLEMENT_PEM_rw_const(RSAPublicKey, RSA, PEM_STRING_RSA_PUBLIC,
-                       RSAPublicKey) IMPLEMENT_PEM_rw(RSA_PUBKEY, RSA,
-                                                      PEM_STRING_PUBLIC,
-                                                      RSA_PUBKEY)
+IMPLEMENT_PEM_rw_const(RSAPublicKey, RSA, PEM_STRING_RSA_PUBLIC, RSAPublicKey)
+IMPLEMENT_PEM_rw(RSA_PUBKEY, RSA, PEM_STRING_PUBLIC, RSA_PUBKEY)
 #ifndef OPENSSL_NO_DSA
-static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa)
-{
-    DSA *dtmp;
-    if (!key)
-        return NULL;
-    dtmp = EVP_PKEY_get1_DSA(key);
-    EVP_PKEY_free(key);
-    if (!dtmp)
-        return NULL;
-    if (dsa) {
-        DSA_free(*dsa);
-        *dsa = dtmp;
-    }
-    return dtmp;
+static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa) {
+  DSA *dtmp;
+  if (!key) {
+    return NULL;
+  }
+  dtmp = EVP_PKEY_get1_DSA(key);
+  EVP_PKEY_free(key);
+  if (!dtmp) {
+    return NULL;
+  }
+  if (dsa) {
+    DSA_free(*dsa);
+    *dsa = dtmp;
+  }
+  return dtmp;
 }
 
 DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **dsa, pem_password_cb *cb,
-                                void *u)
-{
-    EVP_PKEY *pktmp;
-    pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
-    return pkey_get_dsa(pktmp, dsa); /* will free pktmp */
+                                void *u) {
+  EVP_PKEY *pktmp;
+  pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
+  return pkey_get_dsa(pktmp, dsa);  // will free pktmp
 }
 
-IMPLEMENT_PEM_write_cb_const(DSAPrivateKey, DSA, PEM_STRING_DSA,
-                             DSAPrivateKey)
+IMPLEMENT_PEM_write_cb_const(DSAPrivateKey, DSA, PEM_STRING_DSA, DSAPrivateKey)
 
-    IMPLEMENT_PEM_rw(DSA_PUBKEY, DSA, PEM_STRING_PUBLIC, DSA_PUBKEY)
-DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **dsa, pem_password_cb *cb, void *u)
-{
-    EVP_PKEY *pktmp;
-    pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
-    return pkey_get_dsa(pktmp, dsa); /* will free pktmp */
+IMPLEMENT_PEM_rw(DSA_PUBKEY, DSA, PEM_STRING_PUBLIC, DSA_PUBKEY)
+DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **dsa, pem_password_cb *cb, void *u) {
+  EVP_PKEY *pktmp;
+  pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
+  return pkey_get_dsa(pktmp, dsa);  // will free pktmp
 }
 
 IMPLEMENT_PEM_rw_const(DSAparams, DSA, PEM_STRING_DSAPARAMS, DSAparams)
 #endif
-static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey)
-{
-    EC_KEY *dtmp;
-    if (!key)
-        return NULL;
-    dtmp = EVP_PKEY_get1_EC_KEY(key);
-    EVP_PKEY_free(key);
-    if (!dtmp)
-        return NULL;
-    if (eckey) {
-        EC_KEY_free(*eckey);
-        *eckey = dtmp;
-    }
-    return dtmp;
+static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey) {
+  EC_KEY *dtmp;
+  if (!key) {
+    return NULL;
+  }
+  dtmp = EVP_PKEY_get1_EC_KEY(key);
+  EVP_PKEY_free(key);
+  if (!dtmp) {
+    return NULL;
+  }
+  if (eckey) {
+    EC_KEY_free(*eckey);
+    *eckey = dtmp;
+  }
+  return dtmp;
 }
 
 EC_KEY *PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **key, pem_password_cb *cb,
-                                  void *u)
-{
-    EVP_PKEY *pktmp;
-    pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
-    return pkey_get_eckey(pktmp, key); /* will free pktmp */
+                                  void *u) {
+  EVP_PKEY *pktmp;
+  pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
+  return pkey_get_eckey(pktmp, key);  // will free pktmp
 }
 
 IMPLEMENT_PEM_write_cb(ECPrivateKey, EC_KEY, PEM_STRING_ECPRIVATEKEY,
                        ECPrivateKey)
 
-    IMPLEMENT_PEM_rw(EC_PUBKEY, EC_KEY, PEM_STRING_PUBLIC, EC_PUBKEY)
+IMPLEMENT_PEM_rw(EC_PUBKEY, EC_KEY, PEM_STRING_PUBLIC, EC_PUBKEY)
 EC_KEY *PEM_read_ECPrivateKey(FILE *fp, EC_KEY **eckey, pem_password_cb *cb,
-                              void *u)
-{
-    EVP_PKEY *pktmp;
-    pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
-    return pkey_get_eckey(pktmp, eckey); /* will free pktmp */
+                              void *u) {
+  EVP_PKEY *pktmp;
+  pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
+  return pkey_get_eckey(pktmp, eckey);  // will free pktmp
 }
 
 
-IMPLEMENT_PEM_write_const(DHparams, DH, PEM_STRING_DHPARAMS, DHparams)
+IMPLEMENT_PEM_rw_const(DHparams, DH, PEM_STRING_DHPARAMS, DHparams)
 
-    IMPLEMENT_PEM_rw(PUBKEY, EVP_PKEY, PEM_STRING_PUBLIC, PUBKEY)
+IMPLEMENT_PEM_rw(PUBKEY, EVP_PKEY, PEM_STRING_PUBLIC, PUBKEY)

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_info.c

@@ -1,4 +1,3 @@
-/* crypto/pem/pem_info.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -71,288 +70,194 @@
 #include <openssl/x509.h>
 
 STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
-                                        pem_password_cb *cb, void *u)
-{
-    BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
-        return 0;
-    }
-    STACK_OF(X509_INFO) *ret = PEM_X509_INFO_read_bio(b, sk, cb, u);
-    BIO_free(b);
-    return ret;
+                                        pem_password_cb *cb, void *u) {
+  BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
+  if (b == NULL) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
+    return 0;
+  }
+  STACK_OF(X509_INFO) *ret = PEM_X509_INFO_read_bio(b, sk, cb, u);
+  BIO_free(b);
+  return ret;
 }
 
 enum parse_result_t {
-    parse_ok,
-    parse_error,
-    parse_new_entry,
+  parse_ok,
+  parse_error,
+  parse_new_entry,
 };
 
 static enum parse_result_t parse_x509(X509_INFO *info, const uint8_t *data,
-                                      size_t len, int key_type)
-{
-    if (info->x509 != NULL) {
-        return parse_new_entry;
-    }
-    info->x509 = d2i_X509(NULL, &data, len);
-    return info->x509 != NULL ? parse_ok : parse_error;
+                                      size_t len, int key_type) {
+  if (info->x509 != NULL) {
+    return parse_new_entry;
+  }
+  info->x509 = d2i_X509(NULL, &data, len);
+  return info->x509 != NULL ? parse_ok : parse_error;
 }
 
 static enum parse_result_t parse_x509_aux(X509_INFO *info, const uint8_t *data,
-                                          size_t len, int key_type)
-{
-    if (info->x509 != NULL) {
-        return parse_new_entry;
-    }
-    info->x509 = d2i_X509_AUX(NULL, &data, len);
-    return info->x509 != NULL ? parse_ok : parse_error;
+                                          size_t len, int key_type) {
+  if (info->x509 != NULL) {
+    return parse_new_entry;
+  }
+  info->x509 = d2i_X509_AUX(NULL, &data, len);
+  return info->x509 != NULL ? parse_ok : parse_error;
 }
 
 static enum parse_result_t parse_crl(X509_INFO *info, const uint8_t *data,
-                                     size_t len, int key_type)
-{
-    if (info->crl != NULL) {
-        return parse_new_entry;
-    }
-    info->crl = d2i_X509_CRL(NULL, &data, len);
-    return info->crl != NULL ? parse_ok : parse_error;
+                                     size_t len, int key_type) {
+  if (info->crl != NULL) {
+    return parse_new_entry;
+  }
+  info->crl = d2i_X509_CRL(NULL, &data, len);
+  return info->crl != NULL ? parse_ok : parse_error;
 }
 
 static enum parse_result_t parse_key(X509_INFO *info, const uint8_t *data,
-                                     size_t len, int key_type)
-{
-    if (info->x_pkey != NULL) {
-        return parse_new_entry;
-    }
-    info->x_pkey = X509_PKEY_new();
-    if (info->x_pkey == NULL) {
-        return parse_error;
-    }
-    info->x_pkey->dec_pkey = d2i_PrivateKey(key_type, NULL, &data, len);
-    return info->x_pkey->dec_pkey != NULL ? parse_ok : parse_error;
+                                     size_t len, int key_type) {
+  if (info->x_pkey != NULL) {
+    return parse_new_entry;
+  }
+  info->x_pkey = X509_PKEY_new();
+  if (info->x_pkey == NULL) {
+    return parse_error;
+  }
+  info->x_pkey->dec_pkey = d2i_PrivateKey(key_type, NULL, &data, len);
+  return info->x_pkey->dec_pkey != NULL ? parse_ok : parse_error;
 }
 
 STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk,
-                                            pem_password_cb *cb, void *u)
-{
-    X509_INFO *info = NULL;
-    char *name = NULL, *header = NULL;
-    unsigned char *data = NULL;
-    long len;
-    int ok = 0;
-    STACK_OF(X509_INFO) *ret = NULL;
+                                            pem_password_cb *cb, void *u) {
+  X509_INFO *info = NULL;
+  char *name = NULL, *header = NULL;
+  unsigned char *data = NULL;
+  long len;
+  int ok = 0;
+  STACK_OF(X509_INFO) *ret = NULL;
 
-    if (sk == NULL) {
-        ret = sk_X509_INFO_new_null();
-        if (ret == NULL) {
-            OPENSSL_PUT_ERROR(PEM, ERR_R_MALLOC_FAILURE);
-            return NULL;
-        }
-    } else {
-        ret = sk;
+  if (sk == NULL) {
+    ret = sk_X509_INFO_new_null();
+    if (ret == NULL) {
+      return NULL;
     }
-    size_t orig_num = sk_X509_INFO_num(ret);
+  } else {
+    ret = sk;
+  }
+  size_t orig_num = sk_X509_INFO_num(ret);
 
-    info = X509_INFO_new();
-    if (info == NULL) {
-        goto err;
-    }
+  info = X509_INFO_new();
+  if (info == NULL) {
+    goto err;
+  }
 
-    for (;;) {
-        if (!PEM_read_bio(bp, &name, &header, &data, &len)) {
-            uint32_t error = ERR_peek_last_error();
-            if (ERR_GET_LIB(error) == ERR_LIB_PEM &&
-                ERR_GET_REASON(error) == PEM_R_NO_START_LINE) {
-                ERR_clear_error();
-                break;
-            }
-            goto err;
-        }
-
-        enum parse_result_t (*parse_function)(X509_INFO *, const uint8_t *,
-                                              size_t, int) = NULL;
-        int key_type = EVP_PKEY_NONE;
-        if (strcmp(name, PEM_STRING_X509) == 0 ||
-            strcmp(name, PEM_STRING_X509_OLD) == 0) {
-            parse_function = parse_x509;
-        } else if (strcmp(name, PEM_STRING_X509_TRUSTED) == 0) {
-            parse_function = parse_x509_aux;
-        } else if (strcmp(name, PEM_STRING_X509_CRL) == 0) {
-            parse_function = parse_crl;
-        } else if (strcmp(name, PEM_STRING_RSA) == 0) {
-            parse_function = parse_key;
-            key_type = EVP_PKEY_RSA;
-        } else if (strcmp(name, PEM_STRING_DSA) == 0) {
-            parse_function = parse_key;
-            key_type = EVP_PKEY_DSA;
-        } else if (strcmp(name, PEM_STRING_ECPRIVATEKEY) == 0) {
-            parse_function = parse_key;
-            key_type = EVP_PKEY_EC;
-        }
+  for (;;) {
+    if (!PEM_read_bio(bp, &name, &header, &data, &len)) {
+      uint32_t error = ERR_peek_last_error();
+      if (ERR_GET_LIB(error) == ERR_LIB_PEM &&
+          ERR_GET_REASON(error) == PEM_R_NO_START_LINE) {
+        ERR_clear_error();
+        break;
+      }
+      goto err;
+    }
 
-        /* If a private key has a header, assume it is encrypted. */
-        if (key_type != EVP_PKEY_NONE && strlen(header) > 10) {
-            if (info->x_pkey != NULL) {
-                if (!sk_X509_INFO_push(ret, info)) {
-                    goto err;
-                }
-                info = X509_INFO_new();
-                if (info == NULL) {
-                    goto err;
-                }
-            }
-            /* Historically, raw entries pushed an empty key. */
-            info->x_pkey = X509_PKEY_new();
-            if (info->x_pkey == NULL ||
-                !PEM_get_EVP_CIPHER_INFO(header, &info->enc_cipher)) {
-                goto err;
-            }
-            info->enc_data = (char *)data;
-            info->enc_len = (int)len;
-            data = NULL;
-        } else if (parse_function != NULL) {
-            EVP_CIPHER_INFO cipher;
-            if (!PEM_get_EVP_CIPHER_INFO(header, &cipher) ||
-                !PEM_do_header(&cipher, data, &len, cb, u)) {
-                goto err;
-            }
-            enum parse_result_t result =
-                parse_function(info, data, len, key_type);
-            if (result == parse_new_entry) {
-                if (!sk_X509_INFO_push(ret, info)) {
-                    goto err;
-                }
-                info = X509_INFO_new();
-                if (info == NULL) {
-                    goto err;
-                }
-                result = parse_function(info, data, len, key_type);
-            }
-            if (result != parse_ok) {
-                OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
-                goto err;
-            }
-        }
-        OPENSSL_free(name);
-        OPENSSL_free(header);
-        OPENSSL_free(data);
-        name = NULL;
-        header = NULL;
-        data = NULL;
+    enum parse_result_t (*parse_function)(X509_INFO *, const uint8_t *, size_t,
+                                          int) = NULL;
+    int key_type = EVP_PKEY_NONE;
+    if (strcmp(name, PEM_STRING_X509) == 0 ||
+        strcmp(name, PEM_STRING_X509_OLD) == 0) {
+      parse_function = parse_x509;
+    } else if (strcmp(name, PEM_STRING_X509_TRUSTED) == 0) {
+      parse_function = parse_x509_aux;
+    } else if (strcmp(name, PEM_STRING_X509_CRL) == 0) {
+      parse_function = parse_crl;
+    } else if (strcmp(name, PEM_STRING_RSA) == 0) {
+      parse_function = parse_key;
+      key_type = EVP_PKEY_RSA;
+    } else if (strcmp(name, PEM_STRING_DSA) == 0) {
+      parse_function = parse_key;
+      key_type = EVP_PKEY_DSA;
+    } else if (strcmp(name, PEM_STRING_ECPRIVATEKEY) == 0) {
+      parse_function = parse_key;
+      key_type = EVP_PKEY_EC;
     }
 
-    /* Push the last entry on the stack if not empty. */
-    if (info->x509 != NULL || info->crl != NULL ||
-        info->x_pkey != NULL || info->enc_data != NULL) {
+    // If a private key has a header, assume it is encrypted.
+    if (key_type != EVP_PKEY_NONE && strlen(header) > 10) {
+      if (info->x_pkey != NULL) {
         if (!sk_X509_INFO_push(ret, info)) {
-            goto err;
+          goto err;
         }
-        info = NULL;
-    }
-
-    ok = 1;
-
- err:
-    X509_INFO_free(info);
-    if (!ok) {
-        while (sk_X509_INFO_num(ret) > orig_num) {
-            X509_INFO_free(sk_X509_INFO_pop(ret));
+        info = X509_INFO_new();
+        if (info == NULL) {
+          goto err;
+        }
+      }
+      // Historically, raw entries pushed an empty key.
+      info->x_pkey = X509_PKEY_new();
+      if (info->x_pkey == NULL ||
+          !PEM_get_EVP_CIPHER_INFO(header, &info->enc_cipher)) {
+        goto err;
+      }
+      info->enc_data = (char *)data;
+      info->enc_len = (int)len;
+      data = NULL;
+    } else if (parse_function != NULL) {
+      EVP_CIPHER_INFO cipher;
+      if (!PEM_get_EVP_CIPHER_INFO(header, &cipher) ||
+          !PEM_do_header(&cipher, data, &len, cb, u)) {
+        goto err;
+      }
+      enum parse_result_t result = parse_function(info, data, len, key_type);
+      if (result == parse_new_entry) {
+        if (!sk_X509_INFO_push(ret, info)) {
+          goto err;
         }
-        if (ret != sk) {
-            sk_X509_INFO_free(ret);
+        info = X509_INFO_new();
+        if (info == NULL) {
+          goto err;
         }
-        ret = NULL;
+        result = parse_function(info, data, len, key_type);
+      }
+      if (result != parse_ok) {
+        OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
+        goto err;
+      }
     }
-
     OPENSSL_free(name);
     OPENSSL_free(header);
     OPENSSL_free(data);
-    return ret;
-}
-
-/* A TJH addition */
-int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc,
-                            unsigned char *kstr, int klen,
-                            pem_password_cb *cb, void *u)
-{
-    int i, ret = 0;
-    unsigned char *data = NULL;
-    const char *objstr = NULL;
-    char buf[PEM_BUFSIZE];
-    unsigned char *iv = NULL;
-    unsigned iv_len = 0;
+    name = NULL;
+    header = NULL;
+    data = NULL;
+  }
 
-    if (enc != NULL) {
-        iv_len = EVP_CIPHER_iv_length(enc);
-        objstr = OBJ_nid2sn(EVP_CIPHER_nid(enc));
-        if (objstr == NULL) {
-            OPENSSL_PUT_ERROR(PEM, PEM_R_UNSUPPORTED_CIPHER);
-            goto err;
-        }
+  // Push the last entry on the stack if not empty.
+  if (info->x509 != NULL || info->crl != NULL || info->x_pkey != NULL ||
+      info->enc_data != NULL) {
+    if (!sk_X509_INFO_push(ret, info)) {
+      goto err;
     }
+    info = NULL;
+  }
 
-    /*
-     * now for the fun part ... if we have a private key then we have to be
-     * able to handle a not-yet-decrypted key being written out correctly ...
-     * if it is decrypted or it is non-encrypted then we use the base code
-     */
-    if (xi->x_pkey != NULL) {
-        if ((xi->enc_data != NULL) && (xi->enc_len > 0)) {
-            if (enc == NULL) {
-                OPENSSL_PUT_ERROR(PEM, PEM_R_CIPHER_IS_NULL);
-                goto err;
-            }
-
-            /* copy from weirdo names into more normal things */
-            iv = xi->enc_cipher.iv;
-            data = (unsigned char *)xi->enc_data;
-            i = xi->enc_len;
-
-            /*
-             * we take the encryption data from the internal stuff rather
-             * than what the user has passed us ... as we have to match
-             * exactly for some strange reason
-             */
-            objstr = OBJ_nid2sn(EVP_CIPHER_nid(xi->enc_cipher.cipher));
-            if (objstr == NULL) {
-                OPENSSL_PUT_ERROR(PEM, PEM_R_UNSUPPORTED_CIPHER);
-                goto err;
-            }
+  ok = 1;
 
-            /* create the right magic header stuff */
-            assert(strlen(objstr) + 23 + 2 * iv_len + 13 <= sizeof buf);
-            buf[0] = '\0';
-            PEM_proc_type(buf, PEM_TYPE_ENCRYPTED);
-            PEM_dek_info(buf, objstr, iv_len, (char *)iv);
-
-            /* use the normal code to write things out */
-            i = PEM_write_bio(bp, PEM_STRING_RSA, buf, data, i);
-            if (i <= 0)
-                goto err;
-        } else {
-            /* Add DSA/DH */
-            /* normal optionally encrypted stuff */
-            if (PEM_write_bio_RSAPrivateKey(bp,
-                                            xi->x_pkey->dec_pkey->pkey.rsa,
-                                            enc, kstr, klen, cb, u) <= 0)
-                goto err;
-        }
+err:
+  X509_INFO_free(info);
+  if (!ok) {
+    while (sk_X509_INFO_num(ret) > orig_num) {
+      X509_INFO_free(sk_X509_INFO_pop(ret));
     }
+    if (ret != sk) {
+      sk_X509_INFO_free(ret);
+    }
+    ret = NULL;
+  }
 
-    /* if we have a certificate then write it out now */
-    if ((xi->x509 != NULL) && (PEM_write_bio_X509(bp, xi->x509) <= 0))
-        goto err;
-
-    /*
-     * we are ignoring anything else that is loaded into the X509_INFO
-     * structure for the moment ... as I don't need it so I'm not coding it
-     * here and Eric can do it when this makes it into the base library --tjh
-     */
-
-    ret = 1;
-
-err:
-  OPENSSL_cleanse(buf, PEM_BUFSIZE);
+  OPENSSL_free(name);
+  OPENSSL_free(header);
+  OPENSSL_free(data);
   return ret;
 }