fscrypt-crypt-util: add utility for reproducing fscrypt encrypted data
[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).  For simplicity, all crypto
16  * code here tries to follow the mathematical definitions directly, without
17  * optimizing for performance or worrying about following security best
18  * practices such as mitigating side-channel attacks.  So, only use this program
19  * 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 <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33
34 #define PROGRAM_NAME "fscrypt-crypt-util"
35
36 /*
37  * Define to enable the tests of the crypto code in this file.  If enabled, you
38  * must link this program with OpenSSL (-lcrypto) v1.1.0 or later, and your
39  * kernel needs CONFIG_CRYPTO_USER_API_SKCIPHER=y and CONFIG_CRYPTO_ADIANTUM=y.
40  */
41 #undef ENABLE_ALG_TESTS
42
43 #define NUM_ALG_TEST_ITERATIONS 10000
44
45 static void usage(FILE *fp)
46 {
47         fputs(
48 "Usage: " PROGRAM_NAME " [OPTION]... CIPHER MASTER_KEY\n"
49 "\n"
50 "Utility for verifying fscrypt-encrypted data.  This program encrypts\n"
51 "(or decrypts) the data on stdin using the given CIPHER with the given\n"
52 "MASTER_KEY (or a key derived from it, if a KDF is specified), and writes the\n"
53 "resulting ciphertext (or plaintext) to stdout.\n"
54 "\n"
55 "CIPHER can be AES-256-XTS, AES-256-CTS-CBC, AES-128-CBC-ESSIV, AES-128-CTS-CBC,\n"
56 "or Adiantum.  MASTER_KEY must be a hex string long enough for the cipher.\n"
57 "\n"
58 "WARNING: this program is only meant for testing, not for \"real\" use!\n"
59 "\n"
60 "Options:\n"
61 "  --block-size=BLOCK_SIZE     Encrypt each BLOCK_SIZE bytes independently.\n"
62 "                                Default: 4096 bytes\n"
63 "  --decrypt                   Decrypt instead of encrypt\n"
64 "  --file-nonce=NONCE          File's nonce as a 32-character hex string\n"
65 "  --help                      Show this help\n"
66 "  --kdf=KDF                   Key derivation function to use: AES-128-ECB\n"
67 "                                or none.  Default: none\n"
68 "  --padding=PADDING           If last block is partial, zero-pad it to next\n"
69 "                                PADDING-byte boundary.  Default: BLOCK_SIZE\n"
70         , fp);
71 }
72
73 /*----------------------------------------------------------------------------*
74  *                                 Utilities                                  *
75  *----------------------------------------------------------------------------*/
76
77 #define ARRAY_SIZE(A)           (sizeof(A) / sizeof((A)[0]))
78 #define MIN(x, y)               ((x) < (y) ? (x) : (y))
79 #define MAX(x, y)               ((x) > (y) ? (x) : (y))
80 #define ROUND_DOWN(x, y)        ((x) & ~((y) - 1))
81 #define ROUND_UP(x, y)          (((x) + (y) - 1) & ~((y) - 1))
82 #define DIV_ROUND_UP(n, d)      (((n) + (d) - 1) / (d))
83 #define STATIC_ASSERT(e)        ((void)sizeof(char[1 - 2*!(e)]))
84
85 typedef __u8                    u8;
86 typedef __u16                   u16;
87 typedef __u32                   u32;
88 typedef __u64                   u64;
89
90 #define cpu_to_le32             __cpu_to_le32
91 #define cpu_to_be32             __cpu_to_be32
92 #define cpu_to_le64             __cpu_to_le64
93 #define cpu_to_be64             __cpu_to_be64
94 #define le32_to_cpu             __le32_to_cpu
95 #define be32_to_cpu             __be32_to_cpu
96 #define le64_to_cpu             __le64_to_cpu
97 #define be64_to_cpu             __be64_to_cpu
98
99 #define DEFINE_UNALIGNED_ACCESS_HELPERS(type, native_type)      \
100 static inline native_type __attribute__((unused))               \
101 get_unaligned_##type(const void *p)                             \
102 {                                                               \
103         __##type x;                                             \
104                                                                 \
105         memcpy(&x, p, sizeof(x));                               \
106         return type##_to_cpu(x);                                \
107 }                                                               \
108                                                                 \
109 static inline void __attribute__((unused))                      \
110 put_unaligned_##type(native_type v, void *p)                    \
111 {                                                               \
112         __##type x = cpu_to_##type(v);                          \
113                                                                 \
114         memcpy(p, &x, sizeof(x));                               \
115 }
116
117 DEFINE_UNALIGNED_ACCESS_HELPERS(le32, u32)
118 DEFINE_UNALIGNED_ACCESS_HELPERS(be32, u32)
119 DEFINE_UNALIGNED_ACCESS_HELPERS(le64, u64)
120 DEFINE_UNALIGNED_ACCESS_HELPERS(be64, u64)
121
122 static inline bool is_power_of_2(unsigned long v)
123 {
124         return v != 0 && (v & (v - 1)) == 0;
125 }
126
127 static inline u32 rol32(u32 v, int n)
128 {
129         return (v << n) | (v >> (32 - n));
130 }
131
132 static inline u32 ror32(u32 v, int n)
133 {
134         return (v >> n) | (v << (32 - n));
135 }
136
137 static inline void xor(u8 *res, const u8 *a, const u8 *b, size_t count)
138 {
139         while (count--)
140                 *res++ = *a++ ^ *b++;
141 }
142
143 static void __attribute__((noreturn, format(printf, 2, 3)))
144 do_die(int err, const char *format, ...)
145 {
146         va_list va;
147
148         va_start(va, format);
149         fputs("[" PROGRAM_NAME "] ERROR: ", stderr);
150         vfprintf(stderr, format, va);
151         if (err)
152                 fprintf(stderr, ": %s", strerror(errno));
153         putc('\n', stderr);
154         va_end(va);
155         exit(1);
156 }
157
158 #define die(format, ...)        do_die(0,     (format), ##__VA_ARGS__)
159 #define die_errno(format, ...)  do_die(errno, (format), ##__VA_ARGS__)
160
161 static __attribute__((noreturn)) void
162 assertion_failed(const char *expr, const char *file, int line)
163 {
164         die("Assertion failed: %s at %s:%d", expr, file, line);
165 }
166
167 #define ASSERT(e) ({ if (!(e)) assertion_failed(#e, __FILE__, __LINE__); })
168
169 static void *xmalloc(size_t size)
170 {
171         void *p = malloc(size);
172
173         ASSERT(p != NULL);
174         return p;
175 }
176
177 static int hexchar2bin(char c)
178 {
179         if (c >= 'a' && c <= 'f')
180                 return 10 + c - 'a';
181         if (c >= 'A' && c <= 'F')
182                 return 10 + c - 'A';
183         if (c >= '0' && c <= '9')
184                 return c - '0';
185         return -1;
186 }
187
188 static int hex2bin(const char *hex, u8 *bin, int max_bin_size)
189 {
190         size_t len = strlen(hex);
191         size_t i;
192
193         if (len & 1)
194                 return -1;
195         len /= 2;
196         if (len > max_bin_size)
197                 return -1;
198
199         for (i = 0; i < len; i++) {
200                 int high = hexchar2bin(hex[2 * i]);
201                 int low = hexchar2bin(hex[2 * i + 1]);
202
203                 if (high < 0 || low < 0)
204                         return -1;
205                 bin[i] = (high << 4) | low;
206         }
207         return len;
208 }
209
210 static size_t xread(int fd, void *buf, size_t count)
211 {
212         const size_t orig_count = count;
213
214         while (count) {
215                 ssize_t res = read(fd, buf, count);
216
217                 if (res < 0)
218                         die_errno("read error");
219                 if (res == 0)
220                         break;
221                 buf += res;
222                 count -= res;
223         }
224         return orig_count - count;
225 }
226
227 static void full_write(int fd, const void *buf, size_t count)
228 {
229         while (count) {
230                 ssize_t res = write(fd, buf, count);
231
232                 if (res < 0)
233                         die_errno("write error");
234                 buf += res;
235                 count -= res;
236         }
237 }
238
239 #ifdef ENABLE_ALG_TESTS
240 static void rand_bytes(u8 *buf, size_t count)
241 {
242         while (count--)
243                 *buf++ = rand();
244 }
245 #endif
246
247 /*----------------------------------------------------------------------------*
248  *                          Finite field arithmetic                           *
249  *----------------------------------------------------------------------------*/
250
251 /* Multiply a GF(2^8) element by the polynomial 'x' */
252 static inline u8 gf2_8_mul_x(u8 b)
253 {
254         return (b << 1) ^ ((b & 0x80) ? 0x1B : 0);
255 }
256
257 /* Multiply four packed GF(2^8) elements by the polynomial 'x' */
258 static inline u32 gf2_8_mul_x_4way(u32 w)
259 {
260         return ((w & 0x7F7F7F7F) << 1) ^ (((w & 0x80808080) >> 7) * 0x1B);
261 }
262
263 /* Element of GF(2^128) */
264 typedef struct {
265         __le64 lo;
266         __le64 hi;
267 } ble128;
268
269 /* Multiply a GF(2^128) element by the polynomial 'x' */
270 static inline void gf2_128_mul_x(ble128 *t)
271 {
272         u64 lo = le64_to_cpu(t->lo);
273         u64 hi = le64_to_cpu(t->hi);
274
275         t->hi = cpu_to_le64((hi << 1) | (lo >> 63));
276         t->lo = cpu_to_le64((lo << 1) ^ ((hi & (1ULL << 63)) ? 0x87 : 0));
277 }
278
279 /*----------------------------------------------------------------------------*
280  *                             Group arithmetic                               *
281  *----------------------------------------------------------------------------*/
282
283 /* Element of Z/(2^{128}Z)  (a.k.a. the integers modulo 2^128) */
284 typedef struct {
285         __le64 lo;
286         __le64 hi;
287 } le128;
288
289 static inline void le128_add(le128 *res, const le128 *a, const le128 *b)
290 {
291         u64 a_lo = le64_to_cpu(a->lo);
292         u64 b_lo = le64_to_cpu(b->lo);
293
294         res->lo = cpu_to_le64(a_lo + b_lo);
295         res->hi = cpu_to_le64(le64_to_cpu(a->hi) + le64_to_cpu(b->hi) +
296                               (a_lo + b_lo < a_lo));
297 }
298
299 static inline void le128_sub(le128 *res, const le128 *a, const le128 *b)
300 {
301         u64 a_lo = le64_to_cpu(a->lo);
302         u64 b_lo = le64_to_cpu(b->lo);
303
304         res->lo = cpu_to_le64(a_lo - b_lo);
305         res->hi = cpu_to_le64(le64_to_cpu(a->hi) - le64_to_cpu(b->hi) -
306                               (a_lo - b_lo > a_lo));
307 }
308
309 /*----------------------------------------------------------------------------*
310  *                              AES block cipher                              *
311  *----------------------------------------------------------------------------*/
312
313 /*
314  * Reference: "FIPS 197, Advanced Encryption Standard"
315  *      https://nvlpubs.nist.gov/nistpubs/fips/nist.fips.197.pdf
316  */
317
318 #define AES_BLOCK_SIZE          16
319 #define AES_128_KEY_SIZE        16
320 #define AES_192_KEY_SIZE        24
321 #define AES_256_KEY_SIZE        32
322
323 static inline void AddRoundKey(u32 state[4], const u32 *rk)
324 {
325         int i;
326
327         for (i = 0; i < 4; i++)
328                 state[i] ^= rk[i];
329 }
330
331 static const u8 aes_sbox[256] = {
332         0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
333         0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
334         0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
335         0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
336         0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
337         0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
338         0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
339         0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
340         0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
341         0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
342         0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
343         0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
344         0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
345         0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
346         0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
347         0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
348         0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
349         0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
350         0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
351         0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
352         0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
353         0xb0, 0x54, 0xbb, 0x16,
354 };
355
356 static u8 aes_inverse_sbox[256];
357
358 static void aes_init(void)
359 {
360         int i;
361
362         for (i = 0; i < 256; i++)
363                 aes_inverse_sbox[aes_sbox[i]] = i;
364 }
365
366 static inline u32 DoSubWord(u32 w, const u8 sbox[256])
367 {
368         return ((u32)sbox[(u8)(w >> 24)] << 24) |
369                ((u32)sbox[(u8)(w >> 16)] << 16) |
370                ((u32)sbox[(u8)(w >>  8)] <<  8) |
371                ((u32)sbox[(u8)(w >>  0)] <<  0);
372 }
373
374 static inline u32 SubWord(u32 w)
375 {
376         return DoSubWord(w, aes_sbox);
377 }
378
379 static inline u32 InvSubWord(u32 w)
380 {
381         return DoSubWord(w, aes_inverse_sbox);
382 }
383
384 static inline void SubBytes(u32 state[4])
385 {
386         int i;
387
388         for (i = 0; i < 4; i++)
389                 state[i] = SubWord(state[i]);
390 }
391
392 static inline void InvSubBytes(u32 state[4])
393 {
394         int i;
395
396         for (i = 0; i < 4; i++)
397                 state[i] = InvSubWord(state[i]);
398 }
399
400 static inline void DoShiftRows(u32 state[4], int direction)
401 {
402         u32 newstate[4];
403         int i;
404
405         for (i = 0; i < 4; i++)
406                 newstate[i] = (state[(i + direction*0) & 3] & 0xff) |
407                               (state[(i + direction*1) & 3] & 0xff00) |
408                               (state[(i + direction*2) & 3] & 0xff0000) |
409                               (state[(i + direction*3) & 3] & 0xff000000);
410         memcpy(state, newstate, 16);
411 }
412
413 static inline void ShiftRows(u32 state[4])
414 {
415         DoShiftRows(state, 1);
416 }
417
418 static inline void InvShiftRows(u32 state[4])
419 {
420         DoShiftRows(state, -1);
421 }
422
423 /*
424  * Mix one column by doing the following matrix multiplication in GF(2^8):
425  *
426  *     | 2 3 1 1 |   | w[0] |
427  *     | 1 2 3 1 |   | w[1] |
428  *     | 1 1 2 3 | x | w[2] |
429  *     | 3 1 1 2 |   | w[3] |
430  *
431  * a.k.a. w[i] = 2*w[i] + 3*w[(i+1)%4] + w[(i+2)%4] + w[(i+3)%4]
432  */
433 static inline u32 MixColumn(u32 w)
434 {
435         u32 _2w0_w2 = gf2_8_mul_x_4way(w) ^ ror32(w, 16);
436         u32 _3w1_w3 = ror32(_2w0_w2 ^ w, 8);
437
438         return _2w0_w2 ^ _3w1_w3;
439 }
440
441 /*
442  *           ( | 5 0 4 0 |   | w[0] | )
443  *          (  | 0 5 0 4 |   | w[1] |  )
444  * MixColumn(  | 4 0 5 0 | x | w[2] |  )
445  *           ( | 0 4 0 5 |   | w[3] | )
446  */
447 static inline u32 InvMixColumn(u32 w)
448 {
449         u32 _4w = gf2_8_mul_x_4way(gf2_8_mul_x_4way(w));
450
451         return MixColumn(_4w ^ w ^ ror32(_4w, 16));
452 }
453
454 static inline void MixColumns(u32 state[4])
455 {
456         int i;
457
458         for (i = 0; i < 4; i++)
459                 state[i] = MixColumn(state[i]);
460 }
461
462 static inline void InvMixColumns(u32 state[4])
463 {
464         int i;
465
466         for (i = 0; i < 4; i++)
467                 state[i] = InvMixColumn(state[i]);
468 }
469
470 struct aes_key {
471         u32 round_keys[15 * 4];
472         int nrounds;
473 };
474
475 /* Expand an AES key */
476 static void aes_setkey(struct aes_key *k, const u8 *key, int keysize)
477 {
478         const int N = keysize / 4;
479         u32 * const rk = k->round_keys;
480         u8 rcon = 1;
481         int i;
482
483         ASSERT(keysize == 16 || keysize == 24 || keysize == 32);
484         k->nrounds = 6 + N;
485         for (i = 0; i < 4 * (k->nrounds + 1); i++) {
486                 if (i < N) {
487                         rk[i] = get_unaligned_le32(&key[i * sizeof(__le32)]);
488                 } else if (i % N == 0) {
489                         rk[i] = rk[i - N] ^ SubWord(ror32(rk[i - 1], 8)) ^ rcon;
490                         rcon = gf2_8_mul_x(rcon);
491                 } else if (N > 6 && i % N == 4) {
492                         rk[i] = rk[i - N] ^ SubWord(rk[i - 1]);
493                 } else {
494                         rk[i] = rk[i - N] ^ rk[i - 1];
495                 }
496         }
497 }
498
499 /* Encrypt one 16-byte block with AES */
500 static void aes_encrypt(const struct aes_key *k, const u8 src[AES_BLOCK_SIZE],
501                         u8 dst[AES_BLOCK_SIZE])
502 {
503         u32 state[4];
504         int i;
505
506         for (i = 0; i < 4; i++)
507                 state[i] = get_unaligned_le32(&src[i * sizeof(__le32)]);
508
509         AddRoundKey(state, k->round_keys);
510         for (i = 1; i < k->nrounds; i++) {
511                 SubBytes(state);
512                 ShiftRows(state);
513                 MixColumns(state);
514                 AddRoundKey(state, &k->round_keys[4 * i]);
515         }
516         SubBytes(state);
517         ShiftRows(state);
518         AddRoundKey(state, &k->round_keys[4 * i]);
519
520         for (i = 0; i < 4; i++)
521                 put_unaligned_le32(state[i], &dst[i * sizeof(__le32)]);
522 }
523
524 /* Decrypt one 16-byte block with AES */
525 static void aes_decrypt(const struct aes_key *k, const u8 src[AES_BLOCK_SIZE],
526                         u8 dst[AES_BLOCK_SIZE])
527 {
528         u32 state[4];
529         int i;
530
531         for (i = 0; i < 4; i++)
532                 state[i] = get_unaligned_le32(&src[i * sizeof(__le32)]);
533
534         AddRoundKey(state, &k->round_keys[4 * k->nrounds]);
535         InvShiftRows(state);
536         InvSubBytes(state);
537         for (i = k->nrounds - 1; i >= 1; i--) {
538                 AddRoundKey(state, &k->round_keys[4 * i]);
539                 InvMixColumns(state);
540                 InvShiftRows(state);
541                 InvSubBytes(state);
542         }
543         AddRoundKey(state, k->round_keys);
544
545         for (i = 0; i < 4; i++)
546                 put_unaligned_le32(state[i], &dst[i * sizeof(__le32)]);
547 }
548
549 #ifdef ENABLE_ALG_TESTS
550 #include <openssl/aes.h>
551 static void test_aes_keysize(int keysize)
552 {
553         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
554
555         while (num_tests--) {
556                 struct aes_key k;
557                 AES_KEY ref_k;
558                 u8 key[AES_256_KEY_SIZE];
559                 u8 ptext[AES_BLOCK_SIZE];
560                 u8 ctext[AES_BLOCK_SIZE];
561                 u8 ref_ctext[AES_BLOCK_SIZE];
562                 u8 decrypted[AES_BLOCK_SIZE];
563
564                 rand_bytes(key, keysize);
565                 rand_bytes(ptext, AES_BLOCK_SIZE);
566
567                 aes_setkey(&k, key, keysize);
568                 aes_encrypt(&k, ptext, ctext);
569
570                 ASSERT(AES_set_encrypt_key(key, keysize*8, &ref_k) == 0);
571                 AES_encrypt(ptext, ref_ctext, &ref_k);
572
573                 ASSERT(memcmp(ctext, ref_ctext, AES_BLOCK_SIZE) == 0);
574
575                 aes_decrypt(&k, ctext, decrypted);
576                 ASSERT(memcmp(ptext, decrypted, AES_BLOCK_SIZE) == 0);
577         }
578 }
579
580 static void test_aes(void)
581 {
582         test_aes_keysize(AES_128_KEY_SIZE);
583         test_aes_keysize(AES_192_KEY_SIZE);
584         test_aes_keysize(AES_256_KEY_SIZE);
585 }
586 #endif /* ENABLE_ALG_TESTS */
587
588 /*----------------------------------------------------------------------------*
589  *                                  SHA-256                                   *
590  *----------------------------------------------------------------------------*/
591
592 /*
593  * Reference: "FIPS 180-2, Secure Hash Standard"
594  *      https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2withchangenotice.pdf
595  */
596
597 #define SHA256_DIGEST_SIZE      32
598 #define SHA256_BLOCK_SIZE       64
599
600 #define Ch(x, y, z)     (((x) & (y)) ^ (~(x) & (z)))
601 #define Maj(x, y, z)    (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
602 #define Sigma256_0(x)   (ror32((x),  2) ^ ror32((x), 13) ^ ror32((x), 22))
603 #define Sigma256_1(x)   (ror32((x),  6) ^ ror32((x), 11) ^ ror32((x), 25))
604 #define sigma256_0(x)   (ror32((x),  7) ^ ror32((x), 18) ^ ((x) >>  3))
605 #define sigma256_1(x)   (ror32((x), 17) ^ ror32((x), 19) ^ ((x) >> 10))
606
607 static const u32 sha256_iv[8] = {
608         0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
609         0x1f83d9ab, 0x5be0cd19,
610 };
611
612 static const u32 sha256_round_constants[64] = {
613         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
614         0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
615         0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
616         0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
617         0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
618         0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
619         0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
620         0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
621         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
622         0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
623         0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
624 };
625
626 /* Compute the SHA-256 digest of the given buffer */
627 static void sha256(const u8 *in, size_t inlen, u8 out[SHA256_DIGEST_SIZE])
628 {
629         const size_t msglen = ROUND_UP(inlen + 9, SHA256_BLOCK_SIZE);
630         u8 * const msg = xmalloc(msglen);
631         u32 H[8];
632         int i;
633
634         /* super naive way of handling the padding */
635         memcpy(msg, in, inlen);
636         memset(&msg[inlen], 0, msglen - inlen);
637         msg[inlen] = 0x80;
638         put_unaligned_be64((u64)inlen * 8, &msg[msglen - sizeof(__be64)]);
639         in = msg;
640
641         memcpy(H, sha256_iv, sizeof(H));
642         do {
643                 u32 a = H[0], b = H[1], c = H[2], d = H[3],
644                     e = H[4], f = H[5], g = H[6], h = H[7];
645                 u32 W[64];
646
647                 for (i = 0; i < 16; i++)
648                         W[i] = get_unaligned_be32(&in[i * sizeof(__be32)]);
649                 for (; i < ARRAY_SIZE(W); i++)
650                         W[i] = sigma256_1(W[i - 2]) + W[i - 7] +
651                                sigma256_0(W[i - 15]) + W[i - 16];
652                 for (i = 0; i < ARRAY_SIZE(W); i++) {
653                         u32 T1 = h + Sigma256_1(e) + Ch(e, f, g) +
654                                  sha256_round_constants[i] + W[i];
655                         u32 T2 = Sigma256_0(a) + Maj(a, b, c);
656
657                         h = g; g = f; f = e; e = d + T1;
658                         d = c; c = b; b = a; a = T1 + T2;
659                 }
660                 H[0] += a; H[1] += b; H[2] += c; H[3] += d;
661                 H[4] += e; H[5] += f; H[6] += g; H[7] += h;
662         } while ((in += SHA256_BLOCK_SIZE) != &msg[msglen]);
663
664         for (i = 0; i < ARRAY_SIZE(H); i++)
665                 put_unaligned_be32(H[i], &out[i * sizeof(__be32)]);
666         free(msg);
667 }
668
669 #ifdef ENABLE_ALG_TESTS
670 #include <openssl/sha.h>
671 static void test_sha2(void)
672 {
673         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
674
675         while (num_tests--) {
676                 u8 in[4096];
677                 u8 digest[SHA256_DIGEST_SIZE];
678                 u8 ref_digest[SHA256_DIGEST_SIZE];
679                 const size_t inlen = rand() % (1 + sizeof(in));
680
681                 rand_bytes(in, inlen);
682
683                 sha256(in, inlen, digest);
684                 SHA256(in, inlen, ref_digest);
685                 ASSERT(memcmp(digest, ref_digest, SHA256_DIGEST_SIZE) == 0);
686         }
687 }
688 #endif /* ENABLE_ALG_TESTS */
689
690 /*----------------------------------------------------------------------------*
691  *                            AES encryption modes                            *
692  *----------------------------------------------------------------------------*/
693
694 static void aes_256_xts_crypt(const u8 key[2 * AES_256_KEY_SIZE],
695                               const u8 iv[AES_BLOCK_SIZE], const u8 *src,
696                               u8 *dst, size_t nbytes, bool decrypting)
697 {
698         struct aes_key tweak_key, cipher_key;
699         ble128 t;
700         size_t i;
701
702         ASSERT(nbytes % AES_BLOCK_SIZE == 0);
703         aes_setkey(&cipher_key, key, AES_256_KEY_SIZE);
704         aes_setkey(&tweak_key, &key[AES_256_KEY_SIZE], AES_256_KEY_SIZE);
705         aes_encrypt(&tweak_key, iv, (u8 *)&t);
706         for (i = 0; i < nbytes; i += AES_BLOCK_SIZE) {
707                 xor(&dst[i], &src[i], (const u8 *)&t, AES_BLOCK_SIZE);
708                 if (decrypting)
709                         aes_decrypt(&cipher_key, &dst[i], &dst[i]);
710                 else
711                         aes_encrypt(&cipher_key, &dst[i], &dst[i]);
712                 xor(&dst[i], &dst[i], (const u8 *)&t, AES_BLOCK_SIZE);
713                 gf2_128_mul_x(&t);
714         }
715 }
716
717 static void aes_256_xts_encrypt(const u8 key[2 * AES_256_KEY_SIZE],
718                                 const u8 iv[AES_BLOCK_SIZE], const u8 *src,
719                                 u8 *dst, size_t nbytes)
720 {
721         aes_256_xts_crypt(key, iv, src, dst, nbytes, false);
722 }
723
724 static void aes_256_xts_decrypt(const u8 key[2 * AES_256_KEY_SIZE],
725                                 const u8 iv[AES_BLOCK_SIZE], const u8 *src,
726                                 u8 *dst, size_t nbytes)
727 {
728         aes_256_xts_crypt(key, iv, src, dst, nbytes, true);
729 }
730
731 #ifdef ENABLE_ALG_TESTS
732 #include <openssl/evp.h>
733 static void test_aes_256_xts(void)
734 {
735         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
736         EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
737
738         ASSERT(ctx != NULL);
739         while (num_tests--) {
740                 u8 key[2 * AES_256_KEY_SIZE];
741                 u8 iv[AES_BLOCK_SIZE];
742                 u8 ptext[512];
743                 u8 ctext[sizeof(ptext)];
744                 u8 ref_ctext[sizeof(ptext)];
745                 u8 decrypted[sizeof(ptext)];
746                 const size_t datalen = ROUND_DOWN(rand() % (1 + sizeof(ptext)),
747                                                   AES_BLOCK_SIZE);
748                 int outl, res;
749
750                 rand_bytes(key, sizeof(key));
751                 rand_bytes(iv, sizeof(iv));
752                 rand_bytes(ptext, datalen);
753
754                 aes_256_xts_encrypt(key, iv, ptext, ctext, datalen);
755                 res = EVP_EncryptInit_ex(ctx, EVP_aes_256_xts(), NULL, key, iv);
756                 ASSERT(res > 0);
757                 res = EVP_EncryptUpdate(ctx, ref_ctext, &outl, ptext, datalen);
758                 ASSERT(res > 0);
759                 ASSERT(outl == datalen);
760                 ASSERT(memcmp(ctext, ref_ctext, datalen) == 0);
761
762                 aes_256_xts_decrypt(key, iv, ctext, decrypted, datalen);
763                 ASSERT(memcmp(ptext, decrypted, datalen) == 0);
764         }
765         EVP_CIPHER_CTX_free(ctx);
766 }
767 #endif /* ENABLE_ALG_TESTS */
768
769 static void aes_cbc_encrypt(const struct aes_key *k,
770                             const u8 iv[AES_BLOCK_SIZE],
771                             const u8 *src, u8 *dst, size_t nbytes)
772 {
773         size_t i;
774
775         ASSERT(nbytes % AES_BLOCK_SIZE == 0);
776         for (i = 0; i < nbytes; i += AES_BLOCK_SIZE) {
777                 xor(&dst[i], &src[i], (i == 0 ? iv : &dst[i - AES_BLOCK_SIZE]),
778                     AES_BLOCK_SIZE);
779                 aes_encrypt(k, &dst[i], &dst[i]);
780         }
781 }
782
783 static void aes_cbc_decrypt(const struct aes_key *k,
784                             const u8 iv[AES_BLOCK_SIZE],
785                             const u8 *src, u8 *dst, size_t nbytes)
786 {
787         size_t i = nbytes;
788
789         ASSERT(i % AES_BLOCK_SIZE == 0);
790         while (i) {
791                 i -= AES_BLOCK_SIZE;
792                 aes_decrypt(k, &src[i], &dst[i]);
793                 xor(&dst[i], &dst[i], (i == 0 ? iv : &src[i - AES_BLOCK_SIZE]),
794                     AES_BLOCK_SIZE);
795         }
796 }
797
798 static void aes_cts_cbc_encrypt(const u8 *key, int keysize,
799                                 const u8 iv[AES_BLOCK_SIZE],
800                                 const u8 *src, u8 *dst, size_t nbytes)
801 {
802         const size_t offset = ROUND_DOWN(nbytes - 1, AES_BLOCK_SIZE);
803         const size_t final_bsize = nbytes - offset;
804         struct aes_key k;
805         u8 *pad;
806         u8 buf[AES_BLOCK_SIZE];
807
808         ASSERT(nbytes >= AES_BLOCK_SIZE);
809
810         aes_setkey(&k, key, keysize);
811
812         if (nbytes == AES_BLOCK_SIZE)
813                 return aes_cbc_encrypt(&k, iv, src, dst, nbytes);
814
815         aes_cbc_encrypt(&k, iv, src, dst, offset);
816         pad = &dst[offset - AES_BLOCK_SIZE];
817
818         memcpy(buf, pad, AES_BLOCK_SIZE);
819         xor(buf, buf, &src[offset], final_bsize);
820         memcpy(&dst[offset], pad, final_bsize);
821         aes_encrypt(&k, buf, pad);
822 }
823
824 static void aes_cts_cbc_decrypt(const u8 *key, int keysize,
825                                 const u8 iv[AES_BLOCK_SIZE],
826                                 const u8 *src, u8 *dst, size_t nbytes)
827 {
828         const size_t offset = ROUND_DOWN(nbytes - 1, AES_BLOCK_SIZE);
829         const size_t final_bsize = nbytes - offset;
830         struct aes_key k;
831         u8 *pad;
832
833         ASSERT(nbytes >= AES_BLOCK_SIZE);
834
835         aes_setkey(&k, key, keysize);
836
837         if (nbytes == AES_BLOCK_SIZE)
838                 return aes_cbc_decrypt(&k, iv, src, dst, nbytes);
839
840         pad = &dst[offset - AES_BLOCK_SIZE];
841         aes_decrypt(&k, &src[offset - AES_BLOCK_SIZE], pad);
842         xor(&dst[offset], &src[offset], pad, final_bsize);
843         xor(pad, pad, &dst[offset], final_bsize);
844
845         aes_cbc_decrypt(&k, (offset == AES_BLOCK_SIZE ?
846                              iv : &src[offset - 2 * AES_BLOCK_SIZE]),
847                         pad, pad, AES_BLOCK_SIZE);
848         aes_cbc_decrypt(&k, iv, src, dst, offset - AES_BLOCK_SIZE);
849 }
850
851 static void aes_256_cts_cbc_encrypt(const u8 key[AES_256_KEY_SIZE],
852                                     const u8 iv[AES_BLOCK_SIZE],
853                                     const u8 *src, u8 *dst, size_t nbytes)
854 {
855         aes_cts_cbc_encrypt(key, AES_256_KEY_SIZE, iv, src, dst, nbytes);
856 }
857
858 static void aes_256_cts_cbc_decrypt(const u8 key[AES_256_KEY_SIZE],
859                                     const u8 iv[AES_BLOCK_SIZE],
860                                     const u8 *src, u8 *dst, size_t nbytes)
861 {
862         aes_cts_cbc_decrypt(key, AES_256_KEY_SIZE, iv, src, dst, nbytes);
863 }
864
865 #ifdef ENABLE_ALG_TESTS
866 #include <openssl/modes.h>
867 static void aes_block128_f(const unsigned char in[16],
868                            unsigned char out[16], const void *key)
869 {
870         aes_encrypt(key, in, out);
871 }
872
873 static void test_aes_256_cts_cbc(void)
874 {
875         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
876
877         while (num_tests--) {
878                 u8 key[AES_256_KEY_SIZE];
879                 u8 iv[AES_BLOCK_SIZE];
880                 u8 iv_copy[AES_BLOCK_SIZE];
881                 u8 ptext[512];
882                 u8 ctext[sizeof(ptext)];
883                 u8 ref_ctext[sizeof(ptext)];
884                 u8 decrypted[sizeof(ptext)];
885                 const size_t datalen = 16 + (rand() % (sizeof(ptext) - 15));
886                 struct aes_key k;
887
888                 rand_bytes(key, sizeof(key));
889                 rand_bytes(iv, sizeof(iv));
890                 rand_bytes(ptext, datalen);
891
892                 aes_256_cts_cbc_encrypt(key, iv, ptext, ctext, datalen);
893
894                 /* OpenSSL doesn't allow datalen=AES_BLOCK_SIZE; Linux does */
895                 if (datalen != AES_BLOCK_SIZE) {
896                         aes_setkey(&k, key, sizeof(key));
897                         memcpy(iv_copy, iv, sizeof(iv));
898                         ASSERT(CRYPTO_cts128_encrypt_block(ptext, ref_ctext,
899                                                            datalen, &k, iv_copy,
900                                                            aes_block128_f)
901                                == datalen);
902                         ASSERT(memcmp(ctext, ref_ctext, datalen) == 0);
903                 }
904                 aes_256_cts_cbc_decrypt(key, iv, ctext, decrypted, datalen);
905                 ASSERT(memcmp(ptext, decrypted, datalen) == 0);
906         }
907 }
908 #endif /* ENABLE_ALG_TESTS */
909
910 static void essiv_generate_iv(const u8 orig_key[AES_128_KEY_SIZE],
911                               const u8 orig_iv[AES_BLOCK_SIZE],
912                               u8 real_iv[AES_BLOCK_SIZE])
913 {
914         u8 essiv_key[SHA256_DIGEST_SIZE];
915         struct aes_key essiv;
916
917         /* AES encrypt the original IV using a hash of the original key */
918         STATIC_ASSERT(SHA256_DIGEST_SIZE == AES_256_KEY_SIZE);
919         sha256(orig_key, AES_128_KEY_SIZE, essiv_key);
920         aes_setkey(&essiv, essiv_key, AES_256_KEY_SIZE);
921         aes_encrypt(&essiv, orig_iv, real_iv);
922 }
923
924 static void aes_128_cbc_essiv_encrypt(const u8 key[AES_128_KEY_SIZE],
925                                       const u8 iv[AES_BLOCK_SIZE],
926                                       const u8 *src, u8 *dst, size_t nbytes)
927 {
928         struct aes_key k;
929         u8 real_iv[AES_BLOCK_SIZE];
930
931         aes_setkey(&k, key, AES_128_KEY_SIZE);
932         essiv_generate_iv(key, iv, real_iv);
933         aes_cbc_encrypt(&k, real_iv, src, dst, nbytes);
934 }
935
936 static void aes_128_cbc_essiv_decrypt(const u8 key[AES_128_KEY_SIZE],
937                                       const u8 iv[AES_BLOCK_SIZE],
938                                       const u8 *src, u8 *dst, size_t nbytes)
939 {
940         struct aes_key k;
941         u8 real_iv[AES_BLOCK_SIZE];
942
943         aes_setkey(&k, key, AES_128_KEY_SIZE);
944         essiv_generate_iv(key, iv, real_iv);
945         aes_cbc_decrypt(&k, real_iv, src, dst, nbytes);
946 }
947
948 static void aes_128_cts_cbc_encrypt(const u8 key[AES_128_KEY_SIZE],
949                                     const u8 iv[AES_BLOCK_SIZE],
950                                     const u8 *src, u8 *dst, size_t nbytes)
951 {
952         aes_cts_cbc_encrypt(key, AES_128_KEY_SIZE, iv, src, dst, nbytes);
953 }
954
955 static void aes_128_cts_cbc_decrypt(const u8 key[AES_128_KEY_SIZE],
956                                     const u8 iv[AES_BLOCK_SIZE],
957                                     const u8 *src, u8 *dst, size_t nbytes)
958 {
959         aes_cts_cbc_decrypt(key, AES_128_KEY_SIZE, iv, src, dst, nbytes);
960 }
961
962 /*----------------------------------------------------------------------------*
963  *                           XChaCha12 stream cipher                          *
964  *----------------------------------------------------------------------------*/
965
966 /*
967  * References:
968  *   - "XChaCha: eXtended-nonce ChaCha and AEAD_XChaCha20_Poly1305"
969  *      https://tools.ietf.org/html/draft-arciszewski-xchacha-03
970  *
971  *   - "ChaCha, a variant of Salsa20"
972  *      https://cr.yp.to/chacha/chacha-20080128.pdf
973  *
974  *   - "Extending the Salsa20 nonce"
975  *      https://cr.yp.to/snuffle/xsalsa-20081128.pdf
976  */
977
978 #define CHACHA_KEY_SIZE         32
979 #define XCHACHA_KEY_SIZE        CHACHA_KEY_SIZE
980 #define XCHACHA_NONCE_SIZE      24
981
982 static void chacha_init_state(u32 state[16], const u8 key[CHACHA_KEY_SIZE],
983                               const u8 iv[16])
984 {
985         static const u8 consts[16] = "expand 32-byte k";
986         int i;
987
988         for (i = 0; i < 4; i++)
989                 state[i] = get_unaligned_le32(&consts[i * sizeof(__le32)]);
990         for (i = 0; i < 8; i++)
991                 state[4 + i] = get_unaligned_le32(&key[i * sizeof(__le32)]);
992         for (i = 0; i < 4; i++)
993                 state[12 + i] = get_unaligned_le32(&iv[i * sizeof(__le32)]);
994 }
995
996 #define CHACHA_QUARTERROUND(a, b, c, d)         \
997         do {                                    \
998                 a += b; d = rol32(d ^ a, 16);   \
999                 c += d; b = rol32(b ^ c, 12);   \
1000                 a += b; d = rol32(d ^ a, 8);    \
1001                 c += d; b = rol32(b ^ c, 7);    \
1002         } while (0)
1003
1004 static void chacha_permute(u32 x[16], int nrounds)
1005 {
1006         do {
1007                 /* column round */
1008                 CHACHA_QUARTERROUND(x[0], x[4], x[8], x[12]);
1009                 CHACHA_QUARTERROUND(x[1], x[5], x[9], x[13]);
1010                 CHACHA_QUARTERROUND(x[2], x[6], x[10], x[14]);
1011                 CHACHA_QUARTERROUND(x[3], x[7], x[11], x[15]);
1012
1013                 /* diagonal round */
1014                 CHACHA_QUARTERROUND(x[0], x[5], x[10], x[15]);
1015                 CHACHA_QUARTERROUND(x[1], x[6], x[11], x[12]);
1016                 CHACHA_QUARTERROUND(x[2], x[7], x[8], x[13]);
1017                 CHACHA_QUARTERROUND(x[3], x[4], x[9], x[14]);
1018         } while ((nrounds -= 2) != 0);
1019 }
1020
1021 static void xchacha(const u8 key[XCHACHA_KEY_SIZE],
1022                     const u8 nonce[XCHACHA_NONCE_SIZE],
1023                     const u8 *src, u8 *dst, size_t nbytes, int nrounds)
1024 {
1025         u32 state[16];
1026         u8 real_key[CHACHA_KEY_SIZE];
1027         u8 real_iv[16] = { 0 };
1028         size_t i, j;
1029
1030         /* Compute real key using original key and first 128 nonce bits */
1031         chacha_init_state(state, key, nonce);
1032         chacha_permute(state, nrounds);
1033         for (i = 0; i < 8; i++) /* state words 0..3, 12..15 */
1034                 put_unaligned_le32(state[(i < 4 ? 0 : 8) + i],
1035                                    &real_key[i * sizeof(__le32)]);
1036
1037         /* Now do regular ChaCha, using real key and remaining nonce bits */
1038         memcpy(&real_iv[8], nonce + 16, 8);
1039         chacha_init_state(state, real_key, real_iv);
1040         for (i = 0; i < nbytes; i += 64) {
1041                 u32 x[16];
1042                 __le32 keystream[16];
1043
1044                 memcpy(x, state, 64);
1045                 chacha_permute(x, nrounds);
1046                 for (j = 0; j < 16; j++)
1047                         keystream[j] = cpu_to_le32(x[j] + state[j]);
1048                 xor(&dst[i], &src[i], (u8 *)keystream, MIN(nbytes - i, 64));
1049                 if (++state[12] == 0)
1050                         state[13]++;
1051         }
1052 }
1053
1054 static void xchacha12(const u8 key[XCHACHA_KEY_SIZE],
1055                       const u8 nonce[XCHACHA_NONCE_SIZE],
1056                       const u8 *src, u8 *dst, size_t nbytes)
1057 {
1058         xchacha(key, nonce, src, dst, nbytes, 12);
1059 }
1060
1061 /*----------------------------------------------------------------------------*
1062  *                                 Poly1305                                   *
1063  *----------------------------------------------------------------------------*/
1064
1065 /*
1066  * Note: this is only the Poly1305 ε-almost-∆-universal hash function, not the
1067  * full Poly1305 MAC.  I.e., it doesn't add anything at the end.
1068  */
1069
1070 #define POLY1305_KEY_SIZE       16
1071 #define POLY1305_BLOCK_SIZE     16
1072
1073 static void poly1305(const u8 key[POLY1305_KEY_SIZE],
1074                      const u8 *msg, size_t msglen, le128 *out)
1075 {
1076         const u32 limb_mask = 0x3ffffff;        /* limbs are base 2^26 */
1077         const u64 r0 = (get_unaligned_le32(key +  0) >> 0) & 0x3ffffff;
1078         const u64 r1 = (get_unaligned_le32(key +  3) >> 2) & 0x3ffff03;
1079         const u64 r2 = (get_unaligned_le32(key +  6) >> 4) & 0x3ffc0ff;
1080         const u64 r3 = (get_unaligned_le32(key +  9) >> 6) & 0x3f03fff;
1081         const u64 r4 = (get_unaligned_le32(key + 12) >> 8) & 0x00fffff;
1082         u32 h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0;
1083         u32 g0, g1, g2, g3, g4, ge_p_mask;
1084
1085         /* Partial block support is not necessary for Adiantum */
1086         ASSERT(msglen % POLY1305_BLOCK_SIZE == 0);
1087
1088         while (msglen) {
1089                 u64 d0, d1, d2, d3, d4;
1090
1091                 /* h += *msg */
1092                 h0 += (get_unaligned_le32(msg +  0) >> 0) & limb_mask;
1093                 h1 += (get_unaligned_le32(msg +  3) >> 2) & limb_mask;
1094                 h2 += (get_unaligned_le32(msg +  6) >> 4) & limb_mask;
1095                 h3 += (get_unaligned_le32(msg +  9) >> 6) & limb_mask;
1096                 h4 += (get_unaligned_le32(msg + 12) >> 8) | (1 << 24);
1097
1098                 /* h *= r */
1099                 d0 = h0*r0 + h1*5*r4 + h2*5*r3 + h3*5*r2 + h4*5*r1;
1100                 d1 = h0*r1 + h1*r0   + h2*5*r4 + h3*5*r3 + h4*5*r2;
1101                 d2 = h0*r2 + h1*r1   + h2*r0   + h3*5*r4 + h4*5*r3;
1102                 d3 = h0*r3 + h1*r2   + h2*r1   + h3*r0   + h4*5*r4;
1103                 d4 = h0*r4 + h1*r3   + h2*r2   + h3*r1   + h4*r0;
1104
1105                 /* (partial) h %= 2^130 - 5 */
1106                 d1 += d0 >> 26;         h0 = d0 & limb_mask;
1107                 d2 += d1 >> 26;         h1 = d1 & limb_mask;
1108                 d3 += d2 >> 26;         h2 = d2 & limb_mask;
1109                 d4 += d3 >> 26;         h3 = d3 & limb_mask;
1110                 h0 += (d4 >> 26) * 5;   h4 = d4 & limb_mask;
1111                 h1 += h0 >> 26;         h0 &= limb_mask;
1112
1113                 msg += POLY1305_BLOCK_SIZE;
1114                 msglen -= POLY1305_BLOCK_SIZE;
1115         }
1116
1117         /* fully carry h */
1118         h2 += (h1 >> 26);       h1 &= limb_mask;
1119         h3 += (h2 >> 26);       h2 &= limb_mask;
1120         h4 += (h3 >> 26);       h3 &= limb_mask;
1121         h0 += (h4 >> 26) * 5;   h4 &= limb_mask;
1122         h1 += (h0 >> 26);       h0 &= limb_mask;
1123
1124         /* if (h >= 2^130 - 5) h -= 2^130 - 5; */
1125         g0 = h0 + 5;
1126         g1 = h1 + (g0 >> 26);   g0 &= limb_mask;
1127         g2 = h2 + (g1 >> 26);   g1 &= limb_mask;
1128         g3 = h3 + (g2 >> 26);   g2 &= limb_mask;
1129         g4 = h4 + (g3 >> 26);   g3 &= limb_mask;
1130         ge_p_mask = ~((g4 >> 26) - 1); /* all 1's if h >= 2^130 - 5, else 0 */
1131         h0 = (h0 & ~ge_p_mask) | (g0 & ge_p_mask);
1132         h1 = (h1 & ~ge_p_mask) | (g1 & ge_p_mask);
1133         h2 = (h2 & ~ge_p_mask) | (g2 & ge_p_mask);
1134         h3 = (h3 & ~ge_p_mask) | (g3 & ge_p_mask);
1135         h4 = (h4 & ~ge_p_mask) | (g4 & ge_p_mask & limb_mask);
1136
1137         /* h %= 2^128 */
1138         out->lo = cpu_to_le64(((u64)h2 << 52) | ((u64)h1 << 26) | h0);
1139         out->hi = cpu_to_le64(((u64)h4 << 40) | ((u64)h3 << 14) | (h2 >> 12));
1140 }
1141
1142 /*----------------------------------------------------------------------------*
1143  *                          Adiantum encryption mode                          *
1144  *----------------------------------------------------------------------------*/
1145
1146 /*
1147  * Reference: "Adiantum: length-preserving encryption for entry-level processors"
1148  *      https://tosc.iacr.org/index.php/ToSC/article/view/7360
1149  */
1150
1151 #define ADIANTUM_KEY_SIZE       32
1152 #define ADIANTUM_IV_SIZE        32
1153 #define ADIANTUM_HASH_KEY_SIZE  ((2 * POLY1305_KEY_SIZE) + NH_KEY_SIZE)
1154
1155 #define NH_KEY_SIZE             1072
1156 #define NH_KEY_WORDS            (NH_KEY_SIZE / sizeof(u32))
1157 #define NH_BLOCK_SIZE           1024
1158 #define NH_HASH_SIZE            32
1159 #define NH_MESSAGE_UNIT         16
1160
1161 static u64 nh_pass(const u32 *key, const u8 *msg, size_t msglen)
1162 {
1163         u64 sum = 0;
1164
1165         ASSERT(msglen % NH_MESSAGE_UNIT == 0);
1166         while (msglen) {
1167                 sum += (u64)(u32)(get_unaligned_le32(msg +  0) + key[0]) *
1168                             (u32)(get_unaligned_le32(msg +  8) + key[2]);
1169                 sum += (u64)(u32)(get_unaligned_le32(msg +  4) + key[1]) *
1170                             (u32)(get_unaligned_le32(msg + 12) + key[3]);
1171                 key += NH_MESSAGE_UNIT / sizeof(key[0]);
1172                 msg += NH_MESSAGE_UNIT;
1173                 msglen -= NH_MESSAGE_UNIT;
1174         }
1175         return sum;
1176 }
1177
1178 /* NH ε-almost-universal hash function */
1179 static void nh(const u32 *key, const u8 *msg, size_t msglen,
1180                u8 result[NH_HASH_SIZE])
1181 {
1182         size_t i;
1183
1184         for (i = 0; i < NH_HASH_SIZE; i += sizeof(__le64)) {
1185                 put_unaligned_le64(nh_pass(key, msg, msglen), &result[i]);
1186                 key += NH_MESSAGE_UNIT / sizeof(key[0]);
1187         }
1188 }
1189
1190 /* Adiantum's ε-almost-∆-universal hash function */
1191 static void adiantum_hash(const u8 key[ADIANTUM_HASH_KEY_SIZE],
1192                           const u8 iv[ADIANTUM_IV_SIZE],
1193                           const u8 *msg, size_t msglen, le128 *result)
1194 {
1195         const u8 *header_poly_key = key;
1196         const u8 *msg_poly_key = header_poly_key + POLY1305_KEY_SIZE;
1197         const u8 *nh_key = msg_poly_key + POLY1305_KEY_SIZE;
1198         u32 nh_key_words[NH_KEY_WORDS];
1199         u8 header[POLY1305_BLOCK_SIZE + ADIANTUM_IV_SIZE];
1200         const size_t num_nh_blocks = DIV_ROUND_UP(msglen, NH_BLOCK_SIZE);
1201         u8 *nh_hashes = xmalloc(num_nh_blocks * NH_HASH_SIZE);
1202         const size_t padded_msglen = ROUND_UP(msglen, NH_MESSAGE_UNIT);
1203         u8 *padded_msg = xmalloc(padded_msglen);
1204         le128 hash1, hash2;
1205         size_t i;
1206
1207         for (i = 0; i < NH_KEY_WORDS; i++)
1208                 nh_key_words[i] = get_unaligned_le32(&nh_key[i * sizeof(u32)]);
1209
1210         /* Hash tweak and message length with first Poly1305 key */
1211         put_unaligned_le64((u64)msglen * 8, header);
1212         put_unaligned_le64(0, &header[sizeof(__le64)]);
1213         memcpy(&header[POLY1305_BLOCK_SIZE], iv, ADIANTUM_IV_SIZE);
1214         poly1305(header_poly_key, header, sizeof(header), &hash1);
1215
1216         /* Hash NH hashes of message blocks using second Poly1305 key */
1217         /* (using a super naive way of handling the padding) */
1218         memcpy(padded_msg, msg, msglen);
1219         memset(&padded_msg[msglen], 0, padded_msglen - msglen);
1220         for (i = 0; i < num_nh_blocks; i++) {
1221                 nh(nh_key_words, &padded_msg[i * NH_BLOCK_SIZE],
1222                    MIN(NH_BLOCK_SIZE, padded_msglen - (i * NH_BLOCK_SIZE)),
1223                    &nh_hashes[i * NH_HASH_SIZE]);
1224         }
1225         poly1305(msg_poly_key, nh_hashes, num_nh_blocks * NH_HASH_SIZE, &hash2);
1226
1227         /* Add the two hashes together to get the final hash */
1228         le128_add(result, &hash1, &hash2);
1229
1230         free(nh_hashes);
1231         free(padded_msg);
1232 }
1233
1234 static void adiantum_crypt(const u8 key[ADIANTUM_KEY_SIZE],
1235                            const u8 iv[ADIANTUM_IV_SIZE], const u8 *src,
1236                            u8 *dst, size_t nbytes, bool decrypting)
1237 {
1238         u8 subkeys[AES_256_KEY_SIZE + ADIANTUM_HASH_KEY_SIZE] = { 0 };
1239         struct aes_key aes_key;
1240         union {
1241                 u8 nonce[XCHACHA_NONCE_SIZE];
1242                 le128 block;
1243         } u = { .nonce = { 1 } };
1244         const size_t bulk_len = nbytes - sizeof(u.block);
1245         le128 hash;
1246
1247         ASSERT(nbytes >= sizeof(u.block));
1248
1249         /* Derive subkeys */
1250         xchacha12(key, u.nonce, subkeys, subkeys, sizeof(subkeys));
1251         aes_setkey(&aes_key, subkeys, AES_256_KEY_SIZE);
1252
1253         /* Hash left part and add to right part */
1254         adiantum_hash(&subkeys[AES_256_KEY_SIZE], iv, src, bulk_len, &hash);
1255         memcpy(&u.block, &src[bulk_len], sizeof(u.block));
1256         le128_add(&u.block, &u.block, &hash);
1257
1258         if (!decrypting) /* Encrypt right part with block cipher */
1259                 aes_encrypt(&aes_key, u.nonce, u.nonce);
1260
1261         /* Encrypt left part with stream cipher, using the computed nonce */
1262         u.nonce[sizeof(u.block)] = 1;
1263         xchacha12(key, u.nonce, src, dst, bulk_len);
1264
1265         if (decrypting) /* Decrypt right part with block cipher */
1266                 aes_decrypt(&aes_key, u.nonce, u.nonce);
1267
1268         /* Finalize right part by subtracting hash of left part */
1269         adiantum_hash(&subkeys[AES_256_KEY_SIZE], iv, dst, bulk_len, &hash);
1270         le128_sub(&u.block, &u.block, &hash);
1271         memcpy(&dst[bulk_len], &u.block, sizeof(u.block));
1272 }
1273
1274 static void adiantum_encrypt(const u8 key[ADIANTUM_KEY_SIZE],
1275                              const u8 iv[ADIANTUM_IV_SIZE],
1276                              const u8 *src, u8 *dst, size_t nbytes)
1277 {
1278         adiantum_crypt(key, iv, src, dst, nbytes, false);
1279 }
1280
1281 static void adiantum_decrypt(const u8 key[ADIANTUM_KEY_SIZE],
1282                              const u8 iv[ADIANTUM_IV_SIZE],
1283                              const u8 *src, u8 *dst, size_t nbytes)
1284 {
1285         adiantum_crypt(key, iv, src, dst, nbytes, true);
1286 }
1287
1288 #ifdef ENABLE_ALG_TESTS
1289 #include <linux/if_alg.h>
1290 #include <sys/socket.h>
1291 #define SOL_ALG 279
1292 static void af_alg_crypt(int algfd, int op, const u8 *key, size_t keylen,
1293                          const u8 *iv, size_t ivlen,
1294                          const u8 *src, u8 *dst, size_t datalen)
1295 {
1296         size_t controllen = CMSG_SPACE(sizeof(int)) +
1297                             CMSG_SPACE(sizeof(struct af_alg_iv) + ivlen);
1298         u8 *control = xmalloc(controllen);
1299         struct iovec iov = { .iov_base = (u8 *)src, .iov_len = datalen };
1300         struct msghdr msg = {
1301                 .msg_iov = &iov,
1302                 .msg_iovlen = 1,
1303                 .msg_control = control,
1304                 .msg_controllen = controllen,
1305         };
1306         struct cmsghdr *cmsg;
1307         struct af_alg_iv *algiv;
1308         int reqfd;
1309
1310         memset(control, 0, controllen);
1311
1312         cmsg = CMSG_FIRSTHDR(&msg);
1313         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
1314         cmsg->cmsg_level = SOL_ALG;
1315         cmsg->cmsg_type = ALG_SET_OP;
1316         *(int *)CMSG_DATA(cmsg) = op;
1317
1318         cmsg = CMSG_NXTHDR(&msg, cmsg);
1319         cmsg->cmsg_len = CMSG_LEN(sizeof(struct af_alg_iv) + ivlen);
1320         cmsg->cmsg_level = SOL_ALG;
1321         cmsg->cmsg_type = ALG_SET_IV;
1322         algiv = (struct af_alg_iv *)CMSG_DATA(cmsg);
1323         algiv->ivlen = ivlen;
1324         memcpy(algiv->iv, iv, ivlen);
1325
1326         if (setsockopt(algfd, SOL_ALG, ALG_SET_KEY, key, keylen) != 0)
1327                 die_errno("can't set key on AF_ALG socket");
1328
1329         reqfd = accept(algfd, NULL, NULL);
1330         if (reqfd < 0)
1331                 die_errno("can't accept() AF_ALG socket");
1332         if (sendmsg(reqfd, &msg, 0) != datalen)
1333                 die_errno("can't sendmsg() AF_ALG request socket");
1334         if (xread(reqfd, dst, datalen) != datalen)
1335                 die("short read from AF_ALG request socket");
1336         close(reqfd);
1337
1338         free(control);
1339 }
1340
1341 static void test_adiantum(void)
1342 {
1343         int algfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
1344         struct sockaddr_alg addr = {
1345                 .salg_type = "skcipher",
1346                 .salg_name = "adiantum(xchacha12,aes)",
1347         };
1348         unsigned long num_tests = NUM_ALG_TEST_ITERATIONS;
1349
1350         if (algfd < 0)
1351                 die_errno("can't create AF_ALG socket");
1352         if (bind(algfd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
1353                 die_errno("can't bind AF_ALG socket to Adiantum algorithm");
1354
1355         while (num_tests--) {
1356                 u8 key[ADIANTUM_KEY_SIZE];
1357                 u8 iv[ADIANTUM_IV_SIZE];
1358                 u8 ptext[4096];
1359                 u8 ctext[sizeof(ptext)];
1360                 u8 ref_ctext[sizeof(ptext)];
1361                 u8 decrypted[sizeof(ptext)];
1362                 const size_t datalen = 16 + (rand() % (sizeof(ptext) - 15));
1363
1364                 rand_bytes(key, sizeof(key));
1365                 rand_bytes(iv, sizeof(iv));
1366                 rand_bytes(ptext, datalen);
1367
1368                 adiantum_encrypt(key, iv, ptext, ctext, datalen);
1369                 af_alg_crypt(algfd, ALG_OP_ENCRYPT, key, sizeof(key),
1370                              iv, sizeof(iv), ptext, ref_ctext, datalen);
1371                 ASSERT(memcmp(ctext, ref_ctext, datalen) == 0);
1372
1373                 adiantum_decrypt(key, iv, ctext, decrypted, datalen);
1374                 ASSERT(memcmp(ptext, decrypted, datalen) == 0);
1375         }
1376         close(algfd);
1377 }
1378 #endif /* ENABLE_ALG_TESTS */
1379
1380 /*----------------------------------------------------------------------------*
1381  *                               Main program                                 *
1382  *----------------------------------------------------------------------------*/
1383
1384 #define FILE_NONCE_SIZE         16
1385 #define MAX_KEY_SIZE            64
1386
1387 static const struct fscrypt_cipher {
1388         const char *name;
1389         void (*encrypt)(const u8 *key, const u8 *iv, const u8 *src,
1390                         u8 *dst, size_t nbytes);
1391         void (*decrypt)(const u8 *key, const u8 *iv, const u8 *src,
1392                         u8 *dst, size_t nbytes);
1393         int keysize;
1394         int min_input_size;
1395 } fscrypt_ciphers[] = {
1396         {
1397                 .name = "AES-256-XTS",
1398                 .encrypt = aes_256_xts_encrypt,
1399                 .decrypt = aes_256_xts_decrypt,
1400                 .keysize = 2 * AES_256_KEY_SIZE,
1401         }, {
1402                 .name = "AES-256-CTS-CBC",
1403                 .encrypt = aes_256_cts_cbc_encrypt,
1404                 .decrypt = aes_256_cts_cbc_decrypt,
1405                 .keysize = AES_256_KEY_SIZE,
1406                 .min_input_size = AES_BLOCK_SIZE,
1407         }, {
1408                 .name = "AES-128-CBC-ESSIV",
1409                 .encrypt = aes_128_cbc_essiv_encrypt,
1410                 .decrypt = aes_128_cbc_essiv_decrypt,
1411                 .keysize = AES_128_KEY_SIZE,
1412         }, {
1413                 .name = "AES-128-CTS-CBC",
1414                 .encrypt = aes_128_cts_cbc_encrypt,
1415                 .decrypt = aes_128_cts_cbc_decrypt,
1416                 .keysize = AES_128_KEY_SIZE,
1417                 .min_input_size = AES_BLOCK_SIZE,
1418         }, {
1419                 .name = "Adiantum",
1420                 .encrypt = adiantum_encrypt,
1421                 .decrypt = adiantum_decrypt,
1422                 .keysize = ADIANTUM_KEY_SIZE,
1423                 .min_input_size = AES_BLOCK_SIZE,
1424         }
1425 };
1426
1427 static const struct fscrypt_cipher *find_fscrypt_cipher(const char *name)
1428 {
1429         size_t i;
1430
1431         for (i = 0; i < ARRAY_SIZE(fscrypt_ciphers); i++) {
1432                 if (strcmp(fscrypt_ciphers[i].name, name) == 0)
1433                         return &fscrypt_ciphers[i];
1434         }
1435         return NULL;
1436 }
1437
1438 struct fscrypt_iv {
1439         union {
1440                 __le64 block_num;
1441                 u8 bytes[32];
1442         };
1443 };
1444
1445 static void crypt_loop(const struct fscrypt_cipher *cipher, const u8 *key,
1446                        struct fscrypt_iv *iv, bool decrypting,
1447                        size_t block_size, size_t padding)
1448 {
1449         u8 *buf = xmalloc(block_size);
1450         size_t res;
1451
1452         while ((res = xread(STDIN_FILENO, buf, block_size)) > 0) {
1453                 size_t crypt_len = block_size;
1454
1455                 if (padding > 0) {
1456                         crypt_len = MAX(res, cipher->min_input_size);
1457                         crypt_len = ROUND_UP(crypt_len, padding);
1458                         crypt_len = MIN(crypt_len, block_size);
1459                 }
1460                 ASSERT(crypt_len >= res);
1461                 memset(&buf[res], 0, crypt_len - res);
1462
1463                 if (decrypting)
1464                         cipher->decrypt(key, iv->bytes, buf, buf, crypt_len);
1465                 else
1466                         cipher->encrypt(key, iv->bytes, buf, buf, crypt_len);
1467
1468                 full_write(STDOUT_FILENO, buf, crypt_len);
1469
1470                 iv->block_num = cpu_to_le64(le64_to_cpu(iv->block_num) + 1);
1471         }
1472         free(buf);
1473 }
1474
1475 /* The supported key derivation functions */
1476 enum kdf_algorithm {
1477         KDF_NONE,
1478         KDF_AES_128_ECB,
1479 };
1480
1481 static enum kdf_algorithm parse_kdf_algorithm(const char *arg)
1482 {
1483         if (strcmp(arg, "none") == 0)
1484                 return KDF_NONE;
1485         if (strcmp(arg, "AES-128-ECB") == 0)
1486                 return KDF_AES_128_ECB;
1487         die("Unknown KDF: %s", arg);
1488 }
1489
1490 /*
1491  * Get the key and starting IV with which the encryption will actually be done.
1492  * If a KDF was specified, a subkey is derived from the master key and file
1493  * nonce.  Otherwise, the master key is used directly.
1494  */
1495 static void get_key_and_iv(const u8 *master_key, size_t master_key_size,
1496                            enum kdf_algorithm kdf,
1497                            const u8 nonce[FILE_NONCE_SIZE],
1498                            u8 *real_key, size_t real_key_size,
1499                            struct fscrypt_iv *iv)
1500 {
1501         struct aes_key aes_key;
1502         size_t i;
1503
1504         ASSERT(real_key_size <= master_key_size);
1505
1506         memset(iv, 0, sizeof(*iv));
1507
1508         switch (kdf) {
1509         case KDF_NONE:
1510                 memcpy(real_key, master_key, real_key_size);
1511                 if (nonce != NULL)
1512                         memcpy(&iv->bytes[8], nonce, FILE_NONCE_SIZE);
1513                 break;
1514         case KDF_AES_128_ECB:
1515                 if (nonce == NULL)
1516                         die("--file-nonce is required with --kdf=AES-128-ECB");
1517                 STATIC_ASSERT(FILE_NONCE_SIZE == AES_128_KEY_SIZE);
1518                 ASSERT(real_key_size % AES_BLOCK_SIZE == 0);
1519                 aes_setkey(&aes_key, nonce, AES_128_KEY_SIZE);
1520                 for (i = 0; i < real_key_size; i += AES_BLOCK_SIZE)
1521                         aes_encrypt(&aes_key, &master_key[i], &real_key[i]);
1522                 break;
1523         default:
1524                 ASSERT(0);
1525         }
1526 }
1527
1528 enum {
1529         OPT_BLOCK_SIZE,
1530         OPT_DECRYPT,
1531         OPT_FILE_NONCE,
1532         OPT_HELP,
1533         OPT_KDF,
1534         OPT_PADDING,
1535 };
1536
1537 static const struct option longopts[] = {
1538         { "block-size",      required_argument, NULL, OPT_BLOCK_SIZE },
1539         { "decrypt",         no_argument,       NULL, OPT_DECRYPT },
1540         { "file-nonce",      required_argument, NULL, OPT_FILE_NONCE },
1541         { "help",            no_argument,       NULL, OPT_HELP },
1542         { "kdf",             required_argument, NULL, OPT_KDF },
1543         { "padding",         required_argument, NULL, OPT_PADDING },
1544         { NULL, 0, NULL, 0 },
1545 };
1546
1547 int main(int argc, char *argv[])
1548 {
1549         size_t block_size = 4096;
1550         bool decrypting = false;
1551         u8 _file_nonce[FILE_NONCE_SIZE];
1552         u8 *file_nonce = NULL;
1553         enum kdf_algorithm kdf = KDF_NONE;
1554         size_t padding = 0;
1555         const struct fscrypt_cipher *cipher;
1556         u8 master_key[MAX_KEY_SIZE];
1557         int master_key_size;
1558         u8 real_key[MAX_KEY_SIZE];
1559         struct fscrypt_iv iv;
1560         char *tmp;
1561         int c;
1562
1563         aes_init();
1564
1565 #ifdef ENABLE_ALG_TESTS
1566         test_aes();
1567         test_sha2();
1568         test_aes_256_xts();
1569         test_aes_256_cts_cbc();
1570         test_adiantum();
1571 #endif
1572
1573         while ((c = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
1574                 switch (c) {
1575                 case OPT_BLOCK_SIZE:
1576                         block_size = strtoul(optarg, &tmp, 10);
1577                         if (block_size <= 0 || *tmp)
1578                                 die("Invalid block size: %s", optarg);
1579                         break;
1580                 case OPT_DECRYPT:
1581                         decrypting = true;
1582                         break;
1583                 case OPT_FILE_NONCE:
1584                         if (hex2bin(optarg, _file_nonce, FILE_NONCE_SIZE) !=
1585                             FILE_NONCE_SIZE)
1586                                 die("Invalid file nonce: %s", optarg);
1587                         file_nonce = _file_nonce;
1588                         break;
1589                 case OPT_HELP:
1590                         usage(stdout);
1591                         return 0;
1592                 case OPT_KDF:
1593                         kdf = parse_kdf_algorithm(optarg);
1594                         break;
1595                 case OPT_PADDING:
1596                         padding = strtoul(optarg, &tmp, 10);
1597                         if (padding <= 0 || *tmp || !is_power_of_2(padding) ||
1598                             padding > INT_MAX)
1599                                 die("Invalid padding amount: %s", optarg);
1600                         break;
1601                 default:
1602                         usage(stderr);
1603                         return 2;
1604                 }
1605         }
1606         argc -= optind;
1607         argv += optind;
1608
1609         if (argc != 2) {
1610                 usage(stderr);
1611                 return 2;
1612         }
1613
1614         cipher = find_fscrypt_cipher(argv[0]);
1615         if (cipher == NULL)
1616                 die("Unknown cipher: %s", argv[0]);
1617
1618         if (block_size < cipher->min_input_size)
1619                 die("Block size of %zu bytes is too small for cipher %s",
1620                     block_size, cipher->name);
1621
1622         master_key_size = hex2bin(argv[1], master_key, MAX_KEY_SIZE);
1623         if (master_key_size < 0)
1624                 die("Invalid master_key: %s", argv[1]);
1625         if (master_key_size < cipher->keysize)
1626                 die("Master key is too short for cipher %s", cipher->name);
1627
1628         get_key_and_iv(master_key, master_key_size, kdf, file_nonce,
1629                        real_key, cipher->keysize, &iv);
1630
1631         crypt_loop(cipher, real_key, &iv, decrypting, block_size, padding);
1632         return 0;
1633 }