crypto/pkcs12/p12_decr.c

   1 /*
   2  * Copyright 1999-2021 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 "internal/cryptlib.h"
  12 #include <openssl/pkcs12.h>
  13 #include <openssl/trace.h>
  14
  15 /*
  16  * Encrypt/Decrypt a buffer based on password and algor, result in a
  17  * OPENSSL_malloc'ed buffer
  18  */
  19 unsigned char *PKCS12_pbe_crypt_ex(const X509_ALGOR *algor,
  20                                    const char *pass, int passlen,
  21                                    const unsigned char *in, int inlen,
  22                                    unsigned char **data, int *datalen, int en_de,
  23                                    OSSL_LIB_CTX *libctx, const char *propq)
  24 {
  25     unsigned char *out = NULL;
  26     int outlen, i;
  27     EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
  28     int max_out_len, mac_len = 0;
  29
  30     if (ctx == NULL) {
  31         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
  32         goto err;
  33     }
  34
  35     /* Process data */
  36     if (!EVP_PBE_CipherInit_ex(algor->algorithm, pass, passlen,
  37                                algor->parameter, ctx, en_de, libctx, propq))
  38         goto err;
  39
  40     /*
  41      * GOST algorithm specifics:
  42      * OMAC algorithm calculate and encrypt MAC of the encrypted objects
  43      * It's appended to encrypted text on encrypting
  44      * MAC should be processed on decrypting separately from plain text
  45      */
  46     max_out_len = inlen + EVP_CIPHER_CTX_block_size(ctx);
  47     if ((EVP_CIPHER_flags(EVP_CIPHER_CTX_get0_cipher(ctx))
  48                 & EVP_CIPH_FLAG_CIPHER_WITH_MAC) != 0) {
  49         if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD, 0, &mac_len) < 0) {
  50             ERR_raise(ERR_LIB_PKCS12, ERR_R_INTERNAL_ERROR);
  51             goto err;
  52         }
  53
  54         if (EVP_CIPHER_CTX_encrypting(ctx)) {
  55             max_out_len += mac_len;
  56         } else {
  57             if (inlen < mac_len) {
  58                 ERR_raise(ERR_LIB_PKCS12, PKCS12_R_UNSUPPORTED_PKCS12_MODE);
  59                 goto err;
  60             }
  61             inlen -= mac_len;
  62             if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
  63                                     (int)mac_len, (unsigned char *)in+inlen) < 0) {
  64                 ERR_raise(ERR_LIB_PKCS12, ERR_R_INTERNAL_ERROR);
  65                 goto err;
  66             }
  67         }
  68     }
  69
  70     if ((out = OPENSSL_malloc(max_out_len)) == NULL) {
  71         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
  72         goto err;
  73     }
  74
  75     if (!EVP_CipherUpdate(ctx, out, &i, in, inlen)) {
  76         OPENSSL_free(out);
  77         out = NULL;
  78         ERR_raise(ERR_LIB_PKCS12, ERR_R_EVP_LIB);
  79         goto err;
  80     }
  81
  82     outlen = i;
  83     if (!EVP_CipherFinal_ex(ctx, out + i, &i)) {
  84         OPENSSL_free(out);
  85         out = NULL;
  86         ERR_raise_data(ERR_LIB_PKCS12, PKCS12_R_PKCS12_CIPHERFINAL_ERROR,
  87                        passlen == 0 ? "empty password"
  88                        : "maybe wrong password");
  89         goto err;
  90     }
  91     outlen += i;
  92     if ((EVP_CIPHER_flags(EVP_CIPHER_CTX_get0_cipher(ctx))
  93                 & EVP_CIPH_FLAG_CIPHER_WITH_MAC) != 0) {
  94         if (EVP_CIPHER_CTX_encrypting(ctx)) {
  95             if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG,
  96                 (int)mac_len, out+outlen) < 0) {
  97                 ERR_raise(ERR_LIB_PKCS12, ERR_R_INTERNAL_ERROR);
  98                 goto err;
  99             }
 100             outlen += mac_len;
 101         }
 102     }
 103     if (datalen)
 104         *datalen = outlen;
 105     if (data)
 106         *data = out;
 107  err:
 108     EVP_CIPHER_CTX_free(ctx);
 109     return out;
 110
 111 }
 112
 113 unsigned char *PKCS12_pbe_crypt(const X509_ALGOR *algor,
 114                                 const char *pass, int passlen,
 115                                 const unsigned char *in, int inlen,
 116                                 unsigned char **data, int *datalen, int en_de)
 117 {
 118     return PKCS12_pbe_crypt_ex(algor, pass, passlen, in, inlen, data, datalen,
 119                                en_de, NULL, NULL);
 120 }
 121
 122 /*
 123  * Decrypt an OCTET STRING and decode ASN1 structure if zbuf set zero buffer
 124  * after use.
 125  */
 126
 127 void *PKCS12_item_decrypt_d2i_ex(const X509_ALGOR *algor, const ASN1_ITEM *it,
 128                                  const char *pass, int passlen,
 129                                  const ASN1_OCTET_STRING *oct, int zbuf,
 130                                  OSSL_LIB_CTX *libctx,
 131                                  const char *propq)
 132 {
 133     unsigned char *out = NULL;
 134     const unsigned char *p;
 135     void *ret;
 136     int outlen = 0;
 137
 138     if (!PKCS12_pbe_crypt_ex(algor, pass, passlen, oct->data, oct->length,
 139                              &out, &outlen, 0, libctx, propq))
 140         return NULL;
 141     p = out;
 142     OSSL_TRACE_BEGIN(PKCS12_DECRYPT) {
 143         BIO_printf(trc_out, "\n");
 144         BIO_dump(trc_out, out, outlen);
 145         BIO_printf(trc_out, "\n");
 146     } OSSL_TRACE_END(PKCS12_DECRYPT);
 147     ret = ASN1_item_d2i(NULL, &p, outlen, it);
 148     if (zbuf)
 149         OPENSSL_cleanse(out, outlen);
 150     if (!ret)
 151         ERR_raise(ERR_LIB_PKCS12, PKCS12_R_DECODE_ERROR);
 152     OPENSSL_free(out);
 153     return ret;
 154 }
 155
 156 void *PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it,
 157                               const char *pass, int passlen,
 158                               const ASN1_OCTET_STRING *oct, int zbuf)
 159 {
 160     return PKCS12_item_decrypt_d2i_ex(algor, it, pass, passlen, oct, zbuf,
 161                                       NULL, NULL);
 162 }
 163
 164 /*
 165  * Encode ASN1 structure and encrypt, return OCTET STRING if zbuf set zero
 166  * encoding.
 167  */
 168
 169 ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt_ex(X509_ALGOR *algor,
 170                                               const ASN1_ITEM *it,
 171                                               const char *pass, int passlen,
 172                                               void *obj, int zbuf,
 173                                               OSSL_LIB_CTX *ctx,
 174                                               const char *propq)
 175 {
 176     ASN1_OCTET_STRING *oct = NULL;
 177     unsigned char *in = NULL;
 178     int inlen;
 179
 180     if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
 181         ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
 182         goto err;
 183     }
 184     inlen = ASN1_item_i2d(obj, &in, it);
 185     if (!in) {
 186         ERR_raise(ERR_LIB_PKCS12, PKCS12_R_ENCODE_ERROR);
 187         goto err;
 188     }
 189     if (!PKCS12_pbe_crypt_ex(algor, pass, passlen, in, inlen, &oct->data,
 190                              &oct->length, 1, ctx, propq)) {
 191         ERR_raise(ERR_LIB_PKCS12, PKCS12_R_ENCRYPT_ERROR);
 192         OPENSSL_free(in);
 193         goto err;
 194     }
 195     if (zbuf)
 196         OPENSSL_cleanse(in, inlen);
 197     OPENSSL_free(in);
 198     return oct;
 199  err:
 200     ASN1_OCTET_STRING_free(oct);
 201     return NULL;
 202 }
 203
 204 ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor,
 205                                            const ASN1_ITEM *it,
 206                                            const char *pass, int passlen,
 207                                            void *obj, int zbuf)
 208 {
 209     return PKCS12_item_i2d_encrypt_ex(algor, it, pass, passlen, obj, zbuf, NULL, NULL);
 210 }