/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 | } |