xref: /openbmc/qemu/crypto/cipher-builtin.c.inc (revision b14df228) 
1/*
2 * QEMU Crypto cipher built-in algorithms
3 *
4 * Copyright (c) 2015 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21#include "crypto/aes.h"
22
23typedef struct QCryptoCipherBuiltinAESContext QCryptoCipherBuiltinAESContext;
24struct QCryptoCipherBuiltinAESContext {
25    AES_KEY enc;
26    AES_KEY dec;
27};
28
29typedef struct QCryptoCipherBuiltinAES QCryptoCipherBuiltinAES;
30struct QCryptoCipherBuiltinAES {
31    QCryptoCipher base;
32    QCryptoCipherBuiltinAESContext key;
33    uint8_t iv[AES_BLOCK_SIZE];
34};
35
36
37static inline bool qcrypto_length_check(size_t len, size_t blocksize,
38                                        Error **errp)
39{
40    if (unlikely(len & (blocksize - 1))) {
41        error_setg(errp, "Length %zu must be a multiple of block size %zu",
42                   len, blocksize);
43        return false;
44    }
45    return true;
46}
47
48static void qcrypto_cipher_ctx_free(QCryptoCipher *cipher)
49{
50    g_free(cipher);
51}
52
53static int qcrypto_cipher_no_setiv(QCryptoCipher *cipher,
54                                   const uint8_t *iv, size_t niv,
55                                   Error **errp)
56{
57    error_setg(errp, "Setting IV is not supported");
58    return -1;
59}
60
61static void do_aes_encrypt_ecb(const void *vctx,
62                               size_t len,
63                               uint8_t *out,
64                               const uint8_t *in)
65{
66    const QCryptoCipherBuiltinAESContext *ctx = vctx;
67
68    /* We have already verified that len % AES_BLOCK_SIZE == 0. */
69    while (len) {
70        AES_encrypt(in, out, &ctx->enc);
71        in += AES_BLOCK_SIZE;
72        out += AES_BLOCK_SIZE;
73        len -= AES_BLOCK_SIZE;
74    }
75}
76
77static void do_aes_decrypt_ecb(const void *vctx,
78                               size_t len,
79                               uint8_t *out,
80                               const uint8_t *in)
81{
82    const QCryptoCipherBuiltinAESContext *ctx = vctx;
83
84    /* We have already verified that len % AES_BLOCK_SIZE == 0. */
85    while (len) {
86        AES_decrypt(in, out, &ctx->dec);
87        in += AES_BLOCK_SIZE;
88        out += AES_BLOCK_SIZE;
89        len -= AES_BLOCK_SIZE;
90    }
91}
92
93static void do_aes_encrypt_cbc(const AES_KEY *key,
94                               size_t len,
95                               uint8_t *out,
96                               const uint8_t *in,
97                               uint8_t *ivec)
98{
99    uint8_t tmp[AES_BLOCK_SIZE];
100    size_t n;
101
102    /* We have already verified that len % AES_BLOCK_SIZE == 0. */
103    while (len) {
104        for (n = 0; n < AES_BLOCK_SIZE; ++n) {
105            tmp[n] = in[n] ^ ivec[n];
106        }
107        AES_encrypt(tmp, out, key);
108        memcpy(ivec, out, AES_BLOCK_SIZE);
109        len -= AES_BLOCK_SIZE;
110        in += AES_BLOCK_SIZE;
111        out += AES_BLOCK_SIZE;
112    }
113}
114
115static void do_aes_decrypt_cbc(const AES_KEY *key,
116                               size_t len,
117                               uint8_t *out,
118                               const uint8_t *in,
119                               uint8_t *ivec)
120{
121    uint8_t tmp[AES_BLOCK_SIZE];
122    size_t n;
123
124    /* We have already verified that len % AES_BLOCK_SIZE == 0. */
125    while (len) {
126        memcpy(tmp, in, AES_BLOCK_SIZE);
127        AES_decrypt(in, out, key);
128        for (n = 0; n < AES_BLOCK_SIZE; ++n) {
129            out[n] ^= ivec[n];
130        }
131        memcpy(ivec, tmp, AES_BLOCK_SIZE);
132        len -= AES_BLOCK_SIZE;
133        in += AES_BLOCK_SIZE;
134        out += AES_BLOCK_SIZE;
135    }
136}
137
138static int qcrypto_cipher_aes_encrypt_ecb(QCryptoCipher *cipher,
139                                          const void *in, void *out,
140                                          size_t len, Error **errp)
141{
142    QCryptoCipherBuiltinAES *ctx
143        = container_of(cipher, QCryptoCipherBuiltinAES, base);
144
145    if (!qcrypto_length_check(len, AES_BLOCK_SIZE, errp)) {
146        return -1;
147    }
148    do_aes_encrypt_ecb(&ctx->key, len, out, in);
149    return 0;
150}
151
152static int qcrypto_cipher_aes_decrypt_ecb(QCryptoCipher *cipher,
153                                          const void *in, void *out,
154                                          size_t len, Error **errp)
155{
156    QCryptoCipherBuiltinAES *ctx
157        = container_of(cipher, QCryptoCipherBuiltinAES, base);
158
159    if (!qcrypto_length_check(len, AES_BLOCK_SIZE, errp)) {
160        return -1;
161    }
162    do_aes_decrypt_ecb(&ctx->key, len, out, in);
163    return 0;
164}
165
166static int qcrypto_cipher_aes_encrypt_cbc(QCryptoCipher *cipher,
167                                          const void *in, void *out,
168                                          size_t len, Error **errp)
169{
170    QCryptoCipherBuiltinAES *ctx
171        = container_of(cipher, QCryptoCipherBuiltinAES, base);
172
173    if (!qcrypto_length_check(len, AES_BLOCK_SIZE, errp)) {
174        return -1;
175    }
176    do_aes_encrypt_cbc(&ctx->key.enc, len, out, in, ctx->iv);
177    return 0;
178}
179
180static int qcrypto_cipher_aes_decrypt_cbc(QCryptoCipher *cipher,
181                                          const void *in, void *out,
182                                          size_t len, Error **errp)
183{
184    QCryptoCipherBuiltinAES *ctx
185        = container_of(cipher, QCryptoCipherBuiltinAES, base);
186
187    if (!qcrypto_length_check(len, AES_BLOCK_SIZE, errp)) {
188        return -1;
189    }
190    do_aes_decrypt_cbc(&ctx->key.dec, len, out, in, ctx->iv);
191    return 0;
192}
193
194static int qcrypto_cipher_aes_setiv(QCryptoCipher *cipher, const uint8_t *iv,
195                             size_t niv, Error **errp)
196{
197    QCryptoCipherBuiltinAES *ctx
198        = container_of(cipher, QCryptoCipherBuiltinAES, base);
199
200    if (niv != AES_BLOCK_SIZE) {
201        error_setg(errp, "IV must be %d bytes not %zu",
202                   AES_BLOCK_SIZE, niv);
203        return -1;
204    }
205
206    memcpy(ctx->iv, iv, AES_BLOCK_SIZE);
207    return 0;
208}
209
210static const struct QCryptoCipherDriver qcrypto_cipher_aes_driver_ecb = {
211    .cipher_encrypt = qcrypto_cipher_aes_encrypt_ecb,
212    .cipher_decrypt = qcrypto_cipher_aes_decrypt_ecb,
213    .cipher_setiv = qcrypto_cipher_no_setiv,
214    .cipher_free = qcrypto_cipher_ctx_free,
215};
216
217static const struct QCryptoCipherDriver qcrypto_cipher_aes_driver_cbc = {
218    .cipher_encrypt = qcrypto_cipher_aes_encrypt_cbc,
219    .cipher_decrypt = qcrypto_cipher_aes_decrypt_cbc,
220    .cipher_setiv = qcrypto_cipher_aes_setiv,
221    .cipher_free = qcrypto_cipher_ctx_free,
222};
223
224bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
225                             QCryptoCipherMode mode)
226{
227    switch (alg) {
228    case QCRYPTO_CIPHER_ALG_AES_128:
229    case QCRYPTO_CIPHER_ALG_AES_192:
230    case QCRYPTO_CIPHER_ALG_AES_256:
231        switch (mode) {
232        case QCRYPTO_CIPHER_MODE_ECB:
233        case QCRYPTO_CIPHER_MODE_CBC:
234            return true;
235        default:
236            return false;
237        }
238        break;
239    default:
240        return false;
241    }
242}
243
244static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
245                                             QCryptoCipherMode mode,
246                                             const uint8_t *key,
247                                             size_t nkey,
248                                             Error **errp)
249{
250    if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
251        return NULL;
252    }
253
254    switch (alg) {
255    case QCRYPTO_CIPHER_ALG_AES_128:
256    case QCRYPTO_CIPHER_ALG_AES_192:
257    case QCRYPTO_CIPHER_ALG_AES_256:
258        {
259            QCryptoCipherBuiltinAES *ctx;
260            const QCryptoCipherDriver *drv;
261
262            switch (mode) {
263            case QCRYPTO_CIPHER_MODE_ECB:
264                drv = &qcrypto_cipher_aes_driver_ecb;
265                break;
266            case QCRYPTO_CIPHER_MODE_CBC:
267                drv = &qcrypto_cipher_aes_driver_cbc;
268                break;
269            default:
270                goto bad_mode;
271            }
272
273            ctx = g_new0(QCryptoCipherBuiltinAES, 1);
274            ctx->base.driver = drv;
275
276            if (AES_set_encrypt_key(key, nkey * 8, &ctx->key.enc)) {
277                error_setg(errp, "Failed to set encryption key");
278                goto error;
279            }
280            if (AES_set_decrypt_key(key, nkey * 8, &ctx->key.dec)) {
281                error_setg(errp, "Failed to set decryption key");
282                goto error;
283            }
284
285            return &ctx->base;
286
287        error:
288            g_free(ctx);
289            return NULL;
290        }
291
292    default:
293        error_setg(errp,
294                   "Unsupported cipher algorithm %s",
295                   QCryptoCipherAlgorithm_str(alg));
296        return NULL;
297    }
298
299 bad_mode:
300    error_setg(errp, "Unsupported cipher mode %s",
301               QCryptoCipherMode_str(mode));
302    return NULL;
303}
304