Coverage Report

Created: 2024-11-21 07:03

/src/openssl/crypto/asn1/i2d_evp.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1995-2023 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
/*
11
 * Low level APIs are deprecated for public use, but still ok for
12
 * internal use.
13
 */
14
#include "internal/deprecated.h"
15
16
#include <stdio.h>
17
#include "internal/cryptlib.h"
18
#include <openssl/evp.h>
19
#include <openssl/encoder.h>
20
#include <openssl/buffer.h>
21
#include <openssl/x509.h>
22
#include <openssl/rsa.h>         /* For i2d_RSAPublicKey */
23
#include <openssl/dsa.h>         /* For i2d_DSAPublicKey */
24
#include <openssl/ec.h>          /* For i2o_ECPublicKey */
25
#include "crypto/asn1.h"
26
#include "crypto/evp.h"
27
28
struct type_and_structure_st {
29
    const char *output_type;
30
    const char *output_structure;
31
};
32
33
static int i2d_provided(const EVP_PKEY *a, int selection,
34
                        const struct type_and_structure_st *output_info,
35
                        unsigned char **pp)
36
0
{
37
0
    int ret;
38
39
0
    for (ret = -1;
40
0
         ret == -1 && output_info->output_type != NULL;
41
0
         output_info++) {
42
        /*
43
         * The i2d_ calls don't take a boundary length for *pp.  However,
44
         * OSSL_ENCODER_to_data() needs one, so we make one up.  Because
45
         * OSSL_ENCODER_to_data() decrements this number by the amount of
46
         * bytes written, we need to calculate the length written further
47
         * down, when pp != NULL.
48
         */
49
0
        size_t len = INT_MAX;
50
0
        int pp_was_NULL = (pp == NULL || *pp == NULL);
51
0
        OSSL_ENCODER_CTX *ctx;
52
53
0
        ctx = OSSL_ENCODER_CTX_new_for_pkey(a, selection,
54
0
                                            output_info->output_type,
55
0
                                            output_info->output_structure,
56
0
                                            NULL);
57
0
        if (ctx == NULL)
58
0
            return -1;
59
0
        if (OSSL_ENCODER_to_data(ctx, pp, &len)) {
60
0
            if (pp_was_NULL)
61
0
                ret = (int)len;
62
0
            else
63
0
                ret = INT_MAX - (int)len;
64
0
        }
65
0
        OSSL_ENCODER_CTX_free(ctx);
66
0
    }
67
68
0
    if (ret == -1)
69
0
        ERR_raise(ERR_LIB_ASN1, ASN1_R_UNSUPPORTED_TYPE);
70
0
    return ret;
71
0
}
72
73
int i2d_KeyParams(const EVP_PKEY *a, unsigned char **pp)
74
0
{
75
0
    if (evp_pkey_is_provided(a)) {
76
0
        static const struct type_and_structure_st output_info[] = {
77
0
            { "DER", "type-specific" },
78
0
            { NULL, }
79
0
        };
80
81
0
        return i2d_provided(a, EVP_PKEY_KEY_PARAMETERS, output_info, pp);
82
0
    }
83
0
    if (a->ameth != NULL && a->ameth->param_encode != NULL)
84
0
        return a->ameth->param_encode(a, pp);
85
0
    ERR_raise(ERR_LIB_ASN1, ASN1_R_UNSUPPORTED_TYPE);
86
0
    return -1;
87
0
}
88
89
int i2d_KeyParams_bio(BIO *bp, const EVP_PKEY *pkey)
90
0
{
91
0
    return ASN1_i2d_bio_of(EVP_PKEY, i2d_KeyParams, bp, pkey);
92
0
}
93
94
int i2d_PrivateKey(const EVP_PKEY *a, unsigned char **pp)
95
0
{
96
0
    if (evp_pkey_is_provided(a)) {
97
0
        static const struct type_and_structure_st output_info[] = {
98
0
            { "DER", "type-specific" },
99
0
            { "DER", "PrivateKeyInfo" },
100
0
            { NULL, }
101
0
        };
102
103
0
        return i2d_provided(a, EVP_PKEY_KEYPAIR, output_info, pp);
104
0
    }
105
0
    if (a->ameth != NULL && a->ameth->old_priv_encode != NULL) {
106
0
        return a->ameth->old_priv_encode(a, pp);
107
0
    }
108
0
    if (a->ameth != NULL && a->ameth->priv_encode != NULL) {
109
0
        PKCS8_PRIV_KEY_INFO *p8 = EVP_PKEY2PKCS8(a);
110
0
        int ret = 0;
111
112
0
        if (p8 != NULL) {
113
0
            ret = i2d_PKCS8_PRIV_KEY_INFO(p8, pp);
114
0
            PKCS8_PRIV_KEY_INFO_free(p8);
115
0
        }
116
0
        return ret;
117
0
    }
118
0
    ERR_raise(ERR_LIB_ASN1, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
119
0
    return -1;
120
0
}
121
122
int i2d_PublicKey(const EVP_PKEY *a, unsigned char **pp)
123
0
{
124
0
    if (evp_pkey_is_provided(a)) {
125
0
        static const struct type_and_structure_st output_info[] = {
126
0
            { "DER", "type-specific" },
127
0
            { "blob", NULL },    /* for EC */
128
0
            { NULL, }
129
0
        };
130
131
0
        return i2d_provided(a, EVP_PKEY_PUBLIC_KEY, output_info, pp);
132
0
    }
133
0
    switch (EVP_PKEY_get_base_id(a)) {
134
0
    case EVP_PKEY_RSA:
135
0
        return i2d_RSAPublicKey(EVP_PKEY_get0_RSA(a), pp);
136
0
#ifndef OPENSSL_NO_DSA
137
0
    case EVP_PKEY_DSA:
138
0
        return i2d_DSAPublicKey(EVP_PKEY_get0_DSA(a), pp);
139
0
#endif
140
0
#ifndef OPENSSL_NO_EC
141
0
    case EVP_PKEY_EC:
142
0
        return i2o_ECPublicKey(EVP_PKEY_get0_EC_KEY(a), pp);
143
0
#endif
144
0
    default:
145
0
        ERR_raise(ERR_LIB_ASN1, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
146
0
        return -1;
147
0
    }
148
0
}