Coverage Report

Created: 2026-10-31 08:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/crypto/rsakey-builtin.c.inc
Line
Count
Source
1
/*
2
 * QEMU Crypto akcipher algorithms
3
 *
4
 * Copyright (c) 2022 Bytedance
5
 * Author: lei he <helei.sig11@bytedance.com>
6
 *
7
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * This library is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19
 *
20
 */
21
22
#include "der.h"
23
#include "rsakey.h"
24
25
static int extract_mpi(void *ctx, const uint8_t *value,
26
                       size_t vlen, Error **errp)
27
0
{
28
0
    QCryptoAkCipherMPI *mpi = (QCryptoAkCipherMPI *)ctx;
29
0
    if (vlen == 0) {
30
0
        error_setg(errp, "Empty mpi field");
31
0
        return -1;
32
0
    }
33
0
    mpi->data = g_memdup2(value, vlen);
34
0
    mpi->len = vlen;
35
0
    return 0;
36
0
}
37
38
static int extract_version(void *ctx, const uint8_t *value,
39
                           size_t vlen, Error **errp)
40
0
{
41
0
    uint8_t *version = (uint8_t *)ctx;
42
0
    if (vlen != 1 || *value > 1) {
43
0
        error_setg(errp, "Invalid rsakey version");
44
0
        return -1;
45
0
    }
46
0
    *version = *value;
47
0
    return 0;
48
0
}
49
50
static int extract_seq_content(void *ctx, const uint8_t *value,
51
                               size_t vlen, Error **errp)
52
0
{
53
0
    const uint8_t **content = (const uint8_t **)ctx;
54
0
    if (vlen == 0) {
55
0
        error_setg(errp, "Empty sequence");
56
0
        return -1;
57
0
    }
58
0
    *content = value;
59
0
    return 0;
60
0
}
61
62
/**
63
 *
64
 *        RsaPubKey ::= SEQUENCE {
65
 *             n           INTEGER
66
 *             e           INTEGER
67
 *         }
68
 */
69
static QCryptoAkCipherRSAKey *qcrypto_builtin_rsa_public_key_parse(
70
    const uint8_t *key, size_t keylen, Error **errp)
71
0
{
72
0
    QCryptoAkCipherRSAKey *rsa = g_new0(QCryptoAkCipherRSAKey, 1);
73
0
    const uint8_t *seq;
74
0
    size_t seq_length;
75
0
    int decode_ret;
76
77
0
    decode_ret = qcrypto_der_decode_seq(&key, &keylen,
78
0
                                        extract_seq_content, &seq, errp);
79
0
    if (decode_ret < 0 || keylen != 0) {
80
0
        goto error;
81
0
    }
82
0
    seq_length = decode_ret;
83
84
0
    if (qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
85
0
                               &rsa->n, errp) < 0 ||
86
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
87
0
                               &rsa->e, errp) < 0) {
88
0
        goto error;
89
0
    }
90
0
    if (seq_length != 0) {
91
0
        error_setg(errp, "Invalid RSA public key");
92
0
        goto error;
93
0
    }
94
95
0
    return rsa;
96
97
0
error:
98
0
    qcrypto_akcipher_rsakey_free(rsa);
99
0
    return NULL;
100
0
}
101
102
/**
103
 *        RsaPrivKey ::= SEQUENCE {
104
 *             version     INTEGER
105
 *             n           INTEGER
106
 *             e           INTEGER
107
 *             d           INTEGER
108
 *             p           INTEGER
109
 *             q           INTEGER
110
 *             dp          INTEGER
111
 *             dq          INTEGER
112
 *             u           INTEGER
113
 *       otherPrimeInfos   OtherPrimeInfos OPTIONAL
114
 *         }
115
 */
116
static QCryptoAkCipherRSAKey *qcrypto_builtin_rsa_private_key_parse(
117
    const uint8_t *key, size_t keylen, Error **errp)
118
0
{
119
0
    QCryptoAkCipherRSAKey *rsa = g_new0(QCryptoAkCipherRSAKey, 1);
120
0
    uint8_t version;
121
0
    const uint8_t *seq;
122
0
    int decode_ret;
123
0
    size_t seq_length;
124
125
0
    decode_ret = qcrypto_der_decode_seq(&key, &keylen, extract_seq_content,
126
0
                                        &seq, errp);
127
0
    if (decode_ret < 0 || keylen != 0) {
128
0
        goto error;
129
0
    }
130
0
    seq_length = decode_ret;
131
132
0
    decode_ret = qcrypto_der_decode_int(&seq, &seq_length, extract_version,
133
0
                                        &version, errp);
134
135
0
    if (qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
136
0
                               &rsa->n, errp) < 0 ||
137
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
138
0
                               &rsa->e, errp) < 0 ||
139
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
140
0
                               &rsa->d, errp) < 0 ||
141
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->p,
142
0
                               errp) < 0 ||
143
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->q,
144
0
                               errp) < 0 ||
145
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->dp,
146
0
                               errp) < 0 ||
147
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->dq,
148
0
                               errp) < 0 ||
149
0
        qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->u,
150
0
                               errp) < 0) {
151
0
        goto error;
152
0
    }
153
154
    /**
155
     * According to the standard, otherPrimeInfos must be present for version 1.
156
     * There is no strict verification here, this is to be compatible with
157
     * the unit test of the kernel. TODO: remove this until linux kernel's
158
     * unit-test is fixed.
159
     */
160
0
    if (version == 1 && seq_length != 0) {
161
0
        if (qcrypto_der_decode_seq(&seq, &seq_length, NULL, NULL, errp) < 0) {
162
0
            goto error;
163
0
        }
164
0
        if (seq_length != 0) {
165
0
            goto error;
166
0
        }
167
0
        return rsa;
168
0
    }
169
0
    if (seq_length != 0) {
170
0
        error_setg(errp, "Invalid RSA private key");
171
0
        goto error;
172
0
    }
173
174
0
    return rsa;
175
176
0
error:
177
0
    qcrypto_akcipher_rsakey_free(rsa);
178
0
    return NULL;
179
0
}
180
181
QCryptoAkCipherRSAKey *qcrypto_akcipher_rsakey_parse(
182
    QCryptoAkCipherKeyType type, const uint8_t *key,
183
    size_t keylen, Error **errp)
184
0
{
185
0
    switch (type) {
186
0
    case QCRYPTO_AK_CIPHER_KEY_TYPE_PRIVATE:
187
0
        return qcrypto_builtin_rsa_private_key_parse(key, keylen, errp);
188
189
0
    case QCRYPTO_AK_CIPHER_KEY_TYPE_PUBLIC:
190
0
        return qcrypto_builtin_rsa_public_key_parse(key, keylen, errp);
191
192
0
    default:
193
0
        error_setg(errp, "Unknown key type: %d", type);
194
        return NULL;
195
0
    }
196
0
}