Constify X509_SIG.
[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(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 }