26698d7a30e7fe9c26650410b8423555c9c80e0f
[xfstests-dev.git] / src / fscrypt-crypt-util.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * fscrypt-crypt-util.c - utility for verifying fscrypt-encrypted data
4  *
5  * Copyright 2019 Google LLC
6  */
7
8 /*
9  * This program implements all crypto algorithms supported by fscrypt (a.k.a.
10  * ext4, f2fs, and ubifs encryption), for the purpose of verifying the
11  * correctness of the ciphertext stored on-disk.  See usage() below.
12  *
13  * All algorithms are implemented in portable C code to avoid depending on
14  * libcrypto (OpenSSL), and because some fscrypt-supported algorithms aren't
15  * available in libcrypto anyway (e.g. Adiantum), or are only supported in
16  * recent versions (e.g. HKDF-SHA512).  For simplicity, all crypto code here
17  * tries to follow the mathematical definitions directly, without optimizing for
18  * performance or worrying about following security best practices such as
19  * mitigating side-channel attacks.  So, only use this program for testing!
20  */
21
22 #include <asm/byteorder.h>
23 #include <errno.h>
24 #include <getopt.h>
25 #include <limits.h>
26 #include <linux/types.h>
27 #include <stdarg.h>
28 #include <stdbool.h>
29 #include <stdint.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34
35 #define PROGRAM_NAME "fscrypt-crypt-util"
36
37 /*
38  * Define to enable the tests of the crypto code in this file.  If enabled, you
39  * must link this program with OpenSSL (-lcrypto) v1.1.0 or later, and your
40  * kernel needs CONFIG_CRYPTO_USER_API_SKCIPHER=y and CONFIG_CRYPTO_ADIANTUM=y.
41  */
42 #undef ENABLE_ALG_TESTS
43
44 #define NUM_ALG_TEST_ITERATIONS 10000
45
46 static void usage(FILE *fp)
47 {
48         fputs(
49 "Usage: " PROGRAM_NAME " [OPTION]... CIPHER MASTER_KEY\n"
50 "\n"
51 "Utility for verifying fscrypt-encrypted data.  This program encrypts\n"
52 "(or decrypts) the data on stdin using the given CIPHER with the given\n"
53 "MASTER_KEY (or a key derived from it, if a KDF is specified), and writes the\n"
54 "resulting ciphertext (or plaintext) to stdout.\n"
55 "\n"
56 "CIPHER can be AES-256-XTS, AES-256-CTS-CBC, AES-128-CBC-ESSIV, AES-128-CTS-CBC,\n"
57 "or Adiantum.  MASTER_KEY must be a hex string long enough for the cipher.\n"
58 "\n"
59 "WARNING: this program is only meant for testing, not for \"real\" use!\n"
60 "\n"
61 "Options:\n"
62 "  --block-number=BNUM         Starting block number for IV generation.\n"
63 "                                Default: 0\n"
64 "  --block-size=BLOCK_SIZE     Encrypt each BLOCK_SIZE bytes independently.\n"
65 "                                Default: 4096 bytes\n"
66 "  --decrypt                   Decrypt instead of encrypt\n"
67 "  --file-nonce=NONCE          File's nonce as a 32-character hex string\n"
68 "  --fs-uuid=UUID              The filesystem UUID as a 32-character hex string.\n"
69 "                                Required for --iv-ino-lblk-32 and\n"
70 "                                --iv-ino-lblk-64; otherwise is unused.\n"
71 "  --help                      Show this help\n"
72 "  --inode-number=INUM         The file's inode number.  Required for\n"
73 "                                --iv-ino-lblk-32 and --iv-ino-lblk-64;\n"
74 "                                otherwise is unused.\n"
75 "  --iv-ino-lblk-32            Similar to --iv-ino-lblk-64, but selects the\n"
76 "                                32-bit variant.\n"
77 "  --iv-ino-lblk-64            Use the format where the IVs include the inode\n"
78 "                                number and the same key is shared across files.\n"
79 "                                Requires --kdf=HKDF-SHA512, --fs-uuid,\n"
80 "                                --inode-number, and --mode-num.\n"
81 "  --kdf=KDF                   Key derivation function to use: AES-128-ECB,\n"
82 "                                HKDF-SHA512, or none.  Default: none\n"
83 "  --mode-num=NUM              Derive per-mode key using mode number NUM\n"
84 "  --padding=PADDING           If last block is partial, zero-pad it to next\n"
85 "                                PADDING-byte boundary.  Default: BLOCK_SIZE\n"
86         , fp);
87 }
88
89 /*----------------------------------------------------------------------------*
90  *                                 Utilities                                  *
91  *----------------------------------------------------------------------------*/
92
93 #define ARRAY_SIZE(A)           (sizeof(A) / sizeof((A)[0]))
94 #define MIN(x, y)               ((x) < (y) ? (x) : (y))
95 #define MAX(x, y)               ((x) > (y) ? (x) : (y))
96 #define ROUND_DOWN(x, y)        ((x) & ~((y) - 1))
97 #define ROUND_UP(x, y)          (((x) + (y) - 1) & ~((y) - 1))
98 #define DIV_ROUND_UP(n, d)      (((n) + (d) - 1) / (d))
99 #define STATIC_ASSERT(e)        ((void)sizeof(char[1 - 2*!(e)]))
100
101 typedef __u8                    u8;
102 typedef __u16                   u16;
103 typedef __u32                   u32;
104 typedef __u64                   u64;
105
106 #define cpu_to_le32             __cpu_to_le32
107 #define cpu_to_be32             __cpu_to_be32
108 #define cpu_to_le64             __cpu_to_le64
109 #define cpu_to_be64             __cpu_to_be64
110 #define le32_to_cpu             __le32_to_cpu
111 #define be32_to_cpu             __be32_to_cpu
112 #define le64_to_cpu             __le64_to_cpu
113 #define be64_to_cpu             __be64_to_cpu
114
115 #define DEFINE_UNALIGNED_ACCESS_HELPERS(type, native_type)      \
116 static inline native_type __attribute__((unused))               \
117 get_unaligned_##type(const void *p)                             \
118 {                                                               \
119         __##type x;                                             \
120                                                                 \
121         memcpy(&x, p, sizeof(x));                               \
122         return type##_to_cpu(x);                                \
123 }                                                               \
124                                                                 \
125 static inline void __attribute__((unused))                      \
126 put_unaligned_##type(native_type v, void *p)                    \
127 {                                                               \
128         __##type x = cpu_to_##type(v);                          \
129                                                                 \
130         memcpy(p, &x, sizeof(x));                               \
131 }
132
133 DEFINE_UNALIGNED_ACCESS_HELPERS(le32, u32)
134 DEFINE_UNALIGNED_ACCESS_HELPERS(be32, u32)
135 DEFINE_UNALIGNED_ACCESS_HELPERS(le64, u64)
136 DEFINE_UNALIGNED_ACCESS_HELPERS(be64, u64)
137
138 static inline bool is_power_of_2(unsigned long v)
139 {
140         return v != 0 && (v & (v - 1)) == 0;
141 }
142
143 static inline u32 rol32(u32 v, int n)
144 {
145         return (v << n) | (v >> (32 - n));
146 }
147
148 static inline u32 ror32(u32 v, int n)
149 {
150         return (v >> n) | (v << (32 - n));
151 }
152
153 static inline u64 rol64(u64 v, int n)
154 {
155         return (v << n) | (v >> (64 - n));
156 }
157
158 static inline u64 ror64(u64 v, int n)
159 {
160         return (v >> n) | (v << (64 - n));
161 }
162
163 static inline void xor(u8 *res, const u8 *a, const u8 *b, size_t count)
164 {
165         while (count--)
166                 *res++ = *a++ ^ *b++;
167 }
168
169 static void __attribute__((noreturn, format(printf, 2, 3)))
170 do_die(int err, const char *format, ...)
171 {
172         va_list va;
173
174         va_start(va, format);
175         fputs("[" PROGRAM_NAME "] ERROR: ", stderr);
176         vfprintf(stderr, format, va);
177         if (err)
178                 fprintf(stderr, ": %s", strerror(errno));
179         putc('\n', stderr);
180         va_end(va);
181         exit(1);
182 }
183
184 #define die(format, ...)        do_die(0,     (format), ##__VA_ARGS__)
185 #define die_errno(format, ...)  do_die(errno, (format), ##__VA_ARGS__)
186
187 static __attribute__((noreturn)) void
188 assertion_failed(const char *expr, const char *file, int line)
189 {
190         die("Assertion failed: %s at %s:%d", expr, file, line);
191 }
192
193 #define ASSERT(e) ({ if (!(e)) assertion_failed(#e, __FILE__, __LINE__); })
194
195 static void *xmalloc(size_t size)
196 {
197         void *p = malloc(size);
198
199         ASSERT(p != NULL);
200         return p;
201 }
202
203 static int hexchar2bin(char c)
204 {
205         if (c >= 'a' && c <= 'f')
206                 return 10 + c - 'a';
207         if (c >= 'A' && c <= 'F')
208                 return 10 + c - 'A';
209         if (c >= '0' && c <= '9')
210                 return c - '0';
211         return -1;
212 }
213
214 static int hex2bin(const char *hex, u8 *bin, int max_bin_size)
215 {
216         size_t len = strlen(hex);
217         size_t i;
218
219         if (len & 1)
220                 return -1;
221         len /= 2;
222         if (len > max_bin_size)
223                 return -1;
224
225         for (i = 0; i < len; i++) {
226                 int high = hexchar2bin(hex[2 * i]);
227                 int low = hexchar2bin(hex[2 * i + 1]);
228
229                 if (high < 0 || low < 0)
230                         return -1;
231                 bin[i] = (high << 4) | low;
232         }
233         return len;
234 }
235
236 static size_t xread(int fd, void *buf, size_t count)
237 {
238         const size_t orig_count = count;
239
240         while (count) {
241                 ssize_t res = read(fd, buf, count);
242
243                 if (res < 0)
244                         die_errno("read error");
245                 if (res == 0)
246                         break;
247                 buf += res;
248                 count -= res;
249         }
250         return orig_count - count;
251 }
252
253 static void full_write(int fd, const void *buf, size_t count)
254 {
255         while (count) {
256                 ssize_t res = write(fd, buf, count);
257
258                 if (res < 0)
259                         die_errno("write error");
260                 buf += res;
261                 count -= res;
262         }
263 }
264
265 #ifdef ENABLE_ALG_TESTS
266 static void rand_bytes(u8 *buf, size_t count)
267 {
268         while (count--)
269                 *buf++ = rand();
270 }
271 #endif
272
273 /*----------------------------------------------------------------------------*
274  *                          Finite field arithmetic                           *
275  *----------------------------------------------------------------------------*/
276
277 /* Multiply a GF(2^8) element by the polynomial 'x' */
278 static inline u8 gf2_8_mul_x(u8 b)
279 {
280         return (b << 1) ^ ((b & 0x80) ? 0x1B : 0);
281 }
282
283 /* Multiply four packed GF(2^8) elements by the polynomial 'x' */
284 static inline u32 gf2_8_mul_x_4way(u32 w)
285 {
286         return ((w & 0x7F7F7F7F) << 1) ^ (((w & 0x80808080) >> 7) * 0x1B);
287 }
288
289 /* Element of GF(2^128) */
290 typedef struct {
291         __le64 lo;
292         __le64 hi;
293 } ble128;
294
295 /* Multiply a GF(2^128) element by the polynomial 'x' */
296 static inline void gf2_128_mul_x(ble128 *t)
297 {
298         u64 lo = le64_to_cpu(t->lo);
299         u64 hi = le64_to_cpu(t->hi);
300
301         t->hi = cpu_to_le64((hi << 1) | (lo >> 63));
302         t->lo = cpu_to_le64((lo << 1) ^ ((hi & (1ULL << 63)) ? 0x87 : 0));
303 }
304
305 /*----------------------------------------------------------------------------*
306  *                             Group arithmetic                               *
307  *----------------------------------------------------------------------------*/
308
309 /* Element of Z/(2^{128}Z)  (a.k.a. the integers modulo 2^128) */
310 typedef struct {
311         __le64 lo;
312         __le64 hi;
313 } le128;
314
315 static inline void le128_add(le128 *res, const le128 *a, const le128 *b)
316 {
317         u64 a_lo = le64_to_cpu(a->lo);
318         u64 b_lo = le64_to_cpu(b->lo);
319
320         res->lo = cpu_to_le64(a_lo + b_lo);
321         res->hi = cpu_to_le64(le64_to_cpu(a->hi) + le64_to_cpu(b->hi) +
322                               (a_lo + b_lo < a_lo));
323 }
324
325 static inline void le128_sub(le128 *res, const le128 *a, const le128 *b)
326 {
327         u64 a_lo = le64_to_cpu(a->lo);
328         u64 b_lo = le64_to_cpu(b->lo);
329
330         res->lo = cpu_to_le64(a_lo - b_lo);
331         res->hi = cpu_to_le64(le64_to_cpu(a->hi) - le64_to_cpu(b->hi) -
332                               (a_lo - b_lo > a_lo));
333 }
334
335 /*----------------------------------------------------------------------------*
336  *                              AES block cipher                              *
337  *----------------------------------------------------------------------------*/
338
339 /*
340  * Reference: "FIPS 197, Advanced Encryption Standard"
341  *      https://nvlpubs.nist.gov/nistpubs/fips/nist.fips.197.pdf
342  */
343
344 #define AES_BLOCK_SIZE          16
345 #define AES_128_KEY_SIZE        16
346 #define AES_192_KEY_SIZE        24
347 #define AES_256_KEY_SIZE        32
348
349 static inline void AddRoundKey(u32 state[4], const u32 *rk)
350 {
351         int i;
352
353         for (i = 0; i < 4; i++)
354                 state[i] ^= rk[i];
355 }
356
357 static const u8 aes_sbox[256] = {
358         0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
359         0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
360         0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
361         0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
362         0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
363         0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
364         0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
365         0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
366         0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
367         0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
368         0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
369         0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
370         0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
371         0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
372         0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
373         0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
374         0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
375         0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
376         0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
377         0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
378         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
379         0xb0, 0x54, 0xbb, 0x16,
380 };
381
382 static u8 aes_inverse_sbox[256];
383
384 static void aes_init(void)
385 {
386         int i;
387
388         for (i = 0; i < 256; i++)
389                 aes_inverse_sbox[aes_sbox[i]] = i;
390 }
391
392 static inline u32 DoSubWord(u32 w, const u8 sbox[256])
393 {
394         return ((u32)sbox[(u8)(w >> 24)] << 24) |
395                ((u32)sbox[(u8)(w >> 16)] << 16) |
396                ((u32)sbox[(u8)(w >>  8)] <<  8) |
397                ((u32)sbox[(u8)(w >>  0)] <<  0);
398 }
399
400 static inline u32 SubWord(u32 w)
401 {
402         return DoSubWord(w, aes_sbox);
403 }
404
405 static inline u32 InvSubWord(u32 w)
406 {
407         return DoSubWord(w, aes_inverse_sbox);
408 }
409
410 static inline void SubBytes(u32 state[4])
411 {
412         int i;
413
414         for (i = 0; i < 4; i++)
415                 state[i] = SubWord(state[i]);
416 }
417
418 static inline void InvSubBytes(u32 state[4])
419 {
420         int i;
421
422         for (i = 0; i < 4; i++)
423                 state[i] = InvSubWord(state[i]);
424 }
425
426 static inline void DoShiftRows(u32 state[4], int direction)
427 {
428         u32 newstate[4];
429         int i;
430
431         for (i = 0; i < 4; i++)
432                 newstate[i] = (state[(i + direction*0) & 3] & 0xff) |
433                               (state[(i + direction*1) & 3] & 0xff00) |
434                               (state[(i + direction*2) & 3] & 0xff0000) |
435                               (state[(i + direction*3) & 3] & 0xff000000);
436         memcpy(state, newstate, 16);
437 }
438
439 static inline void ShiftRows(u32 state[4])
440 {
441         DoShiftRows(state, 1);
442 }
443
444 static inline void InvShiftRows(u32 state[4])
445 {
446         DoShiftRows(state, -1);
447 }
448
449 /*
450  * Mix one column by doing the following matrix multiplication in GF(2^8):
451  *
452  *     | 2 3 1 1 |   | w[0] |
453  *     | 1 2 3 1 |   | w[1] |
454  *     | 1 1 2 3 | x | w[2] |
455  *     | 3 1 1 2 |   | w[3] |
456  *
457  * a.k.a. w[i] = 2*w[i] + 3*w[(i+1)%4] + w[(i+2)%4] + w[(i+3)%4]
458  */
459 static inline u32 MixColumn(u32 w)
460 {
461         u32 _2w0_w2 = gf2_8_mul_x_4way(w) ^ ror32(w, 16);
462         u32 _3w1_w3 = ror32(_2w0_w2 ^ w, 8);
463
464         return _2w0_w2 ^ _3w1_w3;
465 }
466
467 /*
468  *           ( | 5 0 4 0 |   | w[0] | )
469  *          (  | 0 5 0 4 |   | w[1] |  )
470  * MixColumn(  | 4 0 5 0 | x | w[2] |  )
471  *           ( | 0 4 0 5 |   | w[3] | )
472  */
473 static inline u32 InvMixColumn(u32 w)
474 {
475         u32 _4w = gf2_8_mul_x_4way(gf2_8_mul_x_4way(w));
476
477         return MixColumn(_4w ^ w ^ ror32(_4w, 16));
478 }
479
480 static inline void MixColumns(u32 state[4])
481 {
482         int i;
483
484         for (i = 0; i < 4; i++)
485                 state[i] = MixColumn(state[i]);
486 }
487
488 static inline void InvMixColumns(u32 state[4])
489 {
490         int i;
491
492         for (i = 0; i < 4; i++)
493                 state[i] = InvMixColumn(state[i]);
494 }
495
496 struct aes_key {
497         u32 round_keys[15 * 4];
498         int nrounds;
499 };
500
501 /* Expand an AES key */
502 static void aes_setkey(struct aes_key *k, const u8 *key, int keysize)
503 {
504         const int N = keysize / 4;
505         u32 * const rk = k->round_keys;
506         u8 rcon = 1;
507         int i;
508
509         ASSERT(keysize == 16 || keysize == 24 || keysize == 32);
510         k->nrounds = 6 + N;
511         for (i = 0; i < 4 * (k->nrounds + 1); i++) {
512                 if (i < N) {
513                         rk[i] = get_unaligned_le32(&key[i * sizeof(__le32)]);
514                 } else if (i % N == 0) {
515                         rk[i] = rk[i - N] ^ SubWord(ror32(rk[i - 1], 8)) ^ rcon;
516                         rcon = gf2_8_mul_x(rcon);
517                 } else if (N > 6 && i % N == 4) {
518                         rk[i] = rk[i - N] ^ SubWord(rk[i - 1]);
519                 } else {
520                         rk[i] = rk[i - N] ^ rk[i - 1];
521                 }
522         }
523 }
524
525 /* Encrypt one 16-byte block with AES */
526 static void aes_encrypt(const struct aes_key *k, const u8 src[AES_BLOCK_SIZE],
527                         u8 dst[AES_BLOCK_SIZE])
528 {
529         u32 state[4];
530         int i;
531
532         for (i = 0; i < 4; i++)
533                 state[i] = get_unaligned_le32(&src[i * sizeof(__le32)]);
534
535         AddRoundKey(state, k->round_keys);
536         for (i = 1; i < k->nrounds; i++) {
537                 SubBytes(state);
538                 ShiftRows(state);
539                 MixColumns(state);
540                 AddRoundKey(state, &k->round_keys[4 * i]);
541         }
542         SubBytes(state);
543         ShiftRows(state);
544         AddRoundKey(state, &k->round_keys[4 * i]);
545
546         for (i = 0; i < 4; i++)
547                 put_unaligned_le32(state[i], &dst[i * sizeof(__le32)]);
548 }
549
550 /* Decrypt one 16-byte block with AES */
551 static void aes_decrypt(const struct aes_key *k, const u8 src[AES_BLOCK_SIZE],
552                         u8 dst[AES_BLOCK_SIZE])
553 {
554         u32 state[4];
555         int i;
556
557         for (i = 0; i < 4; i++)
558                 state[i] = get_unaligned_le32(&src[i * sizeof(__le32)]);
559
560         AddRoundKey(state, &k->round_keys[4 * k->nrounds]);
561         InvShiftRows(state);
562         InvSubBytes(state);
563         for (i = k->nrounds - 1; i >= 1; i--) {
564                 AddRoundKey(state, &k->round_keys[4 * i]);
565                 InvMixColumns(state);
566                 InvShiftRows(state);
567                 InvSubBytes(state);
568         }
569         AddRoundKey(state, k->round_keys);
570
571         for (i = 0; i < 4; i++)
572                 put_unaligned_le32(state[i], &dst[i * sizeof(__le32)]);
573 }
574
575 #ifdef ENABLE_ALG_TESTS
576 #include <openssl/aes.h>
577 static void test_aes_keysize(int keysize)
578 {
579         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
580
581         while (num_tests--) {
582                 struct aes_key k;
583                 AES_KEY ref_k;
584                 u8 key[AES_256_KEY_SIZE];
585                 u8 ptext[AES_BLOCK_SIZE];
586                 u8 ctext[AES_BLOCK_SIZE];
587                 u8 ref_ctext[AES_BLOCK_SIZE];
588                 u8 decrypted[AES_BLOCK_SIZE];
589
590                 rand_bytes(key, keysize);
591                 rand_bytes(ptext, AES_BLOCK_SIZE);
592
593                 aes_setkey(&k, key, keysize);
594                 aes_encrypt(&k, ptext, ctext);
595
596                 ASSERT(AES_set_encrypt_key(key, keysize*8, &ref_k) == 0);
597                 AES_encrypt(ptext, ref_ctext, &ref_k);
598
599                 ASSERT(memcmp(ctext, ref_ctext, AES_BLOCK_SIZE) == 0);
600
601                 aes_decrypt(&k, ctext, decrypted);
602                 ASSERT(memcmp(ptext, decrypted, AES_BLOCK_SIZE) == 0);
603         }
604 }
605
606 static void test_aes(void)
607 {
608         test_aes_keysize(AES_128_KEY_SIZE);
609         test_aes_keysize(AES_192_KEY_SIZE);
610         test_aes_keysize(AES_256_KEY_SIZE);
611 }
612 #endif /* ENABLE_ALG_TESTS */
613
614 /*----------------------------------------------------------------------------*
615  *                            SHA-512 and SHA-256                             *
616  *----------------------------------------------------------------------------*/
617
618 /*
619  * Reference: "FIPS 180-2, Secure Hash Standard"
620  *      https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2withchangenotice.pdf
621  */
622
623 #define SHA512_DIGEST_SIZE      64
624 #define SHA512_BLOCK_SIZE       128
625
626 #define SHA256_DIGEST_SIZE      32
627 #define SHA256_BLOCK_SIZE       64
628
629 #define Ch(x, y, z)     (((x) & (y)) ^ (~(x) & (z)))
630 #define Maj(x, y, z)    (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
631
632 #define Sigma512_0(x)   (ror64((x), 28) ^ ror64((x), 34) ^ ror64((x), 39))
633 #define Sigma512_1(x)   (ror64((x), 14) ^ ror64((x), 18) ^ ror64((x), 41))
634 #define sigma512_0(x)   (ror64((x),  1) ^ ror64((x),  8) ^ ((x) >> 7))
635 #define sigma512_1(x)   (ror64((x), 19) ^ ror64((x), 61) ^ ((x) >> 6))
636
637 #define Sigma256_0(x)   (ror32((x),  2) ^ ror32((x), 13) ^ ror32((x), 22))
638 #define Sigma256_1(x)   (ror32((x),  6) ^ ror32((x), 11) ^ ror32((x), 25))
639 #define sigma256_0(x)   (ror32((x),  7) ^ ror32((x), 18) ^ ((x) >>  3))
640 #define sigma256_1(x)   (ror32((x), 17) ^ ror32((x), 19) ^ ((x) >> 10))
641
642 static const u64 sha512_iv[8] = {
643         0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b,
644         0xa54ff53a5f1d36f1, 0x510e527fade682d1, 0x9b05688c2b3e6c1f,
645         0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
646 };
647
648 static const u64 sha512_round_constants[80] = {
649         0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f,
650         0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019,
651         0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242,
652         0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
653         0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
654         0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
655         0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275,
656         0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
657         0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f,
658         0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
659         0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc,
660         0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
661         0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6,
662         0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001,
663         0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
664         0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
665         0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99,
666         0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
667         0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc,
668         0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
669         0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915,
670         0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207,
671         0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba,
672         0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
673         0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
674         0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
675         0x5fcb6fab3ad6faec, 0x6c44198c4a475817,
676 };
677
678 /* Compute the SHA-512 digest of the given buffer */
679 static void sha512(const u8 *in, size_t inlen, u8 out[SHA512_DIGEST_SIZE])
680 {
681         const size_t msglen = ROUND_UP(inlen + 17, SHA512_BLOCK_SIZE);
682         u8 * const msg = xmalloc(msglen);
683         u64 H[8];
684         int i;
685
686         /* super naive way of handling the padding */
687         memcpy(msg, in, inlen);
688         memset(&msg[inlen], 0, msglen - inlen);
689         msg[inlen] = 0x80;
690         put_unaligned_be64((u64)inlen * 8, &msg[msglen - sizeof(__be64)]);
691         in = msg;
692
693         memcpy(H, sha512_iv, sizeof(H));
694         do {
695                 u64 a = H[0], b = H[1], c = H[2], d = H[3],
696                     e = H[4], f = H[5], g = H[6], h = H[7];
697                 u64 W[80];
698
699                 for (i = 0; i < 16; i++)
700                         W[i] = get_unaligned_be64(&in[i * sizeof(__be64)]);
701                 for (; i < ARRAY_SIZE(W); i++)
702                         W[i] = sigma512_1(W[i - 2]) + W[i - 7] +
703                                sigma512_0(W[i - 15]) + W[i - 16];
704                 for (i = 0; i < ARRAY_SIZE(W); i++) {
705                         u64 T1 = h + Sigma512_1(e) + Ch(e, f, g) +
706                                  sha512_round_constants[i] + W[i];
707                         u64 T2 = Sigma512_0(a) + Maj(a, b, c);
708
709                         h = g; g = f; f = e; e = d + T1;
710                         d = c; c = b; b = a; a = T1 + T2;
711                 }
712                 H[0] += a; H[1] += b; H[2] += c; H[3] += d;
713                 H[4] += e; H[5] += f; H[6] += g; H[7] += h;
714         } while ((in += SHA512_BLOCK_SIZE) != &msg[msglen]);
715
716         for (i = 0; i < ARRAY_SIZE(H); i++)
717                 put_unaligned_be64(H[i], &out[i * sizeof(__be64)]);
718         free(msg);
719 }
720
721 /* Compute the SHA-256 digest of the given buffer */
722 static void sha256(const u8 *in, size_t inlen, u8 out[SHA256_DIGEST_SIZE])
723 {
724         const size_t msglen = ROUND_UP(inlen + 9, SHA256_BLOCK_SIZE);
725         u8 * const msg = xmalloc(msglen);
726         u32 H[8];
727         int i;
728
729         /* super naive way of handling the padding */
730         memcpy(msg, in, inlen);
731         memset(&msg[inlen], 0, msglen - inlen);
732         msg[inlen] = 0x80;
733         put_unaligned_be64((u64)inlen * 8, &msg[msglen - sizeof(__be64)]);
734         in = msg;
735
736         for (i = 0; i < ARRAY_SIZE(H); i++)
737                 H[i] = (u32)(sha512_iv[i] >> 32);
738         do {
739                 u32 a = H[0], b = H[1], c = H[2], d = H[3],
740                     e = H[4], f = H[5], g = H[6], h = H[7];
741                 u32 W[64];
742
743                 for (i = 0; i < 16; i++)
744                         W[i] = get_unaligned_be32(&in[i * sizeof(__be32)]);
745                 for (; i < ARRAY_SIZE(W); i++)
746                         W[i] = sigma256_1(W[i - 2]) + W[i - 7] +
747                                sigma256_0(W[i - 15]) + W[i - 16];
748                 for (i = 0; i < ARRAY_SIZE(W); i++) {
749                         u32 T1 = h + Sigma256_1(e) + Ch(e, f, g) +
750                                  (u32)(sha512_round_constants[i] >> 32) + W[i];
751                         u32 T2 = Sigma256_0(a) + Maj(a, b, c);
752
753                         h = g; g = f; f = e; e = d + T1;
754                         d = c; c = b; b = a; a = T1 + T2;
755                 }
756                 H[0] += a; H[1] += b; H[2] += c; H[3] += d;
757                 H[4] += e; H[5] += f; H[6] += g; H[7] += h;
758         } while ((in += SHA256_BLOCK_SIZE) != &msg[msglen]);
759
760         for (i = 0; i < ARRAY_SIZE(H); i++)
761                 put_unaligned_be32(H[i], &out[i * sizeof(__be32)]);
762         free(msg);
763 }
764
765 #ifdef ENABLE_ALG_TESTS
766 #include <openssl/sha.h>
767 static void test_sha2(void)
768 {
769         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
770
771         while (num_tests--) {
772                 u8 in[4096];
773                 u8 digest[SHA512_DIGEST_SIZE];
774                 u8 ref_digest[SHA512_DIGEST_SIZE];
775                 const size_t inlen = rand() % (1 + sizeof(in));
776
777                 rand_bytes(in, inlen);
778
779                 sha256(in, inlen, digest);
780                 SHA256(in, inlen, ref_digest);
781                 ASSERT(memcmp(digest, ref_digest, SHA256_DIGEST_SIZE) == 0);
782
783                 sha512(in, inlen, digest);
784                 SHA512(in, inlen, ref_digest);
785                 ASSERT(memcmp(digest, ref_digest, SHA512_DIGEST_SIZE) == 0);
786         }
787 }
788 #endif /* ENABLE_ALG_TESTS */
789
790 /*----------------------------------------------------------------------------*
791  *                            HKDF implementation                             *
792  *----------------------------------------------------------------------------*/
793
794 static void hmac_sha512(const u8 *key, size_t keylen, const u8 *msg,
795                         size_t msglen, u8 mac[SHA512_DIGEST_SIZE])
796 {
797         u8 *ibuf = xmalloc(SHA512_BLOCK_SIZE + msglen);
798         u8 obuf[SHA512_BLOCK_SIZE + SHA512_DIGEST_SIZE];
799
800         ASSERT(keylen <= SHA512_BLOCK_SIZE); /* keylen > bs not implemented */
801
802         memset(ibuf, 0x36, SHA512_BLOCK_SIZE);
803         xor(ibuf, ibuf, key, keylen);
804         memcpy(&ibuf[SHA512_BLOCK_SIZE], msg, msglen);
805
806         memset(obuf, 0x5c, SHA512_BLOCK_SIZE);
807         xor(obuf, obuf, key, keylen);
808         sha512(ibuf, SHA512_BLOCK_SIZE + msglen, &obuf[SHA512_BLOCK_SIZE]);
809         sha512(obuf, sizeof(obuf), mac);
810
811         free(ibuf);
812 }
813
814 static void hkdf_sha512(const u8 *ikm, size_t ikmlen,
815                         const u8 *salt, size_t saltlen,
816                         const u8 *info, size_t infolen,
817                         u8 *output, size_t outlen)
818 {
819         static const u8 default_salt[SHA512_DIGEST_SIZE];
820         u8 prk[SHA512_DIGEST_SIZE]; /* pseudorandom key */
821         u8 *buf = xmalloc(1 + infolen + SHA512_DIGEST_SIZE);
822         u8 counter = 1;
823         size_t i;
824
825         if (saltlen == 0) {
826                 salt = default_salt;
827                 saltlen = sizeof(default_salt);
828         }
829
830         /* HKDF-Extract */
831         ASSERT(ikmlen > 0);
832         hmac_sha512(salt, saltlen, ikm, ikmlen, prk);
833
834         /* HKDF-Expand */
835         for (i = 0; i < outlen; i += SHA512_DIGEST_SIZE) {
836                 u8 *p = buf;
837                 u8 tmp[SHA512_DIGEST_SIZE];
838
839                 ASSERT(counter != 0);
840                 if (i > 0) {
841                         memcpy(p, &output[i - SHA512_DIGEST_SIZE],
842                                SHA512_DIGEST_SIZE);
843                         p += SHA512_DIGEST_SIZE;
844                 }
845                 memcpy(p, info, infolen);
846                 p += infolen;
847                 *p++ = counter++;
848                 hmac_sha512(prk, sizeof(prk), buf, p - buf, tmp);
849                 memcpy(&output[i], tmp, MIN(sizeof(tmp), outlen - i));
850         }
851         free(buf);
852 }
853
854 #ifdef ENABLE_ALG_TESTS
855 #include <openssl/evp.h>
856 #include <openssl/kdf.h>
857 static void openssl_hkdf_sha512(const u8 *ikm, size_t ikmlen,
858                                 const u8 *salt, size_t saltlen,
859                                 const u8 *info, size_t infolen,
860                                 u8 *output, size_t outlen)
861 {
862         EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
863         size_t actual_outlen = outlen;
864
865         ASSERT(pctx != NULL);
866         ASSERT(EVP_PKEY_derive_init(pctx) > 0);
867         ASSERT(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha512()) > 0);
868         ASSERT(EVP_PKEY_CTX_set1_hkdf_key(pctx, ikm, ikmlen) > 0);
869         ASSERT(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt, saltlen) > 0);
870         ASSERT(EVP_PKEY_CTX_add1_hkdf_info(pctx, info, infolen) > 0);
871         ASSERT(EVP_PKEY_derive(pctx, output, &actual_outlen) > 0);
872         ASSERT(actual_outlen == outlen);
873         EVP_PKEY_CTX_free(pctx);
874 }
875
876 static void test_hkdf_sha512(void)
877 {
878         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
879
880         while (num_tests--) {
881                 u8 ikm[SHA512_DIGEST_SIZE];
882                 u8 salt[SHA512_DIGEST_SIZE];
883                 u8 info[128];
884                 u8 actual_output[512];
885                 u8 expected_output[sizeof(actual_output)];
886                 size_t ikmlen = 1 + (rand() % sizeof(ikm));
887                 size_t saltlen = rand() % (1 + sizeof(salt));
888                 size_t infolen = rand() % (1 + sizeof(info));
889                 size_t outlen = rand() % (1 + sizeof(actual_output));
890
891                 rand_bytes(ikm, ikmlen);
892                 rand_bytes(salt, saltlen);
893                 rand_bytes(info, infolen);
894
895                 hkdf_sha512(ikm, ikmlen, salt, saltlen, info, infolen,
896                             actual_output, outlen);
897                 openssl_hkdf_sha512(ikm, ikmlen, salt, saltlen, info, infolen,
898                                     expected_output, outlen);
899                 ASSERT(memcmp(actual_output, expected_output, outlen) == 0);
900         }
901 }
902 #endif /* ENABLE_ALG_TESTS */
903
904 /*----------------------------------------------------------------------------*
905  *                            AES encryption modes                            *
906  *----------------------------------------------------------------------------*/
907
908 static void aes_256_xts_crypt(const u8 key[2 * AES_256_KEY_SIZE],
909                               const u8 iv[AES_BLOCK_SIZE], const u8 *src,
910                               u8 *dst, size_t nbytes, bool decrypting)
911 {
912         struct aes_key tweak_key, cipher_key;
913         ble128 t;
914         size_t i;
915
916         ASSERT(nbytes % AES_BLOCK_SIZE == 0);
917         aes_setkey(&cipher_key, key, AES_256_KEY_SIZE);
918         aes_setkey(&tweak_key, &key[AES_256_KEY_SIZE], AES_256_KEY_SIZE);
919         aes_encrypt(&tweak_key, iv, (u8 *)&t);
920         for (i = 0; i < nbytes; i += AES_BLOCK_SIZE) {
921                 xor(&dst[i], &src[i], (const u8 *)&t, AES_BLOCK_SIZE);
922                 if (decrypting)
923                         aes_decrypt(&cipher_key, &dst[i], &dst[i]);
924                 else
925                         aes_encrypt(&cipher_key, &dst[i], &dst[i]);
926                 xor(&dst[i], &dst[i], (const u8 *)&t, AES_BLOCK_SIZE);
927                 gf2_128_mul_x(&t);
928         }
929 }
930
931 static void aes_256_xts_encrypt(const u8 key[2 * AES_256_KEY_SIZE],
932                                 const u8 iv[AES_BLOCK_SIZE], const u8 *src,
933                                 u8 *dst, size_t nbytes)
934 {
935         aes_256_xts_crypt(key, iv, src, dst, nbytes, false);
936 }
937
938 static void aes_256_xts_decrypt(const u8 key[2 * AES_256_KEY_SIZE],
939                                 const u8 iv[AES_BLOCK_SIZE], const u8 *src,
940                                 u8 *dst, size_t nbytes)
941 {
942         aes_256_xts_crypt(key, iv, src, dst, nbytes, true);
943 }
944
945 #ifdef ENABLE_ALG_TESTS
946 #include <openssl/evp.h>
947 static void test_aes_256_xts(void)
948 {
949         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
950         EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
951
952         ASSERT(ctx != NULL);
953         while (num_tests--) {
954                 u8 key[2 * AES_256_KEY_SIZE];
955                 u8 iv[AES_BLOCK_SIZE];
956                 u8 ptext[512];
957                 u8 ctext[sizeof(ptext)];
958                 u8 ref_ctext[sizeof(ptext)];
959                 u8 decrypted[sizeof(ptext)];
960                 const size_t datalen = ROUND_DOWN(rand() % (1 + sizeof(ptext)),
961                                                   AES_BLOCK_SIZE);
962                 int outl, res;
963
964                 rand_bytes(key, sizeof(key));
965                 rand_bytes(iv, sizeof(iv));
966                 rand_bytes(ptext, datalen);
967
968                 aes_256_xts_encrypt(key, iv, ptext, ctext, datalen);
969                 res = EVP_EncryptInit_ex(ctx, EVP_aes_256_xts(), NULL, key, iv);
970                 ASSERT(res > 0);
971                 res = EVP_EncryptUpdate(ctx, ref_ctext, &outl, ptext, datalen);
972                 ASSERT(res > 0);
973                 ASSERT(outl == datalen);
974                 ASSERT(memcmp(ctext, ref_ctext, datalen) == 0);
975
976                 aes_256_xts_decrypt(key, iv, ctext, decrypted, datalen);
977                 ASSERT(memcmp(ptext, decrypted, datalen) == 0);
978         }
979         EVP_CIPHER_CTX_free(ctx);
980 }
981 #endif /* ENABLE_ALG_TESTS */
982
983 static void aes_cbc_encrypt(const struct aes_key *k,
984                             const u8 iv[AES_BLOCK_SIZE],
985                             const u8 *src, u8 *dst, size_t nbytes)
986 {
987         size_t i;
988
989         ASSERT(nbytes % AES_BLOCK_SIZE == 0);
990         for (i = 0; i < nbytes; i += AES_BLOCK_SIZE) {
991                 xor(&dst[i], &src[i], (i == 0 ? iv : &dst[i - AES_BLOCK_SIZE]),
992                     AES_BLOCK_SIZE);
993                 aes_encrypt(k, &dst[i], &dst[i]);
994         }
995 }
996
997 static void aes_cbc_decrypt(const struct aes_key *k,
998                             const u8 iv[AES_BLOCK_SIZE],
999                             const u8 *src, u8 *dst, size_t nbytes)
1000 {
1001         size_t i = nbytes;
1002
1003         ASSERT(i % AES_BLOCK_SIZE == 0);
1004         while (i) {
1005                 i -= AES_BLOCK_SIZE;
1006                 aes_decrypt(k, &src[i], &dst[i]);
1007                 xor(&dst[i], &dst[i], (i == 0 ? iv : &src[i - AES_BLOCK_SIZE]),
1008                     AES_BLOCK_SIZE);
1009         }
1010 }
1011
1012 static void aes_cts_cbc_encrypt(const u8 *key, int keysize,
1013                                 const u8 iv[AES_BLOCK_SIZE],
1014                                 const u8 *src, u8 *dst, size_t nbytes)
1015 {
1016         const size_t offset = ROUND_DOWN(nbytes - 1, AES_BLOCK_SIZE);
1017         const size_t final_bsize = nbytes - offset;
1018         struct aes_key k;
1019         u8 *pad;
1020         u8 buf[AES_BLOCK_SIZE];
1021
1022         ASSERT(nbytes >= AES_BLOCK_SIZE);
1023
1024         aes_setkey(&k, key, keysize);
1025
1026         if (nbytes == AES_BLOCK_SIZE)
1027                 return aes_cbc_encrypt(&k, iv, src, dst, nbytes);
1028
1029         aes_cbc_encrypt(&k, iv, src, dst, offset);
1030         pad = &dst[offset - AES_BLOCK_SIZE];
1031
1032         memcpy(buf, pad, AES_BLOCK_SIZE);
1033         xor(buf, buf, &src[offset], final_bsize);
1034         memcpy(&dst[offset], pad, final_bsize);
1035         aes_encrypt(&k, buf, pad);
1036 }
1037
1038 static void aes_cts_cbc_decrypt(const u8 *key, int keysize,
1039                                 const u8 iv[AES_BLOCK_SIZE],
1040                                 const u8 *src, u8 *dst, size_t nbytes)
1041 {
1042         const size_t offset = ROUND_DOWN(nbytes - 1, AES_BLOCK_SIZE);
1043         const size_t final_bsize = nbytes - offset;
1044         struct aes_key k;
1045         u8 *pad;
1046
1047         ASSERT(nbytes >= AES_BLOCK_SIZE);
1048
1049         aes_setkey(&k, key, keysize);
1050
1051         if (nbytes == AES_BLOCK_SIZE)
1052                 return aes_cbc_decrypt(&k, iv, src, dst, nbytes);
1053
1054         pad = &dst[offset - AES_BLOCK_SIZE];
1055         aes_decrypt(&k, &src[offset - AES_BLOCK_SIZE], pad);
1056         xor(&dst[offset], &src[offset], pad, final_bsize);
1057         xor(pad, pad, &dst[offset], final_bsize);
1058
1059         aes_cbc_decrypt(&k, (offset == AES_BLOCK_SIZE ?
1060                              iv : &src[offset - 2 * AES_BLOCK_SIZE]),
1061                         pad, pad, AES_BLOCK_SIZE);
1062         aes_cbc_decrypt(&k, iv, src, dst, offset - AES_BLOCK_SIZE);
1063 }
1064
1065 static void aes_256_cts_cbc_encrypt(const u8 key[AES_256_KEY_SIZE],
1066                                     const u8 iv[AES_BLOCK_SIZE],
1067                                     const u8 *src, u8 *dst, size_t nbytes)
1068 {
1069         aes_cts_cbc_encrypt(key, AES_256_KEY_SIZE, iv, src, dst, nbytes);
1070 }
1071
1072 static void aes_256_cts_cbc_decrypt(const u8 key[AES_256_KEY_SIZE],
1073                                     const u8 iv[AES_BLOCK_SIZE],
1074                                     const u8 *src, u8 *dst, size_t nbytes)
1075 {
1076         aes_cts_cbc_decrypt(key, AES_256_KEY_SIZE, iv, src, dst, nbytes);
1077 }
1078
1079 #ifdef ENABLE_ALG_TESTS
1080 #include <openssl/modes.h>
1081 static void aes_block128_f(const unsigned char in[16],
1082                            unsigned char out[16], const void *key)
1083 {
1084         aes_encrypt(key, in, out);
1085 }
1086
1087 static void test_aes_256_cts_cbc(void)
1088 {
1089         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
1090
1091         while (num_tests--) {
1092                 u8 key[AES_256_KEY_SIZE];
1093                 u8 iv[AES_BLOCK_SIZE];
1094                 u8 iv_copy[AES_BLOCK_SIZE];
1095                 u8 ptext[512];
1096                 u8 ctext[sizeof(ptext)];
1097                 u8 ref_ctext[sizeof(ptext)];
1098                 u8 decrypted[sizeof(ptext)];
1099                 const size_t datalen = 16 + (rand() % (sizeof(ptext) - 15));
1100                 struct aes_key k;
1101
1102                 rand_bytes(key, sizeof(key));
1103                 rand_bytes(iv, sizeof(iv));
1104                 rand_bytes(ptext, datalen);
1105
1106                 aes_256_cts_cbc_encrypt(key, iv, ptext, ctext, datalen);
1107
1108                 /* OpenSSL doesn't allow datalen=AES_BLOCK_SIZE; Linux does */
1109                 if (datalen != AES_BLOCK_SIZE) {
1110                         aes_setkey(&k, key, sizeof(key));
1111                         memcpy(iv_copy, iv, sizeof(iv));
1112                         ASSERT(CRYPTO_cts128_encrypt_block(ptext, ref_ctext,
1113                                                            datalen, &k, iv_copy,
1114                                                            aes_block128_f)
1115                                == datalen);
1116                         ASSERT(memcmp(ctext, ref_ctext, datalen) == 0);
1117                 }
1118                 aes_256_cts_cbc_decrypt(key, iv, ctext, decrypted, datalen);
1119                 ASSERT(memcmp(ptext, decrypted, datalen) == 0);
1120         }
1121 }
1122 #endif /* ENABLE_ALG_TESTS */
1123
1124 static void essiv_generate_iv(const u8 orig_key[AES_128_KEY_SIZE],
1125                               const u8 orig_iv[AES_BLOCK_SIZE],
1126                               u8 real_iv[AES_BLOCK_SIZE])
1127 {
1128         u8 essiv_key[SHA256_DIGEST_SIZE];
1129         struct aes_key essiv;
1130
1131         /* AES encrypt the original IV using a hash of the original key */
1132         STATIC_ASSERT(SHA256_DIGEST_SIZE == AES_256_KEY_SIZE);
1133         sha256(orig_key, AES_128_KEY_SIZE, essiv_key);
1134         aes_setkey(&essiv, essiv_key, AES_256_KEY_SIZE);
1135         aes_encrypt(&essiv, orig_iv, real_iv);
1136 }
1137
1138 static void aes_128_cbc_essiv_encrypt(const u8 key[AES_128_KEY_SIZE],
1139                                       const u8 iv[AES_BLOCK_SIZE],
1140                                       const u8 *src, u8 *dst, size_t nbytes)
1141 {
1142         struct aes_key k;
1143         u8 real_iv[AES_BLOCK_SIZE];
1144
1145         aes_setkey(&k, key, AES_128_KEY_SIZE);
1146         essiv_generate_iv(key, iv, real_iv);
1147         aes_cbc_encrypt(&k, real_iv, src, dst, nbytes);
1148 }
1149
1150 static void aes_128_cbc_essiv_decrypt(const u8 key[AES_128_KEY_SIZE],
1151                                       const u8 iv[AES_BLOCK_SIZE],
1152                                       const u8 *src, u8 *dst, size_t nbytes)
1153 {
1154         struct aes_key k;
1155         u8 real_iv[AES_BLOCK_SIZE];
1156
1157         aes_setkey(&k, key, AES_128_KEY_SIZE);
1158         essiv_generate_iv(key, iv, real_iv);
1159         aes_cbc_decrypt(&k, real_iv, src, dst, nbytes);
1160 }
1161
1162 static void aes_128_cts_cbc_encrypt(const u8 key[AES_128_KEY_SIZE],
1163                                     const u8 iv[AES_BLOCK_SIZE],
1164                                     const u8 *src, u8 *dst, size_t nbytes)
1165 {
1166         aes_cts_cbc_encrypt(key, AES_128_KEY_SIZE, iv, src, dst, nbytes);
1167 }
1168
1169 static void aes_128_cts_cbc_decrypt(const u8 key[AES_128_KEY_SIZE],
1170                                     const u8 iv[AES_BLOCK_SIZE],
1171                                     const u8 *src, u8 *dst, size_t nbytes)
1172 {
1173         aes_cts_cbc_decrypt(key, AES_128_KEY_SIZE, iv, src, dst, nbytes);
1174 }
1175
1176 /*----------------------------------------------------------------------------*
1177  *                           XChaCha12 stream cipher                          *
1178  *----------------------------------------------------------------------------*/
1179
1180 /*
1181  * References:
1182  *   - "XChaCha: eXtended-nonce ChaCha and AEAD_XChaCha20_Poly1305"
1183  *      https://tools.ietf.org/html/draft-arciszewski-xchacha-03
1184  *
1185  *   - "ChaCha, a variant of Salsa20"
1186  *      https://cr.yp.to/chacha/chacha-20080128.pdf
1187  *
1188  *   - "Extending the Salsa20 nonce"
1189  *      https://cr.yp.to/snuffle/xsalsa-20081128.pdf
1190  */
1191
1192 #define CHACHA_KEY_SIZE         32
1193 #define XCHACHA_KEY_SIZE        CHACHA_KEY_SIZE
1194 #define XCHACHA_NONCE_SIZE      24
1195
1196 static void chacha_init_state(u32 state[16], const u8 key[CHACHA_KEY_SIZE],
1197                               const u8 iv[16])
1198 {
1199         static const u8 consts[16] = "expand 32-byte k";
1200         int i;
1201
1202         for (i = 0; i < 4; i++)
1203                 state[i] = get_unaligned_le32(&consts[i * sizeof(__le32)]);
1204         for (i = 0; i < 8; i++)
1205                 state[4 + i] = get_unaligned_le32(&key[i * sizeof(__le32)]);
1206         for (i = 0; i < 4; i++)
1207                 state[12 + i] = get_unaligned_le32(&iv[i * sizeof(__le32)]);
1208 }
1209
1210 #define CHACHA_QUARTERROUND(a, b, c, d)         \
1211         do {                                    \
1212                 a += b; d = rol32(d ^ a, 16);   \
1213                 c += d; b = rol32(b ^ c, 12);   \
1214                 a += b; d = rol32(d ^ a, 8);    \
1215                 c += d; b = rol32(b ^ c, 7);    \
1216         } while (0)
1217
1218 static void chacha_permute(u32 x[16], int nrounds)
1219 {
1220         do {
1221                 /* column round */
1222                 CHACHA_QUARTERROUND(x[0], x[4], x[8], x[12]);
1223                 CHACHA_QUARTERROUND(x[1], x[5], x[9], x[13]);
1224                 CHACHA_QUARTERROUND(x[2], x[6], x[10], x[14]);
1225                 CHACHA_QUARTERROUND(x[3], x[7], x[11], x[15]);
1226
1227                 /* diagonal round */
1228                 CHACHA_QUARTERROUND(x[0], x[5], x[10], x[15]);
1229                 CHACHA_QUARTERROUND(x[1], x[6], x[11], x[12]);
1230                 CHACHA_QUARTERROUND(x[2], x[7], x[8], x[13]);
1231                 CHACHA_QUARTERROUND(x[3], x[4], x[9], x[14]);
1232         } while ((nrounds -= 2) != 0);
1233 }
1234
1235 static void xchacha(const u8 key[XCHACHA_KEY_SIZE],
1236                     const u8 nonce[XCHACHA_NONCE_SIZE],
1237                     const u8 *src, u8 *dst, size_t nbytes, int nrounds)
1238 {
1239         u32 state[16];
1240         u8 real_key[CHACHA_KEY_SIZE];
1241         u8 real_iv[16] = { 0 };
1242         size_t i, j;
1243
1244         /* Compute real key using original key and first 128 nonce bits */
1245         chacha_init_state(state, key, nonce);
1246         chacha_permute(state, nrounds);
1247         for (i = 0; i < 8; i++) /* state words 0..3, 12..15 */
1248                 put_unaligned_le32(state[(i < 4 ? 0 : 8) + i],
1249                                    &real_key[i * sizeof(__le32)]);
1250
1251         /* Now do regular ChaCha, using real key and remaining nonce bits */
1252         memcpy(&real_iv[8], nonce + 16, 8);
1253         chacha_init_state(state, real_key, real_iv);
1254         for (i = 0; i < nbytes; i += 64) {
1255                 u32 x[16];
1256                 __le32 keystream[16];
1257
1258                 memcpy(x, state, 64);
1259                 chacha_permute(x, nrounds);
1260                 for (j = 0; j < 16; j++)
1261                         keystream[j] = cpu_to_le32(x[j] + state[j]);
1262                 xor(&dst[i], &src[i], (u8 *)keystream, MIN(nbytes - i, 64));
1263                 if (++state[12] == 0)
1264                         state[13]++;
1265         }
1266 }
1267
1268 static void xchacha12(const u8 key[XCHACHA_KEY_SIZE],
1269                       const u8 nonce[XCHACHA_NONCE_SIZE],
1270                       const u8 *src, u8 *dst, size_t nbytes)
1271 {
1272         xchacha(key, nonce, src, dst, nbytes, 12);
1273 }
1274
1275 /*----------------------------------------------------------------------------*
1276  *                                 Poly1305                                   *
1277  *----------------------------------------------------------------------------*/
1278
1279 /*
1280  * Note: this is only the Poly1305 ε-almost-∆-universal hash function, not the
1281  * full Poly1305 MAC.  I.e., it doesn't add anything at the end.
1282  */
1283
1284 #define POLY1305_KEY_SIZE       16
1285 #define POLY1305_BLOCK_SIZE     16
1286
1287 static void poly1305(const u8 key[POLY1305_KEY_SIZE],
1288                      const u8 *msg, size_t msglen, le128 *out)
1289 {
1290         const u32 limb_mask = 0x3ffffff;        /* limbs are base 2^26 */
1291         const u64 r0 = (get_unaligned_le32(key +  0) >> 0) & 0x3ffffff;
1292         const u64 r1 = (get_unaligned_le32(key +  3) >> 2) & 0x3ffff03;
1293         const u64 r2 = (get_unaligned_le32(key +  6) >> 4) & 0x3ffc0ff;
1294         const u64 r3 = (get_unaligned_le32(key +  9) >> 6) & 0x3f03fff;
1295         const u64 r4 = (get_unaligned_le32(key + 12) >> 8) & 0x00fffff;
1296         u32 h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0;
1297         u32 g0, g1, g2, g3, g4, ge_p_mask;
1298
1299         /* Partial block support is not necessary for Adiantum */
1300         ASSERT(msglen % POLY1305_BLOCK_SIZE == 0);
1301
1302         while (msglen) {
1303                 u64 d0, d1, d2, d3, d4;
1304
1305                 /* h += *msg */
1306                 h0 += (get_unaligned_le32(msg +  0) >> 0) & limb_mask;
1307                 h1 += (get_unaligned_le32(msg +  3) >> 2) & limb_mask;
1308                 h2 += (get_unaligned_le32(msg +  6) >> 4) & limb_mask;
1309                 h3 += (get_unaligned_le32(msg +  9) >> 6) & limb_mask;
1310                 h4 += (get_unaligned_le32(msg + 12) >> 8) | (1 << 24);
1311
1312                 /* h *= r */
1313                 d0 = h0*r0 + h1*5*r4 + h2*5*r3 + h3*5*r2 + h4*5*r1;
1314                 d1 = h0*r1 + h1*r0   + h2*5*r4 + h3*5*r3 + h4*5*r2;
1315                 d2 = h0*r2 + h1*r1   + h2*r0   + h3*5*r4 + h4*5*r3;
1316                 d3 = h0*r3 + h1*r2   + h2*r1   + h3*r0   + h4*5*r4;
1317                 d4 = h0*r4 + h1*r3   + h2*r2   + h3*r1   + h4*r0;
1318
1319                 /* (partial) h %= 2^130 - 5 */
1320                 d1 += d0 >> 26;         h0 = d0 & limb_mask;
1321                 d2 += d1 >> 26;         h1 = d1 & limb_mask;
1322                 d3 += d2 >> 26;         h2 = d2 & limb_mask;
1323                 d4 += d3 >> 26;         h3 = d3 & limb_mask;
1324                 h0 += (d4 >> 26) * 5;   h4 = d4 & limb_mask;
1325                 h1 += h0 >> 26;         h0 &= limb_mask;
1326
1327                 msg += POLY1305_BLOCK_SIZE;
1328                 msglen -= POLY1305_BLOCK_SIZE;
1329         }
1330
1331         /* fully carry h */
1332         h2 += (h1 >> 26);       h1 &= limb_mask;
1333         h3 += (h2 >> 26);       h2 &= limb_mask;
1334         h4 += (h3 >> 26);       h3 &= limb_mask;
1335         h0 += (h4 >> 26) * 5;   h4 &= limb_mask;
1336         h1 += (h0 >> 26);       h0 &= limb_mask;
1337
1338         /* if (h >= 2^130 - 5) h -= 2^130 - 5; */
1339         g0 = h0 + 5;
1340         g1 = h1 + (g0 >> 26);   g0 &= limb_mask;
1341         g2 = h2 + (g1 >> 26);   g1 &= limb_mask;
1342         g3 = h3 + (g2 >> 26);   g2 &= limb_mask;
1343         g4 = h4 + (g3 >> 26);   g3 &= limb_mask;
1344         ge_p_mask = ~((g4 >> 26) - 1); /* all 1's if h >= 2^130 - 5, else 0 */
1345         h0 = (h0 & ~ge_p_mask) | (g0 & ge_p_mask);
1346         h1 = (h1 & ~ge_p_mask) | (g1 & ge_p_mask);
1347         h2 = (h2 & ~ge_p_mask) | (g2 & ge_p_mask);
1348         h3 = (h3 & ~ge_p_mask) | (g3 & ge_p_mask);
1349         h4 = (h4 & ~ge_p_mask) | (g4 & ge_p_mask & limb_mask);
1350
1351         /* h %= 2^128 */
1352         out->lo = cpu_to_le64(((u64)h2 << 52) | ((u64)h1 << 26) | h0);
1353         out->hi = cpu_to_le64(((u64)h4 << 40) | ((u64)h3 << 14) | (h2 >> 12));
1354 }
1355
1356 /*----------------------------------------------------------------------------*
1357  *                          Adiantum encryption mode                          *
1358  *----------------------------------------------------------------------------*/
1359
1360 /*
1361  * Reference: "Adiantum: length-preserving encryption for entry-level processors"
1362  *      https://tosc.iacr.org/index.php/ToSC/article/view/7360
1363  */
1364
1365 #define ADIANTUM_KEY_SIZE       32
1366 #define ADIANTUM_IV_SIZE        32
1367 #define ADIANTUM_HASH_KEY_SIZE  ((2 * POLY1305_KEY_SIZE) + NH_KEY_SIZE)
1368
1369 #define NH_KEY_SIZE             1072
1370 #define NH_KEY_WORDS            (NH_KEY_SIZE / sizeof(u32))
1371 #define NH_BLOCK_SIZE           1024
1372 #define NH_HASH_SIZE            32
1373 #define NH_MESSAGE_UNIT         16
1374
1375 static u64 nh_pass(const u32 *key, const u8 *msg, size_t msglen)
1376 {
1377         u64 sum = 0;
1378
1379         ASSERT(msglen % NH_MESSAGE_UNIT == 0);
1380         while (msglen) {
1381                 sum += (u64)(u32)(get_unaligned_le32(msg +  0) + key[0]) *
1382                             (u32)(get_unaligned_le32(msg +  8) + key[2]);
1383                 sum += (u64)(u32)(get_unaligned_le32(msg +  4) + key[1]) *
1384                             (u32)(get_unaligned_le32(msg + 12) + key[3]);
1385                 key += NH_MESSAGE_UNIT / sizeof(key[0]);
1386                 msg += NH_MESSAGE_UNIT;
1387                 msglen -= NH_MESSAGE_UNIT;
1388         }
1389         return sum;
1390 }
1391
1392 /* NH ε-almost-universal hash function */
1393 static void nh(const u32 *key, const u8 *msg, size_t msglen,
1394                u8 result[NH_HASH_SIZE])
1395 {
1396         size_t i;
1397
1398         for (i = 0; i < NH_HASH_SIZE; i += sizeof(__le64)) {
1399                 put_unaligned_le64(nh_pass(key, msg, msglen), &result[i]);
1400                 key += NH_MESSAGE_UNIT / sizeof(key[0]);
1401         }
1402 }
1403
1404 /* Adiantum's ε-almost-∆-universal hash function */
1405 static void adiantum_hash(const u8 key[ADIANTUM_HASH_KEY_SIZE],
1406                           const u8 iv[ADIANTUM_IV_SIZE],
1407                           const u8 *msg, size_t msglen, le128 *result)
1408 {
1409         const u8 *header_poly_key = key;
1410         const u8 *msg_poly_key = header_poly_key + POLY1305_KEY_SIZE;
1411         const u8 *nh_key = msg_poly_key + POLY1305_KEY_SIZE;
1412         u32 nh_key_words[NH_KEY_WORDS];
1413         u8 header[POLY1305_BLOCK_SIZE + ADIANTUM_IV_SIZE];
1414         const size_t num_nh_blocks = DIV_ROUND_UP(msglen, NH_BLOCK_SIZE);
1415         u8 *nh_hashes = xmalloc(num_nh_blocks * NH_HASH_SIZE);
1416         const size_t padded_msglen = ROUND_UP(msglen, NH_MESSAGE_UNIT);
1417         u8 *padded_msg = xmalloc(padded_msglen);
1418         le128 hash1, hash2;
1419         size_t i;
1420
1421         for (i = 0; i < NH_KEY_WORDS; i++)
1422                 nh_key_words[i] = get_unaligned_le32(&nh_key[i * sizeof(u32)]);
1423
1424         /* Hash tweak and message length with first Poly1305 key */
1425         put_unaligned_le64((u64)msglen * 8, header);
1426         put_unaligned_le64(0, &header[sizeof(__le64)]);
1427         memcpy(&header[POLY1305_BLOCK_SIZE], iv, ADIANTUM_IV_SIZE);
1428         poly1305(header_poly_key, header, sizeof(header), &hash1);
1429
1430         /* Hash NH hashes of message blocks using second Poly1305 key */
1431         /* (using a super naive way of handling the padding) */
1432         memcpy(padded_msg, msg, msglen);
1433         memset(&padded_msg[msglen], 0, padded_msglen - msglen);
1434         for (i = 0; i < num_nh_blocks; i++) {
1435                 nh(nh_key_words, &padded_msg[i * NH_BLOCK_SIZE],
1436                    MIN(NH_BLOCK_SIZE, padded_msglen - (i * NH_BLOCK_SIZE)),
1437                    &nh_hashes[i * NH_HASH_SIZE]);
1438         }
1439         poly1305(msg_poly_key, nh_hashes, num_nh_blocks * NH_HASH_SIZE, &hash2);
1440
1441         /* Add the two hashes together to get the final hash */
1442         le128_add(result, &hash1, &hash2);
1443
1444         free(nh_hashes);
1445         free(padded_msg);
1446 }
1447
1448 static void adiantum_crypt(const u8 key[ADIANTUM_KEY_SIZE],
1449                            const u8 iv[ADIANTUM_IV_SIZE], const u8 *src,
1450                            u8 *dst, size_t nbytes, bool decrypting)
1451 {
1452         u8 subkeys[AES_256_KEY_SIZE + ADIANTUM_HASH_KEY_SIZE] = { 0 };
1453         struct aes_key aes_key;
1454         union {
1455                 u8 nonce[XCHACHA_NONCE_SIZE];
1456                 le128 block;
1457         } u = { .nonce = { 1 } };
1458         const size_t bulk_len = nbytes - sizeof(u.block);
1459         le128 hash;
1460
1461         ASSERT(nbytes >= sizeof(u.block));
1462
1463         /* Derive subkeys */
1464         xchacha12(key, u.nonce, subkeys, subkeys, sizeof(subkeys));
1465         aes_setkey(&aes_key, subkeys, AES_256_KEY_SIZE);
1466
1467         /* Hash left part and add to right part */
1468         adiantum_hash(&subkeys[AES_256_KEY_SIZE], iv, src, bulk_len, &hash);
1469         memcpy(&u.block, &src[bulk_len], sizeof(u.block));
1470         le128_add(&u.block, &u.block, &hash);
1471
1472         if (!decrypting) /* Encrypt right part with block cipher */
1473                 aes_encrypt(&aes_key, u.nonce, u.nonce);
1474
1475         /* Encrypt left part with stream cipher, using the computed nonce */
1476         u.nonce[sizeof(u.block)] = 1;
1477         xchacha12(key, u.nonce, src, dst, bulk_len);
1478
1479         if (decrypting) /* Decrypt right part with block cipher */
1480                 aes_decrypt(&aes_key, u.nonce, u.nonce);
1481
1482         /* Finalize right part by subtracting hash of left part */
1483         adiantum_hash(&subkeys[AES_256_KEY_SIZE], iv, dst, bulk_len, &hash);
1484         le128_sub(&u.block, &u.block, &hash);
1485         memcpy(&dst[bulk_len], &u.block, sizeof(u.block));
1486 }
1487
1488 static void adiantum_encrypt(const u8 key[ADIANTUM_KEY_SIZE],
1489                              const u8 iv[ADIANTUM_IV_SIZE],
1490                              const u8 *src, u8 *dst, size_t nbytes)
1491 {
1492         adiantum_crypt(key, iv, src, dst, nbytes, false);
1493 }
1494
1495 static void adiantum_decrypt(const u8 key[ADIANTUM_KEY_SIZE],
1496                              const u8 iv[ADIANTUM_IV_SIZE],
1497                              const u8 *src, u8 *dst, size_t nbytes)
1498 {
1499         adiantum_crypt(key, iv, src, dst, nbytes, true);
1500 }
1501
1502 #ifdef ENABLE_ALG_TESTS
1503 #include <linux/if_alg.h>
1504 #include <sys/socket.h>
1505 #define SOL_ALG 279
1506 static void af_alg_crypt(int algfd, int op, const u8 *key, size_t keylen,
1507                          const u8 *iv, size_t ivlen,
1508                          const u8 *src, u8 *dst, size_t datalen)
1509 {
1510         size_t controllen = CMSG_SPACE(sizeof(int)) +
1511                             CMSG_SPACE(sizeof(struct af_alg_iv) + ivlen);
1512         u8 *control = xmalloc(controllen);
1513         struct iovec iov = { .iov_base = (u8 *)src, .iov_len = datalen };
1514         struct msghdr msg = {
1515                 .msg_iov = &iov,
1516                 .msg_iovlen = 1,
1517                 .msg_control = control,
1518                 .msg_controllen = controllen,
1519         };
1520         struct cmsghdr *cmsg;
1521         struct af_alg_iv *algiv;
1522         int reqfd;
1523
1524         memset(control, 0, controllen);
1525
1526         cmsg = CMSG_FIRSTHDR(&msg);
1527         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
1528         cmsg->cmsg_level = SOL_ALG;
1529         cmsg->cmsg_type = ALG_SET_OP;
1530         *(int *)CMSG_DATA(cmsg) = op;
1531
1532         cmsg = CMSG_NXTHDR(&msg, cmsg);
1533         cmsg->cmsg_len = CMSG_LEN(sizeof(struct af_alg_iv) + ivlen);
1534         cmsg->cmsg_level = SOL_ALG;
1535         cmsg->cmsg_type = ALG_SET_IV;
1536         algiv = (struct af_alg_iv *)CMSG_DATA(cmsg);
1537         algiv->ivlen = ivlen;
1538         memcpy(algiv->iv, iv, ivlen);
1539
1540         if (setsockopt(algfd, SOL_ALG, ALG_SET_KEY, key, keylen) != 0)
1541                 die_errno("can't set key on AF_ALG socket");
1542
1543         reqfd = accept(algfd, NULL, NULL);
1544         if (reqfd < 0)
1545                 die_errno("can't accept() AF_ALG socket");
1546         if (sendmsg(reqfd, &msg, 0) != datalen)
1547                 die_errno("can't sendmsg() AF_ALG request socket");
1548         if (xread(reqfd, dst, datalen) != datalen)
1549                 die("short read from AF_ALG request socket");
1550         close(reqfd);
1551
1552         free(control);
1553 }
1554
1555 static void test_adiantum(void)
1556 {
1557         int algfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
1558         struct sockaddr_alg addr = {
1559                 .salg_type = "skcipher",
1560                 .salg_name = "adiantum(xchacha12,aes)",
1561         };
1562         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
1563
1564         if (algfd < 0)
1565                 die_errno("can't create AF_ALG socket");
1566         if (bind(algfd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
1567                 die_errno("can't bind AF_ALG socket to Adiantum algorithm");
1568
1569         while (num_tests--) {
1570                 u8 key[ADIANTUM_KEY_SIZE];
1571                 u8 iv[ADIANTUM_IV_SIZE];
1572                 u8 ptext[4096];
1573                 u8 ctext[sizeof(ptext)];
1574                 u8 ref_ctext[sizeof(ptext)];
1575                 u8 decrypted[sizeof(ptext)];
1576                 const size_t datalen = 16 + (rand() % (sizeof(ptext) - 15));
1577
1578                 rand_bytes(key, sizeof(key));
1579                 rand_bytes(iv, sizeof(iv));
1580                 rand_bytes(ptext, datalen);
1581
1582                 adiantum_encrypt(key, iv, ptext, ctext, datalen);
1583                 af_alg_crypt(algfd, ALG_OP_ENCRYPT, key, sizeof(key),
1584                              iv, sizeof(iv), ptext, ref_ctext, datalen);
1585                 ASSERT(memcmp(ctext, ref_ctext, datalen) == 0);
1586
1587                 adiantum_decrypt(key, iv, ctext, decrypted, datalen);
1588                 ASSERT(memcmp(ptext, decrypted, datalen) == 0);
1589         }
1590         close(algfd);
1591 }
1592 #endif /* ENABLE_ALG_TESTS */
1593
1594 /*----------------------------------------------------------------------------*
1595  *                               SipHash-2-4                                  *
1596  *----------------------------------------------------------------------------*/
1597
1598 /*
1599  * Reference: "SipHash: a fast short-input PRF"
1600  *      https://cr.yp.to/siphash/siphash-20120918.pdf
1601  */
1602
1603 #define SIPROUND                                                \
1604         do {                                                    \
1605                 v0 += v1;           v2 += v3;                   \
1606                 v1 = rol64(v1, 13); v3 = rol64(v3, 16);         \
1607                 v1 ^= v0;           v3 ^= v2;                   \
1608                 v0 = rol64(v0, 32);                             \
1609                 v2 += v1;           v0 += v3;                   \
1610                 v1 = rol64(v1, 17); v3 = rol64(v3, 21);         \
1611                 v1 ^= v2;           v3 ^= v0;                   \
1612                 v2 = rol64(v2, 32);                             \
1613         } while (0)
1614
1615 /* Compute the SipHash-2-4 of a 64-bit number when formatted as little endian */
1616 static u64 siphash_1u64(const u64 key[2], u64 data)
1617 {
1618         u64 v0 = key[0] ^ 0x736f6d6570736575ULL;
1619         u64 v1 = key[1] ^ 0x646f72616e646f6dULL;
1620         u64 v2 = key[0] ^ 0x6c7967656e657261ULL;
1621         u64 v3 = key[1] ^ 0x7465646279746573ULL;
1622         u64 m[2] = {data, (u64)sizeof(data) << 56};
1623         size_t i;
1624
1625         for (i = 0; i < ARRAY_SIZE(m); i++) {
1626                 v3 ^= m[i];
1627                 SIPROUND;
1628                 SIPROUND;
1629                 v0 ^= m[i];
1630         }
1631
1632         v2 ^= 0xff;
1633         for (i = 0; i < 4; i++)
1634                 SIPROUND;
1635         return v0 ^ v1 ^ v2 ^ v3;
1636 }
1637
1638 /*----------------------------------------------------------------------------*
1639  *                               Main program                                 *
1640  *----------------------------------------------------------------------------*/
1641
1642 #define FILE_NONCE_SIZE         16
1643 #define UUID_SIZE               16
1644 #define MAX_KEY_SIZE            64
1645
1646 static const struct fscrypt_cipher {
1647         const char *name;
1648         void (*encrypt)(const u8 *key, const u8 *iv, const u8 *src,
1649                         u8 *dst, size_t nbytes);
1650         void (*decrypt)(const u8 *key, const u8 *iv, const u8 *src,
1651                         u8 *dst, size_t nbytes);
1652         int keysize;
1653         int min_input_size;
1654 } fscrypt_ciphers[] = {
1655         {
1656                 .name = "AES-256-XTS",
1657                 .encrypt = aes_256_xts_encrypt,
1658                 .decrypt = aes_256_xts_decrypt,
1659                 .keysize = 2 * AES_256_KEY_SIZE,
1660         }, {
1661                 .name = "AES-256-CTS-CBC",
1662                 .encrypt = aes_256_cts_cbc_encrypt,
1663                 .decrypt = aes_256_cts_cbc_decrypt,
1664                 .keysize = AES_256_KEY_SIZE,
1665                 .min_input_size = AES_BLOCK_SIZE,
1666         }, {
1667                 .name = "AES-128-CBC-ESSIV",
1668                 .encrypt = aes_128_cbc_essiv_encrypt,
1669                 .decrypt = aes_128_cbc_essiv_decrypt,
1670                 .keysize = AES_128_KEY_SIZE,
1671         }, {
1672                 .name = "AES-128-CTS-CBC",
1673                 .encrypt = aes_128_cts_cbc_encrypt,
1674                 .decrypt = aes_128_cts_cbc_decrypt,
1675                 .keysize = AES_128_KEY_SIZE,
1676                 .min_input_size = AES_BLOCK_SIZE,
1677         }, {
1678                 .name = "Adiantum",
1679                 .encrypt = adiantum_encrypt,
1680                 .decrypt = adiantum_decrypt,
1681                 .keysize = ADIANTUM_KEY_SIZE,
1682                 .min_input_size = AES_BLOCK_SIZE,
1683         }
1684 };
1685
1686 static const struct fscrypt_cipher *find_fscrypt_cipher(const char *name)
1687 {
1688         size_t i;
1689
1690         for (i = 0; i < ARRAY_SIZE(fscrypt_ciphers); i++) {
1691                 if (strcmp(fscrypt_ciphers[i].name, name) == 0)
1692                         return &fscrypt_ciphers[i];
1693         }
1694         return NULL;
1695 }
1696
1697 union fscrypt_iv {
1698         /* usual IV format */
1699         struct {
1700                 /* logical block number within the file */
1701                 __le64 block_number;
1702
1703                 /* per-file nonce; only set in DIRECT_KEY mode */
1704                 u8 nonce[FILE_NONCE_SIZE];
1705         };
1706         /* IV format for IV_INO_LBLK_* modes */
1707         struct {
1708                 /*
1709                  * IV_INO_LBLK_64: logical block number within the file
1710                  * IV_INO_LBLK_32: hashed inode number + logical block number
1711                  *                 within the file, mod 2^32
1712                  */
1713                 __le32 block_number32;
1714
1715                 /* IV_INO_LBLK_64: inode number */
1716                 __le32 inode_number;
1717         };
1718 };
1719
1720 static void crypt_loop(const struct fscrypt_cipher *cipher, const u8 *key,
1721                        union fscrypt_iv *iv, bool decrypting,
1722                        size_t block_size, size_t padding, bool is_bnum_32bit)
1723 {
1724         u8 *buf = xmalloc(block_size);
1725         size_t res;
1726
1727         while ((res = xread(STDIN_FILENO, buf, block_size)) > 0) {
1728                 size_t crypt_len = block_size;
1729
1730                 if (padding > 0) {
1731                         crypt_len = MAX(res, cipher->min_input_size);
1732                         crypt_len = ROUND_UP(crypt_len, padding);
1733                         crypt_len = MIN(crypt_len, block_size);
1734                 }
1735                 ASSERT(crypt_len >= res);
1736                 memset(&buf[res], 0, crypt_len - res);
1737
1738                 if (decrypting)
1739                         cipher->decrypt(key, (u8 *)iv, buf, buf, crypt_len);
1740                 else
1741                         cipher->encrypt(key, (u8 *)iv, buf, buf, crypt_len);
1742
1743                 full_write(STDOUT_FILENO, buf, crypt_len);
1744
1745                 if (is_bnum_32bit)
1746                         iv->block_number32 = cpu_to_le32(
1747                                         le32_to_cpu(iv->block_number32) + 1);
1748                 else
1749                         iv->block_number = cpu_to_le64(
1750                                         le64_to_cpu(iv->block_number) + 1);
1751         }
1752         free(buf);
1753 }
1754
1755 /* The supported key derivation functions */
1756 enum kdf_algorithm {
1757         KDF_NONE,
1758         KDF_AES_128_ECB,
1759         KDF_HKDF_SHA512,
1760 };
1761
1762 static enum kdf_algorithm parse_kdf_algorithm(const char *arg)
1763 {
1764         if (strcmp(arg, "none") == 0)
1765                 return KDF_NONE;
1766         if (strcmp(arg, "AES-128-ECB") == 0)
1767                 return KDF_AES_128_ECB;
1768         if (strcmp(arg, "HKDF-SHA512") == 0)
1769                 return KDF_HKDF_SHA512;
1770         die("Unknown KDF: %s", arg);
1771 }
1772
1773 static u8 parse_mode_number(const char *arg)
1774 {
1775         char *tmp;
1776         long num = strtol(arg, &tmp, 10);
1777
1778         if (num <= 0 || *tmp || (u8)num != num)
1779                 die("Invalid mode number: %s", arg);
1780         return num;
1781 }
1782
1783 struct key_and_iv_params {
1784         u8 master_key[MAX_KEY_SIZE];
1785         int master_key_size;
1786         enum kdf_algorithm kdf;
1787         u8 mode_num;
1788         u8 file_nonce[FILE_NONCE_SIZE];
1789         bool file_nonce_specified;
1790         bool iv_ino_lblk_64;
1791         bool iv_ino_lblk_32;
1792         u64 block_number;
1793         u64 inode_number;
1794         u8 fs_uuid[UUID_SIZE];
1795         bool fs_uuid_specified;
1796 };
1797
1798 #define HKDF_CONTEXT_KEY_IDENTIFIER     1
1799 #define HKDF_CONTEXT_PER_FILE_ENC_KEY   2
1800 #define HKDF_CONTEXT_DIRECT_KEY         3
1801 #define HKDF_CONTEXT_IV_INO_LBLK_64_KEY 4
1802 #define HKDF_CONTEXT_DIRHASH_KEY        5
1803 #define HKDF_CONTEXT_IV_INO_LBLK_32_KEY 6
1804 #define HKDF_CONTEXT_INODE_HASH_KEY     7
1805
1806 /* Hash the file's inode number using SipHash keyed by a derived key */
1807 static u32 hash_inode_number(const struct key_and_iv_params *params)
1808 {
1809         u8 info[9] = "fscrypt";
1810         union {
1811                 u64 words[2];
1812                 u8 bytes[16];
1813         } hash_key;
1814
1815         info[8] = HKDF_CONTEXT_INODE_HASH_KEY;
1816         hkdf_sha512(params->master_key, params->master_key_size,
1817                     NULL, 0, info, sizeof(info),
1818                     hash_key.bytes, sizeof(hash_key));
1819
1820         hash_key.words[0] = get_unaligned_le64(&hash_key.bytes[0]);
1821         hash_key.words[1] = get_unaligned_le64(&hash_key.bytes[8]);
1822
1823         return (u32)siphash_1u64(hash_key.words, params->inode_number);
1824 }
1825
1826 /*
1827  * Get the key and starting IV with which the encryption will actually be done.
1828  * If a KDF was specified, a subkey is derived from the master key and the mode
1829  * number or file nonce.  Otherwise, the master key is used directly.
1830  */
1831 static void get_key_and_iv(const struct key_and_iv_params *params,
1832                            u8 *real_key, size_t real_key_size,
1833                            union fscrypt_iv *iv)
1834 {
1835         bool file_nonce_in_iv = false;
1836         struct aes_key aes_key;
1837         u8 info[8 + 1 + 1 + UUID_SIZE] = "fscrypt";
1838         size_t infolen = 8;
1839         size_t i;
1840
1841         ASSERT(real_key_size <= params->master_key_size);
1842
1843         memset(iv, 0, sizeof(*iv));
1844
1845         /* Overridden later for iv_ino_lblk_{64,32} */
1846         iv->block_number = cpu_to_le64(params->block_number);
1847
1848         if (params->iv_ino_lblk_64 || params->iv_ino_lblk_32) {
1849                 const char *opt = params->iv_ino_lblk_64 ? "--iv-ino-lblk-64" :
1850                                                            "--iv-ino-lblk-32";
1851                 if (params->iv_ino_lblk_64 && params->iv_ino_lblk_32)
1852                         die("--iv-ino-lblk-64 and --iv-ino-lblk-32 are mutually exclusive");
1853                 if (params->kdf != KDF_HKDF_SHA512)
1854                         die("%s requires --kdf=HKDF-SHA512", opt);
1855                 if (!params->fs_uuid_specified)
1856                         die("%s requires --fs-uuid", opt);
1857                 if (params->inode_number == 0)
1858                         die("%s requires --inode-number", opt);
1859                 if (params->mode_num == 0)
1860                         die("%s requires --mode-num", opt);
1861                 if (params->block_number > UINT32_MAX)
1862                         die("%s can't use --block-number > UINT32_MAX", opt);
1863                 if (params->inode_number > UINT32_MAX)
1864                         die("%s can't use --inode-number > UINT32_MAX", opt);
1865         }
1866
1867         switch (params->kdf) {
1868         case KDF_NONE:
1869                 if (params->mode_num != 0)
1870                         die("--mode-num isn't supported with --kdf=none");
1871                 memcpy(real_key, params->master_key, real_key_size);
1872                 file_nonce_in_iv = true;
1873                 break;
1874         case KDF_AES_128_ECB:
1875                 if (!params->file_nonce_specified)
1876                         die("--file-nonce is required with --kdf=AES-128-ECB");
1877                 if (params->mode_num != 0)
1878                         die("--mode-num isn't supported with --kdf=AES-128-ECB");
1879                 STATIC_ASSERT(FILE_NONCE_SIZE == AES_128_KEY_SIZE);
1880                 ASSERT(real_key_size % AES_BLOCK_SIZE == 0);
1881                 aes_setkey(&aes_key, params->file_nonce, AES_128_KEY_SIZE);
1882                 for (i = 0; i < real_key_size; i += AES_BLOCK_SIZE)
1883                         aes_encrypt(&aes_key, &params->master_key[i],
1884                                     &real_key[i]);
1885                 break;
1886         case KDF_HKDF_SHA512:
1887                 if (params->iv_ino_lblk_64) {
1888                         info[infolen++] = HKDF_CONTEXT_IV_INO_LBLK_64_KEY;
1889                         info[infolen++] = params->mode_num;
1890                         memcpy(&info[infolen], params->fs_uuid, UUID_SIZE);
1891                         infolen += UUID_SIZE;
1892                         iv->block_number32 = cpu_to_le32(params->block_number);
1893                         iv->inode_number = cpu_to_le32(params->inode_number);
1894                 } else if (params->iv_ino_lblk_32) {
1895                         info[infolen++] = HKDF_CONTEXT_IV_INO_LBLK_32_KEY;
1896                         info[infolen++] = params->mode_num;
1897                         memcpy(&info[infolen], params->fs_uuid, UUID_SIZE);
1898                         infolen += UUID_SIZE;
1899                         iv->block_number32 =
1900                                 cpu_to_le32(hash_inode_number(params) +
1901                                             params->block_number);
1902                         iv->inode_number = 0;
1903                 } else if (params->mode_num != 0) {
1904                         info[infolen++] = HKDF_CONTEXT_DIRECT_KEY;
1905                         info[infolen++] = params->mode_num;
1906                         file_nonce_in_iv = true;
1907                 } else if (params->file_nonce_specified) {
1908                         info[infolen++] = HKDF_CONTEXT_PER_FILE_ENC_KEY;
1909                         memcpy(&info[infolen], params->file_nonce,
1910                                FILE_NONCE_SIZE);
1911                         infolen += FILE_NONCE_SIZE;
1912                 } else {
1913                         die("With --kdf=HKDF-SHA512, at least one of --file-nonce and --mode-num must be specified");
1914                 }
1915                 hkdf_sha512(params->master_key, params->master_key_size,
1916                             NULL, 0, info, infolen, real_key, real_key_size);
1917                 break;
1918         default:
1919                 ASSERT(0);
1920         }
1921
1922         if (file_nonce_in_iv && params->file_nonce_specified)
1923                 memcpy(iv->nonce, params->file_nonce, FILE_NONCE_SIZE);
1924 }
1925
1926 enum {
1927         OPT_BLOCK_NUMBER,
1928         OPT_BLOCK_SIZE,
1929         OPT_DECRYPT,
1930         OPT_FILE_NONCE,
1931         OPT_FS_UUID,
1932         OPT_HELP,
1933         OPT_INODE_NUMBER,
1934         OPT_IV_INO_LBLK_32,
1935         OPT_IV_INO_LBLK_64,
1936         OPT_KDF,
1937         OPT_MODE_NUM,
1938         OPT_PADDING,
1939 };
1940
1941 static const struct option longopts[] = {
1942         { "block-number",    required_argument, NULL, OPT_BLOCK_NUMBER },
1943         { "block-size",      required_argument, NULL, OPT_BLOCK_SIZE },
1944         { "decrypt",         no_argument,       NULL, OPT_DECRYPT },
1945         { "file-nonce",      required_argument, NULL, OPT_FILE_NONCE },
1946         { "fs-uuid",         required_argument, NULL, OPT_FS_UUID },
1947         { "help",            no_argument,       NULL, OPT_HELP },
1948         { "inode-number",    required_argument, NULL, OPT_INODE_NUMBER },
1949         { "iv-ino-lblk-32",  no_argument,       NULL, OPT_IV_INO_LBLK_32 },
1950         { "iv-ino-lblk-64",  no_argument,       NULL, OPT_IV_INO_LBLK_64 },
1951         { "kdf",             required_argument, NULL, OPT_KDF },
1952         { "mode-num",        required_argument, NULL, OPT_MODE_NUM },
1953         { "padding",         required_argument, NULL, OPT_PADDING },
1954         { NULL, 0, NULL, 0 },
1955 };
1956
1957 int main(int argc, char *argv[])
1958 {
1959         size_t block_size = 4096;
1960         bool decrypting = false;
1961         struct key_and_iv_params params;
1962         size_t padding = 0;
1963         const struct fscrypt_cipher *cipher;
1964         u8 real_key[MAX_KEY_SIZE];
1965         union fscrypt_iv iv;
1966         char *tmp;
1967         int c;
1968
1969         memset(&params, 0, sizeof(params));
1970
1971         aes_init();
1972
1973 #ifdef ENABLE_ALG_TESTS
1974         test_aes();
1975         test_sha2();
1976         test_hkdf_sha512();
1977         test_aes_256_xts();
1978         test_aes_256_cts_cbc();
1979         test_adiantum();
1980 #endif
1981
1982         while ((c = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
1983                 switch (c) {
1984                 case OPT_BLOCK_NUMBER:
1985                         errno = 0;
1986                         params.block_number = strtoull(optarg, &tmp, 10);
1987                         if (*tmp || errno)
1988                                 die("Invalid block number: %s", optarg);
1989                         break;
1990                 case OPT_BLOCK_SIZE:
1991                         errno = 0;
1992                         block_size = strtoul(optarg, &tmp, 10);
1993                         if (block_size <= 0 || *tmp || errno)
1994                                 die("Invalid block size: %s", optarg);
1995                         break;
1996                 case OPT_DECRYPT:
1997                         decrypting = true;
1998                         break;
1999                 case OPT_FILE_NONCE:
2000                         if (hex2bin(optarg, params.file_nonce, FILE_NONCE_SIZE)
2001                             != FILE_NONCE_SIZE)
2002                                 die("Invalid file nonce: %s", optarg);
2003                         params.file_nonce_specified = true;
2004                         break;
2005                 case OPT_FS_UUID:
2006                         if (hex2bin(optarg, params.fs_uuid, UUID_SIZE)
2007                             != UUID_SIZE)
2008                                 die("Invalid filesystem UUID: %s", optarg);
2009                         params.fs_uuid_specified = true;
2010                         break;
2011                 case OPT_HELP:
2012                         usage(stdout);
2013                         return 0;
2014                 case OPT_INODE_NUMBER:
2015                         errno = 0;
2016                         params.inode_number = strtoull(optarg, &tmp, 10);
2017                         if (params.inode_number <= 0 || *tmp || errno)
2018                                 die("Invalid inode number: %s", optarg);
2019                         break;
2020                 case OPT_IV_INO_LBLK_32:
2021                         params.iv_ino_lblk_32 = true;
2022                         break;
2023                 case OPT_IV_INO_LBLK_64:
2024                         params.iv_ino_lblk_64 = true;
2025                         break;
2026                 case OPT_KDF:
2027                         params.kdf = parse_kdf_algorithm(optarg);
2028                         break;
2029                 case OPT_MODE_NUM:
2030                         params.mode_num = parse_mode_number(optarg);
2031                         break;
2032                 case OPT_PADDING:
2033                         padding = strtoul(optarg, &tmp, 10);
2034                         if (padding <= 0 || *tmp || !is_power_of_2(padding) ||
2035                             padding > INT_MAX)
2036                                 die("Invalid padding amount: %s", optarg);
2037                         break;
2038                 default:
2039                         usage(stderr);
2040                         return 2;
2041                 }
2042         }
2043         argc -= optind;
2044         argv += optind;
2045
2046         if (argc != 2) {
2047                 usage(stderr);
2048                 return 2;
2049         }
2050
2051         cipher = find_fscrypt_cipher(argv[0]);
2052         if (cipher == NULL)
2053                 die("Unknown cipher: %s", argv[0]);
2054
2055         if (block_size < cipher->min_input_size)
2056                 die("Block size of %zu bytes is too small for cipher %s",
2057                     block_size, cipher->name);
2058
2059         params.master_key_size = hex2bin(argv[1], params.master_key,
2060                                          MAX_KEY_SIZE);
2061         if (params.master_key_size < 0)
2062                 die("Invalid master_key: %s", argv[1]);
2063         if (params.master_key_size < cipher->keysize)
2064                 die("Master key is too short for cipher %s", cipher->name);
2065
2066         get_key_and_iv(&params, real_key, cipher->keysize, &iv);
2067
2068         crypt_loop(cipher, real_key, &iv, decrypting, block_size, padding,
2069                    params.iv_ino_lblk_64 || params.iv_ino_lblk_32);
2070         return 0;
2071 }