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