Coverage Report

Created: 2026-11-16 07:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl/crypto/pkcs12/p12_sbag.c
Line
Count
Source
1
/*
2
 * Copyright 1999-2026 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/core_names.h>
14
#include <openssl/objects.h>
15
#include <openssl/param_build.h>
16
#include "p12_local.h"
17
#include "crypto/x509.h"
18
19
#ifndef OPENSSL_NO_DEPRECATED_1_1_0
20
const ASN1_TYPE *PKCS12_get_attr(const PKCS12_SAFEBAG *bag, int attr_nid)
21
0
{
22
0
    return PKCS12_get_attr_gen(bag->attrib, attr_nid);
23
0
}
24
#endif
25
26
const ASN1_TYPE *PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag,
27
    int attr_nid)
28
0
{
29
0
    return PKCS12_get_attr_gen(bag->attrib, attr_nid);
30
0
}
31
32
const ASN1_TYPE *PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid)
33
0
{
34
0
    return PKCS12_get_attr_gen(PKCS8_pkey_get0_attrs(p8), attr_nid);
35
0
}
36
37
const PKCS8_PRIV_KEY_INFO *PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag)
38
0
{
39
0
    if (PKCS12_SAFEBAG_get_nid(bag) != NID_keyBag)
40
0
        return NULL;
41
0
    return bag->value.keybag;
42
0
}
43
44
const X509_SIG *PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag)
45
0
{
46
0
    if (OBJ_obj2nid(bag->type) != NID_pkcs8ShroudedKeyBag)
47
0
        return NULL;
48
0
    return bag->value.shkeybag;
49
0
}
50
51
const STACK_OF(PKCS12_SAFEBAG) *
52
PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag)
53
0
{
54
0
    if (OBJ_obj2nid(bag->type) != NID_safeContentsBag)
55
0
        return NULL;
56
0
    return bag->value.safes;
57
0
}
58
59
const ASN1_OBJECT *PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag)
60
0
{
61
0
    return bag->type;
62
0
}
63
64
int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag)
65
0
{
66
0
    return OBJ_obj2nid(bag->type);
67
0
}
68
69
int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag)
70
0
{
71
0
    int btype = PKCS12_SAFEBAG_get_nid(bag);
72
73
0
    if (btype != NID_certBag && btype != NID_crlBag && btype != NID_secretBag)
74
0
        return -1;
75
0
    return OBJ_obj2nid(bag->value.bag->type);
76
0
}
77
78
const ASN1_OBJECT *PKCS12_SAFEBAG_get0_bag_type(const PKCS12_SAFEBAG *bag)
79
0
{
80
0
    int btype = PKCS12_SAFEBAG_get_nid(bag);
81
82
0
    if (btype != NID_certBag && btype != NID_crlBag && btype != NID_secretBag)
83
0
        return NULL;
84
0
    return bag->value.bag->type;
85
0
}
86
87
const ASN1_TYPE *PKCS12_SAFEBAG_get0_bag_obj(const PKCS12_SAFEBAG *bag)
88
0
{
89
0
    int vtype = PKCS12_SAFEBAG_get_bag_nid(bag);
90
91
0
    if (vtype == -1 || vtype == NID_x509Certificate || vtype == NID_x509Crl
92
0
        || vtype == NID_sdsiCertificate)
93
0
        return NULL;
94
0
    return bag->value.bag->value.other;
95
0
}
96
97
X509 *PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag)
98
0
{
99
0
    if (PKCS12_SAFEBAG_get_nid(bag) != NID_certBag)
100
0
        return NULL;
101
0
    if (OBJ_obj2nid(bag->value.bag->type) != NID_x509Certificate)
102
0
        return NULL;
103
0
    return ASN1_item_unpack(bag->value.bag->value.octet,
104
0
        ASN1_ITEM_rptr(X509));
105
0
}
106
107
X509_CRL *PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag)
108
0
{
109
0
    if (PKCS12_SAFEBAG_get_nid(bag) != NID_crlBag)
110
0
        return NULL;
111
0
    if (OBJ_obj2nid(bag->value.bag->type) != NID_x509Crl)
112
0
        return NULL;
113
0
    return ASN1_item_unpack(bag->value.bag->value.octet,
114
0
        ASN1_ITEM_rptr(X509_CRL));
115
0
}
116
117
X509 *PKCS12_SAFEBAG_get1_cert_ex(const PKCS12_SAFEBAG *bag,
118
    OSSL_LIB_CTX *libctx, const char *propq)
119
0
{
120
0
    if (PKCS12_SAFEBAG_get_nid(bag) != NID_certBag)
121
0
        return NULL;
122
0
    if (OBJ_obj2nid(bag->value.bag->type) != NID_x509Certificate)
123
0
        return NULL;
124
0
    return ASN1_item_unpack_ex(bag->value.bag->value.octet,
125
0
        ASN1_ITEM_rptr(X509), libctx, propq);
126
0
}
127
128
X509_CRL *PKCS12_SAFEBAG_get1_crl_ex(const PKCS12_SAFEBAG *bag,
129
    OSSL_LIB_CTX *libctx, const char *propq)
130
0
{
131
0
    X509_CRL *ret = NULL;
132
133
0
    if (PKCS12_SAFEBAG_get_nid(bag) != NID_crlBag)
134
0
        return NULL;
135
0
    if (OBJ_obj2nid(bag->value.bag->type) != NID_x509Crl)
136
0
        return NULL;
137
0
    ret = ASN1_item_unpack_ex(bag->value.bag->value.octet,
138
0
        ASN1_ITEM_rptr(X509_CRL), libctx, propq);
139
0
    if (!ossl_x509_crl_set0_libctx(ret, libctx, propq)) {
140
0
        X509_CRL_free(ret);
141
0
        return NULL;
142
0
    }
143
0
    return ret;
144
0
}
145
146
EVP_SKEY *PKCS8_PRIV_KEY_INFO_get1_skey(const PKCS8_PRIV_KEY_INFO *p8inf,
147
    OSSL_LIB_CTX *libctx, const char *propq,
148
    const OSSL_PARAM *extra_params, int strict)
149
0
{
150
0
    const ASN1_OBJECT *algoid = NULL;
151
0
    const X509_ALGOR *algor = NULL;
152
0
    const unsigned char *raw_key = NULL;
153
0
    int raw_key_len = 0;
154
0
    const char *skey_type = OSSL_SKEY_TYPE_GENERIC;
155
0
    unsigned char *oid_der = NULL;
156
0
    int oid_der_len = 0;
157
0
    unsigned char *params_der = NULL;
158
0
    int params_der_len = 0;
159
0
    OSSL_PARAM_BLD *bld = NULL;
160
0
    OSSL_PARAM *params = NULL;
161
0
    EVP_SKEY *skey = NULL;
162
163
0
    if (p8inf == NULL)
164
0
        return NULL;
165
166
0
    if (!PKCS8_pkey_get0(&algoid, &raw_key, &raw_key_len, &algor, p8inf)
167
0
        || raw_key == NULL || raw_key_len <= 0)
168
0
        return NULL;
169
170
0
    if (algoid != NULL) {
171
0
        int nid = OBJ_obj2nid(algoid);
172
173
0
        switch (nid) {
174
0
        case NID_id_aes:
175
0
            if (raw_key_len != 16 && raw_key_len != 24 && raw_key_len != 32)
176
0
                return NULL;
177
0
            skey_type = OSSL_SKEY_TYPE_AES;
178
0
            break;
179
0
        case NID_aes_128_cbc:
180
0
        case NID_aes_128_ccm:
181
0
        case NID_aes_128_ecb:
182
0
        case NID_aes_128_gcm:
183
0
            if (raw_key_len != 16)
184
0
                return NULL;
185
0
            skey_type = OSSL_SKEY_TYPE_AES;
186
0
            break;
187
0
        case NID_aes_192_cbc:
188
0
        case NID_aes_192_ccm:
189
0
        case NID_aes_192_ecb:
190
0
        case NID_aes_192_gcm:
191
0
            if (raw_key_len != 24)
192
0
                return NULL;
193
0
            skey_type = OSSL_SKEY_TYPE_AES;
194
0
            break;
195
0
        case NID_aes_256_cbc:
196
0
        case NID_aes_256_ccm:
197
0
        case NID_aes_256_ecb:
198
0
        case NID_aes_256_gcm:
199
0
            if (raw_key_len != 32)
200
0
                return NULL;
201
0
            skey_type = OSSL_SKEY_TYPE_AES;
202
0
            break;
203
0
        default:
204
0
            if (strict != 0)
205
0
                return NULL;
206
0
            break;
207
0
        }
208
0
    }
209
210
0
    bld = OSSL_PARAM_BLD_new();
211
0
    if (bld == NULL)
212
0
        return NULL;
213
214
0
    if (!OSSL_PARAM_BLD_push_octet_string(bld, OSSL_SKEY_PARAM_RAW_BYTES,
215
0
            raw_key, (size_t)raw_key_len))
216
0
        goto err;
217
218
0
    if (algoid != NULL) {
219
0
        oid_der_len = i2d_ASN1_OBJECT(algoid, &oid_der);
220
0
        if (oid_der_len > 0
221
0
            && !OSSL_PARAM_BLD_push_octet_string(bld,
222
0
                OSSL_SKEY_PARAM_ALGORITHM_OID,
223
0
                oid_der, (size_t)oid_der_len))
224
0
            goto err;
225
0
    }
226
227
0
    if (algor != NULL && algor->parameter != NULL
228
0
        && algor->parameter->type != V_ASN1_UNDEF) {
229
0
        params_der_len = i2d_ASN1_TYPE(algor->parameter, &params_der);
230
0
        if (params_der_len > 0
231
0
            && !OSSL_PARAM_BLD_push_octet_string(bld,
232
0
                OSSL_SKEY_PARAM_ALGORITHM_PARAMS,
233
0
                params_der, (size_t)params_der_len))
234
0
            goto err;
235
0
    }
236
237
0
    if (extra_params != NULL) {
238
0
        const OSSL_PARAM *p;
239
240
0
        for (p = extra_params; p->key != NULL; p++) {
241
0
            switch (p->data_type) {
242
0
            case OSSL_PARAM_UTF8_STRING:
243
0
                if (!OSSL_PARAM_BLD_push_utf8_string(bld,
244
0
                        p->key, p->data, p->data_size))
245
0
                    goto err;
246
0
                break;
247
0
            case OSSL_PARAM_OCTET_STRING:
248
0
                if (!OSSL_PARAM_BLD_push_octet_string(bld,
249
0
                        p->key, p->data, p->data_size))
250
0
                    goto err;
251
0
                break;
252
0
            default:
253
0
                break;
254
0
            }
255
0
        }
256
0
    }
257
258
0
    params = OSSL_PARAM_BLD_to_param(bld);
259
0
    if (params == NULL)
260
0
        goto err;
261
262
0
    skey = EVP_SKEY_import(libctx, skey_type, propq,
263
0
        OSSL_SKEYMGMT_SELECT_ALL, params);
264
265
0
err:
266
0
    OSSL_PARAM_BLD_free(bld);
267
0
    OSSL_PARAM_clear_free(params);
268
0
    OPENSSL_free(oid_der);
269
0
    OPENSSL_free(params_der);
270
0
    return skey;
271
0
}
272
273
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_cert(X509 *x509)
274
0
{
275
0
    return PKCS12_item_pack_safebag(x509, ASN1_ITEM_rptr(X509),
276
0
        NID_x509Certificate, NID_certBag);
277
0
}
278
279
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_crl(X509_CRL *crl)
280
0
{
281
0
    return PKCS12_item_pack_safebag(crl, ASN1_ITEM_rptr(X509_CRL),
282
0
        NID_x509Crl, NID_crlBag);
283
0
}
284
285
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_secret(int type, int vtype, const unsigned char *value, int len)
286
0
{
287
0
    PKCS12_BAGS *bag;
288
0
    PKCS12_SAFEBAG *safebag;
289
290
0
    if ((bag = PKCS12_BAGS_new()) == NULL) {
291
0
        ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
292
0
        return NULL;
293
0
    }
294
0
    bag->type = OBJ_nid2obj(type);
295
296
0
    switch (vtype) {
297
0
    case V_ASN1_OCTET_STRING: {
298
0
        ASN1_OCTET_STRING *strtmp = ASN1_OCTET_STRING_new();
299
300
0
        if (strtmp == NULL) {
301
0
            ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
302
0
            goto err;
303
0
        }
304
        /* Pack data into an octet string */
305
0
        if (!ASN1_OCTET_STRING_set(strtmp, value, len)) {
306
0
            ASN1_OCTET_STRING_free(strtmp);
307
0
            ERR_raise(ERR_LIB_PKCS12, PKCS12_R_ENCODE_ERROR);
308
0
            goto err;
309
0
        }
310
0
        bag->value.other = ASN1_TYPE_new();
311
0
        if (bag->value.other == NULL) {
312
0
            ASN1_OCTET_STRING_free(strtmp);
313
0
            ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
314
0
            goto err;
315
0
        }
316
0
        ASN1_TYPE_set(bag->value.other, vtype, strtmp);
317
0
    } break;
318
319
0
    default:
320
0
        ERR_raise(ERR_LIB_PKCS12, PKCS12_R_INVALID_TYPE);
321
0
        goto err;
322
0
    }
323
324
0
    if ((safebag = PKCS12_SAFEBAG_new()) == NULL) {
325
0
        ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
326
0
        goto err;
327
0
    }
328
0
    safebag->value.bag = bag;
329
0
    safebag->type = OBJ_nid2obj(NID_secretBag);
330
0
    return safebag;
331
332
0
err:
333
0
    PKCS12_BAGS_free(bag);
334
0
    return NULL;
335
0
}
336
337
/* Turn PKCS8 object into a keybag */
338
339
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8)
340
0
{
341
0
    PKCS12_SAFEBAG *bag = PKCS12_SAFEBAG_new();
342
343
0
    if (bag == NULL) {
344
0
        ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
345
0
        return NULL;
346
0
    }
347
0
    bag->type = OBJ_nid2obj(NID_keyBag);
348
0
    bag->value.keybag = p8;
349
0
    return bag;
350
0
}
351
352
/* Turn PKCS8 object into a shrouded keybag */
353
354
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8)
355
0
{
356
0
    PKCS12_SAFEBAG *bag = PKCS12_SAFEBAG_new();
357
358
    /* Set up the safe bag */
359
0
    if (bag == NULL) {
360
0
        ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
361
0
        return NULL;
362
0
    }
363
0
    bag->type = OBJ_nid2obj(NID_pkcs8ShroudedKeyBag);
364
0
    bag->value.shkeybag = p8;
365
0
    return bag;
366
0
}
367
368
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt_ex(int pbe_nid,
369
    const char *pass,
370
    int passlen,
371
    unsigned char *salt,
372
    int saltlen, int iter,
373
    PKCS8_PRIV_KEY_INFO *p8inf,
374
    OSSL_LIB_CTX *ctx,
375
    const char *propq)
376
0
{
377
0
    PKCS12_SAFEBAG *bag = NULL;
378
0
    EVP_CIPHER *pbe_ciph = NULL;
379
0
    X509_SIG *p8;
380
381
0
    ERR_set_mark();
382
0
    pbe_ciph = EVP_CIPHER_fetch(ctx, OBJ_nid2sn(pbe_nid), propq);
383
0
    ERR_pop_to_mark();
384
385
0
    if (pbe_ciph != NULL)
386
0
        pbe_nid = -1;
387
388
0
    p8 = PKCS8_encrypt_ex(pbe_nid, pbe_ciph, pass, passlen, salt, saltlen, iter,
389
0
        p8inf, ctx, propq);
390
0
    if (p8 == NULL)
391
0
        goto err;
392
393
0
    bag = PKCS12_SAFEBAG_create0_pkcs8(p8);
394
0
    if (bag == NULL)
395
0
        X509_SIG_free(p8);
396
397
0
err:
398
0
    EVP_CIPHER_free(pbe_ciph);
399
0
    return bag;
400
0
}
401
402
PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid,
403
    const char *pass,
404
    int passlen,
405
    unsigned char *salt,
406
    int saltlen, int iter,
407
    PKCS8_PRIV_KEY_INFO *p8inf)
408
0
{
409
0
    return PKCS12_SAFEBAG_create_pkcs8_encrypt_ex(pbe_nid, pass, passlen,
410
0
        salt, saltlen, iter, p8inf,
411
0
        NULL, NULL);
412
0
}