1 /*
2 * QEMU Crypto XTS cipher mode
3 *
4 * Copyright (c) 2015-2018 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 * This code is originally derived from public domain / WTFPL code in
20 * LibTomCrypt crytographic library http://libtom.org. The XTS code
21 * was donated by Elliptic Semiconductor Inc (www.ellipticsemi.com)
22 * to the LibTom Projects
23 *
24 */
25
26 #include "qemu/osdep.h"
27 #include "crypto/init.h"
28 #include "crypto/xts.h"
29 #include "crypto/aes.h"
30
31 typedef struct {
32 const char *path;
33 int keylen;
34 unsigned char key1[32];
35 unsigned char key2[32];
36 uint64_t seqnum;
37 unsigned long PTLEN;
38 unsigned char PTX[512], CTX[512];
39 } QCryptoXTSTestData;
40
41 static const QCryptoXTSTestData test_data[] = {
42 /* #1 32 byte key, 32 byte PTX */
43 {
44 "/crypto/xts/t-1-key-32-ptx-32",
45 32,
46 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
47 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
48 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
49 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
50 0,
51 32,
52 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
53 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
55 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
56 { 0x91, 0x7c, 0xf6, 0x9e, 0xbd, 0x68, 0xb2, 0xec,
57 0x9b, 0x9f, 0xe9, 0xa3, 0xea, 0xdd, 0xa6, 0x92,
58 0xcd, 0x43, 0xd2, 0xf5, 0x95, 0x98, 0xed, 0x85,
59 0x8c, 0x02, 0xc2, 0x65, 0x2f, 0xbf, 0x92, 0x2e },
60 },
61
62 /* #2, 32 byte key, 32 byte PTX */
63 {
64 "/crypto/xts/t-2-key-32-ptx-32",
65 32,
66 { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
67 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
68 { 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
69 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },
70 0x3333333333LL,
71 32,
72 { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
73 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
74 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
75 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },
76 { 0xc4, 0x54, 0x18, 0x5e, 0x6a, 0x16, 0x93, 0x6e,
77 0x39, 0x33, 0x40, 0x38, 0xac, 0xef, 0x83, 0x8b,
78 0xfb, 0x18, 0x6f, 0xff, 0x74, 0x80, 0xad, 0xc4,
79 0x28, 0x93, 0x82, 0xec, 0xd6, 0xd3, 0x94, 0xf0 },
80 },
81
82 /* #5 from xts.7, 32 byte key, 32 byte PTX */
83 {
84 "/crypto/xts/t-5-key-32-ptx-32",
85 32,
86 { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
87 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0 },
88 { 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
89 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0 },
90 0x123456789aLL,
91 32,
92 { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
93 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
94 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
95 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },
96 { 0xb0, 0x1f, 0x86, 0xf8, 0xed, 0xc1, 0x86, 0x37,
97 0x06, 0xfa, 0x8a, 0x42, 0x53, 0xe3, 0x4f, 0x28,
98 0xaf, 0x31, 0x9d, 0xe3, 0x83, 0x34, 0x87, 0x0f,
99 0x4d, 0xd1, 0xf9, 0x4c, 0xbe, 0x98, 0x32, 0xf1 },
100 },
101
102 /* #4, 32 byte key, 512 byte PTX */
103 {
104 "/crypto/xts/t-4-key-32-ptx-512",
105 32,
106 { 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45,
107 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26 },
108 { 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93,
109 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95 },
110 0,
111 512,
112 {
113 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
114 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
115 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
116 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
117 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
118 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
119 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
120 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
121 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
122 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
123 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
124 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
125 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
126 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
127 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
128 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
129 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
130 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
131 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
132 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
133 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
134 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
135 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
136 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
137 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
138 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
139 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
140 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
141 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
142 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
143 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
144 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
145 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
146 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
147 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
148 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
149 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
150 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
151 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
152 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
153 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
154 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
155 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
156 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
157 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
158 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
159 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
160 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
161 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
162 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
163 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
164 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
165 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
166 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
167 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
168 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
169 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
170 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
171 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
172 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
173 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
174 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
175 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
176 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
177 },
178 {
179 0x27, 0xa7, 0x47, 0x9b, 0xef, 0xa1, 0xd4, 0x76,
180 0x48, 0x9f, 0x30, 0x8c, 0xd4, 0xcf, 0xa6, 0xe2,
181 0xa9, 0x6e, 0x4b, 0xbe, 0x32, 0x08, 0xff, 0x25,
182 0x28, 0x7d, 0xd3, 0x81, 0x96, 0x16, 0xe8, 0x9c,
183 0xc7, 0x8c, 0xf7, 0xf5, 0xe5, 0x43, 0x44, 0x5f,
184 0x83, 0x33, 0xd8, 0xfa, 0x7f, 0x56, 0x00, 0x00,
185 0x05, 0x27, 0x9f, 0xa5, 0xd8, 0xb5, 0xe4, 0xad,
186 0x40, 0xe7, 0x36, 0xdd, 0xb4, 0xd3, 0x54, 0x12,
187 0x32, 0x80, 0x63, 0xfd, 0x2a, 0xab, 0x53, 0xe5,
188 0xea, 0x1e, 0x0a, 0x9f, 0x33, 0x25, 0x00, 0xa5,
189 0xdf, 0x94, 0x87, 0xd0, 0x7a, 0x5c, 0x92, 0xcc,
190 0x51, 0x2c, 0x88, 0x66, 0xc7, 0xe8, 0x60, 0xce,
191 0x93, 0xfd, 0xf1, 0x66, 0xa2, 0x49, 0x12, 0xb4,
192 0x22, 0x97, 0x61, 0x46, 0xae, 0x20, 0xce, 0x84,
193 0x6b, 0xb7, 0xdc, 0x9b, 0xa9, 0x4a, 0x76, 0x7a,
194 0xae, 0xf2, 0x0c, 0x0d, 0x61, 0xad, 0x02, 0x65,
195 0x5e, 0xa9, 0x2d, 0xc4, 0xc4, 0xe4, 0x1a, 0x89,
196 0x52, 0xc6, 0x51, 0xd3, 0x31, 0x74, 0xbe, 0x51,
197 0xa1, 0x0c, 0x42, 0x11, 0x10, 0xe6, 0xd8, 0x15,
198 0x88, 0xed, 0xe8, 0x21, 0x03, 0xa2, 0x52, 0xd8,
199 0xa7, 0x50, 0xe8, 0x76, 0x8d, 0xef, 0xff, 0xed,
200 0x91, 0x22, 0x81, 0x0a, 0xae, 0xb9, 0x9f, 0x91,
201 0x72, 0xaf, 0x82, 0xb6, 0x04, 0xdc, 0x4b, 0x8e,
202 0x51, 0xbc, 0xb0, 0x82, 0x35, 0xa6, 0xf4, 0x34,
203 0x13, 0x32, 0xe4, 0xca, 0x60, 0x48, 0x2a, 0x4b,
204 0xa1, 0xa0, 0x3b, 0x3e, 0x65, 0x00, 0x8f, 0xc5,
205 0xda, 0x76, 0xb7, 0x0b, 0xf1, 0x69, 0x0d, 0xb4,
206 0xea, 0xe2, 0x9c, 0x5f, 0x1b, 0xad, 0xd0, 0x3c,
207 0x5c, 0xcf, 0x2a, 0x55, 0xd7, 0x05, 0xdd, 0xcd,
208 0x86, 0xd4, 0x49, 0x51, 0x1c, 0xeb, 0x7e, 0xc3,
209 0x0b, 0xf1, 0x2b, 0x1f, 0xa3, 0x5b, 0x91, 0x3f,
210 0x9f, 0x74, 0x7a, 0x8a, 0xfd, 0x1b, 0x13, 0x0e,
211 0x94, 0xbf, 0xf9, 0x4e, 0xff, 0xd0, 0x1a, 0x91,
212 0x73, 0x5c, 0xa1, 0x72, 0x6a, 0xcd, 0x0b, 0x19,
213 0x7c, 0x4e, 0x5b, 0x03, 0x39, 0x36, 0x97, 0xe1,
214 0x26, 0x82, 0x6f, 0xb6, 0xbb, 0xde, 0x8e, 0xcc,
215 0x1e, 0x08, 0x29, 0x85, 0x16, 0xe2, 0xc9, 0xed,
216 0x03, 0xff, 0x3c, 0x1b, 0x78, 0x60, 0xf6, 0xde,
217 0x76, 0xd4, 0xce, 0xcd, 0x94, 0xc8, 0x11, 0x98,
218 0x55, 0xef, 0x52, 0x97, 0xca, 0x67, 0xe9, 0xf3,
219 0xe7, 0xff, 0x72, 0xb1, 0xe9, 0x97, 0x85, 0xca,
220 0x0a, 0x7e, 0x77, 0x20, 0xc5, 0xb3, 0x6d, 0xc6,
221 0xd7, 0x2c, 0xac, 0x95, 0x74, 0xc8, 0xcb, 0xbc,
222 0x2f, 0x80, 0x1e, 0x23, 0xe5, 0x6f, 0xd3, 0x44,
223 0xb0, 0x7f, 0x22, 0x15, 0x4b, 0xeb, 0xa0, 0xf0,
224 0x8c, 0xe8, 0x89, 0x1e, 0x64, 0x3e, 0xd9, 0x95,
225 0xc9, 0x4d, 0x9a, 0x69, 0xc9, 0xf1, 0xb5, 0xf4,
226 0x99, 0x02, 0x7a, 0x78, 0x57, 0x2a, 0xee, 0xbd,
227 0x74, 0xd2, 0x0c, 0xc3, 0x98, 0x81, 0xc2, 0x13,
228 0xee, 0x77, 0x0b, 0x10, 0x10, 0xe4, 0xbe, 0xa7,
229 0x18, 0x84, 0x69, 0x77, 0xae, 0x11, 0x9f, 0x7a,
230 0x02, 0x3a, 0xb5, 0x8c, 0xca, 0x0a, 0xd7, 0x52,
231 0xaf, 0xe6, 0x56, 0xbb, 0x3c, 0x17, 0x25, 0x6a,
232 0x9f, 0x6e, 0x9b, 0xf1, 0x9f, 0xdd, 0x5a, 0x38,
233 0xfc, 0x82, 0xbb, 0xe8, 0x72, 0xc5, 0x53, 0x9e,
234 0xdb, 0x60, 0x9e, 0xf4, 0xf7, 0x9c, 0x20, 0x3e,
235 0xbb, 0x14, 0x0f, 0x2e, 0x58, 0x3c, 0xb2, 0xad,
236 0x15, 0xb4, 0xaa, 0x5b, 0x65, 0x50, 0x16, 0xa8,
237 0x44, 0x92, 0x77, 0xdb, 0xd4, 0x77, 0xef, 0x2c,
238 0x8d, 0x6c, 0x01, 0x7d, 0xb7, 0x38, 0xb1, 0x8d,
239 0xeb, 0x4a, 0x42, 0x7d, 0x19, 0x23, 0xce, 0x3f,
240 0xf2, 0x62, 0x73, 0x57, 0x79, 0xa4, 0x18, 0xf2,
241 0x0a, 0x28, 0x2d, 0xf9, 0x20, 0x14, 0x7b, 0xea,
242 0xbe, 0x42, 0x1e, 0xe5, 0x31, 0x9d, 0x05, 0x68,
243 }
244 },
245
246 /* #7, 32 byte key, 17 byte PTX */
247 {
248 "/crypto/xts/t-7-key-32-ptx-17",
249 32,
250 { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
251 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0 },
252 { 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
253 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0 },
254 0x123456789aLL,
255 17,
256 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
257 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 },
258 { 0x6c, 0x16, 0x25, 0xdb, 0x46, 0x71, 0x52, 0x2d,
259 0x3d, 0x75, 0x99, 0x60, 0x1d, 0xe7, 0xca, 0x09, 0xed },
260 },
261
262 /* #15, 32 byte key, 25 byte PTX */
263 {
264 "/crypto/xts/t-15-key-32-ptx-25",
265 32,
266 { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
267 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0 },
268 { 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
269 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0 },
270 0x123456789aLL,
271 25,
272 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
273 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
274 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 },
275 { 0x8f, 0x4d, 0xcb, 0xad, 0x55, 0x55, 0x8d, 0x7b,
276 0x4e, 0x01, 0xd9, 0x37, 0x9c, 0xd4, 0xea, 0x22,
277 0xed, 0xbf, 0x9d, 0xac, 0xe4, 0x5d, 0x6f, 0x6a, 0x73 },
278 },
279
280 /* #21, 32 byte key, 31 byte PTX */
281 {
282 "/crypto/xts/t-21-key-32-ptx-31",
283 32,
284 { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
285 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0 },
286 { 0xbf, 0xbe, 0xbd, 0xbc, 0xbb, 0xba, 0xb9, 0xb8,
287 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1, 0xb0 },
288 0x123456789aLL,
289 31,
290 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
291 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
292 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
293 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e },
294 { 0xd0, 0x5b, 0xc0, 0x90, 0xa8, 0xe0, 0x4f, 0x1b,
295 0x3d, 0x3e, 0xcd, 0xd5, 0xba, 0xec, 0x0f, 0xd4,
296 0xed, 0xbf, 0x9d, 0xac, 0xe4, 0x5d, 0x6f, 0x6a,
297 0x73, 0x06, 0xe6, 0x4b, 0xe5, 0xdd, 0x82 },
298 },
299 };
300
301 #define STORE64L(x, y) \
302 do { \
303 (y)[7] = (unsigned char)(((x) >> 56) & 255); \
304 (y)[6] = (unsigned char)(((x) >> 48) & 255); \
305 (y)[5] = (unsigned char)(((x) >> 40) & 255); \
306 (y)[4] = (unsigned char)(((x) >> 32) & 255); \
307 (y)[3] = (unsigned char)(((x) >> 24) & 255); \
308 (y)[2] = (unsigned char)(((x) >> 16) & 255); \
309 (y)[1] = (unsigned char)(((x) >> 8) & 255); \
310 (y)[0] = (unsigned char)((x) & 255); \
311 } while (0)
312
313 struct TestAES {
314 AES_KEY enc;
315 AES_KEY dec;
316 };
317
test_xts_aes_encrypt(const void * ctx,size_t length,uint8_t * dst,const uint8_t * src)318 static void test_xts_aes_encrypt(const void *ctx,
319 size_t length,
320 uint8_t *dst,
321 const uint8_t *src)
322 {
323 const struct TestAES *aesctx = ctx;
324
325 AES_encrypt(src, dst, &aesctx->enc);
326 }
327
328
test_xts_aes_decrypt(const void * ctx,size_t length,uint8_t * dst,const uint8_t * src)329 static void test_xts_aes_decrypt(const void *ctx,
330 size_t length,
331 uint8_t *dst,
332 const uint8_t *src)
333 {
334 const struct TestAES *aesctx = ctx;
335
336 AES_decrypt(src, dst, &aesctx->dec);
337 }
338
339
test_xts(const void * opaque)340 static void test_xts(const void *opaque)
341 {
342 const QCryptoXTSTestData *data = opaque;
343 uint8_t out[512], Torg[16], T[16];
344 uint64_t seq;
345 struct TestAES aesdata;
346 struct TestAES aestweak;
347
348 AES_set_encrypt_key(data->key1, data->keylen / 2 * 8, &aesdata.enc);
349 AES_set_decrypt_key(data->key1, data->keylen / 2 * 8, &aesdata.dec);
350 AES_set_encrypt_key(data->key2, data->keylen / 2 * 8, &aestweak.enc);
351 AES_set_decrypt_key(data->key2, data->keylen / 2 * 8, &aestweak.dec);
352
353 seq = data->seqnum;
354 STORE64L(seq, Torg);
355 memset(Torg + 8, 0, 8);
356
357 memcpy(T, Torg, sizeof(T));
358 xts_encrypt(&aesdata, &aestweak,
359 test_xts_aes_encrypt,
360 test_xts_aes_decrypt,
361 T, data->PTLEN, out, data->PTX);
362
363 g_assert(memcmp(out, data->CTX, data->PTLEN) == 0);
364
365 memcpy(T, Torg, sizeof(T));
366 xts_decrypt(&aesdata, &aestweak,
367 test_xts_aes_encrypt,
368 test_xts_aes_decrypt,
369 T, data->PTLEN, out, data->CTX);
370
371 g_assert(memcmp(out, data->PTX, data->PTLEN) == 0);
372 }
373
374
test_xts_split(const void * opaque)375 static void test_xts_split(const void *opaque)
376 {
377 const QCryptoXTSTestData *data = opaque;
378 uint8_t out[512], Torg[16], T[16];
379 uint64_t seq;
380 unsigned long len = data->PTLEN / 2;
381 struct TestAES aesdata;
382 struct TestAES aestweak;
383
384 AES_set_encrypt_key(data->key1, data->keylen / 2 * 8, &aesdata.enc);
385 AES_set_decrypt_key(data->key1, data->keylen / 2 * 8, &aesdata.dec);
386 AES_set_encrypt_key(data->key2, data->keylen / 2 * 8, &aestweak.enc);
387 AES_set_decrypt_key(data->key2, data->keylen / 2 * 8, &aestweak.dec);
388
389 seq = data->seqnum;
390 STORE64L(seq, Torg);
391 memset(Torg + 8, 0, 8);
392
393 memcpy(T, Torg, sizeof(T));
394 xts_encrypt(&aesdata, &aestweak,
395 test_xts_aes_encrypt,
396 test_xts_aes_decrypt,
397 T, len, out, data->PTX);
398 xts_encrypt(&aesdata, &aestweak,
399 test_xts_aes_encrypt,
400 test_xts_aes_decrypt,
401 T, len, &out[len], &data->PTX[len]);
402
403 g_assert(memcmp(out, data->CTX, data->PTLEN) == 0);
404
405 memcpy(T, Torg, sizeof(T));
406 xts_decrypt(&aesdata, &aestweak,
407 test_xts_aes_encrypt,
408 test_xts_aes_decrypt,
409 T, len, out, data->CTX);
410 xts_decrypt(&aesdata, &aestweak,
411 test_xts_aes_encrypt,
412 test_xts_aes_decrypt,
413 T, len, &out[len], &data->CTX[len]);
414
415 g_assert(memcmp(out, data->PTX, data->PTLEN) == 0);
416 }
417
418
test_xts_unaligned(const void * opaque)419 static void test_xts_unaligned(const void *opaque)
420 {
421 #define BAD_ALIGN 3
422 const QCryptoXTSTestData *data = opaque;
423 uint8_t in[512 + BAD_ALIGN], out[512 + BAD_ALIGN];
424 uint8_t Torg[16], T[16 + BAD_ALIGN];
425 uint64_t seq;
426 struct TestAES aesdata;
427 struct TestAES aestweak;
428
429 AES_set_encrypt_key(data->key1, data->keylen / 2 * 8, &aesdata.enc);
430 AES_set_decrypt_key(data->key1, data->keylen / 2 * 8, &aesdata.dec);
431 AES_set_encrypt_key(data->key2, data->keylen / 2 * 8, &aestweak.enc);
432 AES_set_decrypt_key(data->key2, data->keylen / 2 * 8, &aestweak.dec);
433
434 seq = data->seqnum;
435 STORE64L(seq, Torg);
436 memset(Torg + 8, 0, 8);
437
438 /* IV not aligned */
439 memcpy(T + BAD_ALIGN, Torg, 16);
440 memcpy(in, data->PTX, data->PTLEN);
441 xts_encrypt(&aesdata, &aestweak,
442 test_xts_aes_encrypt,
443 test_xts_aes_decrypt,
444 T + BAD_ALIGN, data->PTLEN, out, in);
445
446 g_assert(memcmp(out, data->CTX, data->PTLEN) == 0);
447
448 /* plain text not aligned */
449 memcpy(T, Torg, 16);
450 memcpy(in + BAD_ALIGN, data->PTX, data->PTLEN);
451 xts_encrypt(&aesdata, &aestweak,
452 test_xts_aes_encrypt,
453 test_xts_aes_decrypt,
454 T, data->PTLEN, out, in + BAD_ALIGN);
455
456 g_assert(memcmp(out, data->CTX, data->PTLEN) == 0);
457
458 /* cipher text not aligned */
459 memcpy(T, Torg, 16);
460 memcpy(in, data->PTX, data->PTLEN);
461 xts_encrypt(&aesdata, &aestweak,
462 test_xts_aes_encrypt,
463 test_xts_aes_decrypt,
464 T, data->PTLEN, out + BAD_ALIGN, in);
465
466 g_assert(memcmp(out + BAD_ALIGN, data->CTX, data->PTLEN) == 0);
467
468
469 /* IV not aligned */
470 memcpy(T + BAD_ALIGN, Torg, 16);
471 memcpy(in, data->CTX, data->PTLEN);
472 xts_decrypt(&aesdata, &aestweak,
473 test_xts_aes_encrypt,
474 test_xts_aes_decrypt,
475 T + BAD_ALIGN, data->PTLEN, out, in);
476
477 g_assert(memcmp(out, data->PTX, data->PTLEN) == 0);
478
479 /* cipher text not aligned */
480 memcpy(T, Torg, 16);
481 memcpy(in + BAD_ALIGN, data->CTX, data->PTLEN);
482 xts_decrypt(&aesdata, &aestweak,
483 test_xts_aes_encrypt,
484 test_xts_aes_decrypt,
485 T, data->PTLEN, out, in + BAD_ALIGN);
486
487 g_assert(memcmp(out, data->PTX, data->PTLEN) == 0);
488
489 /* plain text not aligned */
490 memcpy(T, Torg, 16);
491 memcpy(in, data->CTX, data->PTLEN);
492 xts_decrypt(&aesdata, &aestweak,
493 test_xts_aes_encrypt,
494 test_xts_aes_decrypt,
495 T, data->PTLEN, out + BAD_ALIGN, in);
496
497 g_assert(memcmp(out + BAD_ALIGN, data->PTX, data->PTLEN) == 0);
498 }
499
500
main(int argc,char ** argv)501 int main(int argc, char **argv)
502 {
503 size_t i;
504
505 g_test_init(&argc, &argv, NULL);
506
507 g_assert(qcrypto_init(NULL) == 0);
508
509 for (i = 0; i < G_N_ELEMENTS(test_data); i++) {
510 gchar *path = g_strdup_printf("%s/basic", test_data[i].path);
511 g_test_add_data_func(path, &test_data[i], test_xts);
512 g_free(path);
513
514 /* skip the cases where the length is smaller than 2*blocklen
515 * or the length is not a multiple of 32
516 */
517 if ((test_data[i].PTLEN >= 32) && !(test_data[i].PTLEN % 32)) {
518 path = g_strdup_printf("%s/split", test_data[i].path);
519 g_test_add_data_func(path, &test_data[i], test_xts_split);
520 g_free(path);
521 }
522
523 path = g_strdup_printf("%s/unaligned", test_data[i].path);
524 g_test_add_data_func(path, &test_data[i], test_xts_unaligned);
525 g_free(path);
526 }
527
528 return g_test_run();
529 }
530