crypto/pkcs12/p12_mutl.c

   1 /*
   2  * Copyright 1999-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/crypto.h>
  13 # include <openssl/hmac.h>
  14 # include <openssl/rand.h>
  15 # include <openssl/pkcs12.h>
  16 # include "p12_lcl.h"
  17
  18 int PKCS12_mac_present(const PKCS12 *p12)
  19 {
  20     return p12->mac ? 1 : 0;
  21 }
  22
  23 void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac,
  24                      const X509_ALGOR **pmacalg,
  25                      const ASN1_OCTET_STRING **psalt,
  26                      const ASN1_INTEGER **piter,
  27                      const PKCS12 *p12)
  28 {
  29     if (p12->mac) {
  30         X509_SIG_get0(p12->mac->dinfo, pmacalg, pmac);
  31         if (psalt)
  32             *psalt = p12->mac->salt;
  33         if (piter)
  34             *piter = p12->mac->iter;
  35     } else {
  36         if (pmac)
  37             *pmac = NULL;
  38         if (pmacalg)
  39             *pmacalg = NULL;
  40         if (psalt)
  41             *psalt = NULL;
  42         if (piter)
  43             *piter = NULL;
  44     }
  45 }
  46
  47 # define TK26_MAC_KEY_LEN 32
  48
  49 static int pkcs12_gen_gost_mac_key(const char *pass, int passlen,
  50                                    const unsigned char *salt, int saltlen,
  51                                    int iter, int keylen, unsigned char *key,
  52                                    const EVP_MD *digest)
  53 {
  54     unsigned char out[96];
  55
  56     if (keylen != TK26_MAC_KEY_LEN) {
  57         return 0;
  58     }
  59
  60     if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter,
  61                            digest, sizeof(out), out)) {
  62         return 0;
  63     }
  64     memcpy(key, out + sizeof(out) - TK26_MAC_KEY_LEN, TK26_MAC_KEY_LEN);
  65     OPENSSL_cleanse(out, sizeof(out));
  66     return 1;
  67 }
  68
  69 /* Generate a MAC */
  70 int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen,
  71                    unsigned char *mac, unsigned int *maclen)
  72 {
  73     const EVP_MD *md_type;
  74     HMAC_CTX *hmac = NULL;
  75     unsigned char key[EVP_MAX_MD_SIZE], *salt;
  76     int saltlen, iter;
  77     int md_size = 0;
  78     int md_type_nid;
  79     const X509_ALGOR *macalg;
  80     const ASN1_OBJECT *macoid;
  81
  82     if (!PKCS7_type_is_data(p12->authsafes)) {
  83         PKCS12err(PKCS12_F_PKCS12_GEN_MAC, PKCS12_R_CONTENT_TYPE_NOT_DATA);
  84         return 0;
  85     }
  86
  87     salt = p12->mac->salt->data;
  88     saltlen = p12->mac->salt->length;
  89     if (!p12->mac->iter)
  90         iter = 1;
  91     else
  92         iter = ASN1_INTEGER_get(p12->mac->iter);
  93     X509_SIG_get0(p12->mac->dinfo, &macalg, NULL);
  94     X509_ALGOR_get0(&macoid, NULL, NULL, macalg);
  95     if ((md_type = EVP_get_digestbyobj(macoid)) == NULL) {
  96         PKCS12err(PKCS12_F_PKCS12_GEN_MAC, PKCS12_R_UNKNOWN_DIGEST_ALGORITHM);
  97         return 0;
  98     }
  99     md_size = EVP_MD_size(md_type);
 100     md_type_nid = EVP_MD_type(md_type);
 101     if (md_size < 0)
 102         return 0;
 103     if ((md_type_nid == NID_id_GostR3411_94
 104          || md_type_nid == NID_id_GostR3411_2012_256
 105          || md_type_nid == NID_id_GostR3411_2012_512)
 106         && !getenv("LEGACY_GOST_PKCS12")) {
 107         md_size = TK26_MAC_KEY_LEN;
 108         if (!pkcs12_gen_gost_mac_key(pass, passlen, salt, saltlen, iter,
 109                                      md_size, key, md_type)) {
 110             PKCS12err(PKCS12_F_PKCS12_GEN_MAC, PKCS12_R_KEY_GEN_ERROR);
 111             return 0;
 112         }
 113     } else
 114         if (!PKCS12_key_gen(pass, passlen, salt, saltlen, PKCS12_MAC_ID, iter,
 115                             md_size, key, md_type)) {
 116         PKCS12err(PKCS12_F_PKCS12_GEN_MAC, PKCS12_R_KEY_GEN_ERROR);
 117         return 0;
 118     }
 119     hmac = HMAC_CTX_new();
 120     if (!HMAC_Init_ex(hmac, key, md_size, md_type, NULL)
 121         || !HMAC_Update(hmac, p12->authsafes->d.data->data,
 122                         p12->authsafes->d.data->length)
 123         || !HMAC_Final(hmac, mac, maclen)) {
 124         HMAC_CTX_free(hmac);
 125         return 0;
 126     }
 127     HMAC_CTX_free(hmac);
 128     return 1;
 129 }
 130
 131 /* Verify the mac */
 132 int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen)
 133 {
 134     unsigned char mac[EVP_MAX_MD_SIZE];
 135     unsigned int maclen;
 136     const ASN1_OCTET_STRING *macoct;
 137
 138     if (p12->mac == NULL) {
 139         PKCS12err(PKCS12_F_PKCS12_VERIFY_MAC, PKCS12_R_MAC_ABSENT);
 140         return 0;
 141     }
 142     if (!PKCS12_gen_mac(p12, pass, passlen, mac, &maclen)) {
 143         PKCS12err(PKCS12_F_PKCS12_VERIFY_MAC, PKCS12_R_MAC_GENERATION_ERROR);
 144         return 0;
 145     }
 146     X509_SIG_get0(p12->mac->dinfo, NULL, &macoct);
 147     if ((maclen != (unsigned int)ASN1_STRING_length(macoct))
 148         || CRYPTO_memcmp(mac, ASN1_STRING_get0_data(macoct), maclen))
 149         return 0;
 150     return 1;
 151 }
 152
 153 /* Set a mac */
 154
 155 int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen,
 156                    unsigned char *salt, int saltlen, int iter,
 157                    const EVP_MD *md_type)
 158 {
 159     unsigned char mac[EVP_MAX_MD_SIZE];
 160     unsigned int maclen;
 161     ASN1_OCTET_STRING *macoct;
 162
 163     if (!md_type)
 164         md_type = EVP_sha1();
 165     if (PKCS12_setup_mac(p12, iter, salt, saltlen, md_type) == PKCS12_ERROR) {
 166         PKCS12err(PKCS12_F_PKCS12_SET_MAC, PKCS12_R_MAC_SETUP_ERROR);
 167         return 0;
 168     }
 169     if (!PKCS12_gen_mac(p12, pass, passlen, mac, &maclen)) {
 170         PKCS12err(PKCS12_F_PKCS12_SET_MAC, PKCS12_R_MAC_GENERATION_ERROR);
 171         return 0;
 172     }
 173     X509_SIG_get0_mutable(p12->mac->dinfo, NULL, &macoct);
 174     if (!ASN1_OCTET_STRING_set(macoct, mac, maclen)) {
 175         PKCS12err(PKCS12_F_PKCS12_SET_MAC, PKCS12_R_MAC_STRING_SET_ERROR);
 176         return 0;
 177     }
 178     return 1;
 179 }
 180
 181 /* Set up a mac structure */
 182 int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, int saltlen,
 183                      const EVP_MD *md_type)
 184 {
 185     X509_ALGOR *macalg;
 186
 187     if ((p12->mac = PKCS12_MAC_DATA_new()) == NULL)
 188         return PKCS12_ERROR;
 189     if (iter > 1) {
 190         if ((p12->mac->iter = ASN1_INTEGER_new()) == NULL) {
 191             PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
 192             return 0;
 193         }
 194         if (!ASN1_INTEGER_set(p12->mac->iter, iter)) {
 195             PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
 196             return 0;
 197         }
 198     }
 199     if (!saltlen)
 200         saltlen = PKCS12_SALT_LEN;
 201     if ((p12->mac->salt->data = OPENSSL_malloc(saltlen)) == NULL) {
 202         PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
 203         return 0;
 204     }
 205     p12->mac->salt->length = saltlen;
 206     if (!salt) {
 207         if (RAND_bytes(p12->mac->salt->data, saltlen) <= 0)
 208             return 0;
 209     } else
 210         memcpy(p12->mac->salt->data, salt, saltlen);
 211     X509_SIG_get0_mutable(p12->mac->dinfo, &macalg, NULL);
 212     if (!X509_ALGOR_set0(macalg, OBJ_nid2obj(EVP_MD_type(md_type)),
 213                          V_ASN1_NULL, NULL)) {
 214         PKCS12err(PKCS12_F_PKCS12_SETUP_MAC, ERR_R_MALLOC_FAILURE);
 215         return 0;
 216     }
 217
 218     return 1;
 219 }