vSMC
vSMC: Scalable Monte Carlo
aes.hpp
Go to the documentation of this file.
1 //============================================================================
2 // vSMC/include/vsmc/rng/aes.hpp
3 //----------------------------------------------------------------------------
4 // vSMC: Scalable Monte Carlo
5 //----------------------------------------------------------------------------
6 // Copyright (c) 2013-2015, Yan Zhou
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are met:
11 //
12 // Redistributions of source code must retain the above copyright notice,
13 // this list of conditions and the following disclaimer.
14 //
15 // Redistributions in binary form must reproduce the above copyright notice,
16 // this list of conditions and the following disclaimer in the documentation
17 // and/or other materials provided with the distribution.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
20 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 // POSSIBILITY OF SUCH DAMAGE.
30 //============================================================================
31 
32 #ifndef VSMC_RNG_AES_HPP
33 #define VSMC_RNG_AES_HPP
34 
35 #include <vsmc/rng/internal/common.hpp>
36 #include <vsmc/rng/aes_ni.hpp>
37 
38 #define VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(N, val) \
39  template <> \
40  class AESRoundConstant<N> : public std::integral_constant<int, val> \
41  { \
42  }; // class AESRoundConstant
43 
46 #ifndef VSMC_RNG_AES_BLOCKS
47 #define VSMC_RNG_AES_BLOCKS 4
48 #endif
49 
50 namespace vsmc
51 {
52 
53 namespace internal
54 {
55 
56 template <std::size_t N>
57 class AESRoundConstant;
58 
59 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x00, 0x8D)
60 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x01, 0x01)
61 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x02, 0x02)
62 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x03, 0x04)
63 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x04, 0x08)
64 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x05, 0x10)
65 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x06, 0x20)
66 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x07, 0x40)
67 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x08, 0x80)
68 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x09, 0x1B)
69 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0A, 0x36)
70 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0B, 0x6C)
71 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0C, 0xD8)
72 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0D, 0xAB)
73 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0E, 0x4D)
74 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0F, 0x9A)
75 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x10, 0x2F)
76 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x11, 0x5E)
77 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x12, 0xBC)
78 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x13, 0x63)
79 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x14, 0xC6)
80 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x15, 0x97)
81 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x16, 0x35)
82 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x17, 0x6A)
83 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x18, 0xD4)
84 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x19, 0xB3)
85 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1A, 0x7D)
86 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1B, 0xFA)
87 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1C, 0xEF)
88 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1D, 0xC5)
89 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1E, 0x91)
90 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1F, 0x39)
91 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x20, 0x72)
92 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x21, 0xE4)
93 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x22, 0xD3)
94 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x23, 0xBD)
95 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x24, 0x61)
96 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x25, 0xC2)
97 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x26, 0x9F)
98 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x27, 0x25)
99 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x28, 0x4A)
100 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x29, 0x94)
101 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2A, 0x33)
102 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2B, 0x66)
103 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2C, 0xCC)
104 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2D, 0x83)
105 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2E, 0x1D)
106 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2F, 0x3A)
107 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x30, 0x74)
108 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x31, 0xE8)
109 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x32, 0xCB)
110 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x33, 0x8D)
111 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x34, 0x01)
112 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x35, 0x02)
113 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x36, 0x04)
114 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x37, 0x08)
115 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x38, 0x10)
116 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x39, 0x20)
117 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3A, 0x40)
118 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3B, 0x80)
119 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3C, 0x1B)
120 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3D, 0x36)
121 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3E, 0x6C)
122 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3F, 0xD8)
123 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x40, 0xAB)
124 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x41, 0x4D)
125 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x42, 0x9A)
126 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x43, 0x2F)
127 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x44, 0x5E)
128 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x45, 0xBC)
129 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x46, 0x63)
130 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x47, 0xC6)
131 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x48, 0x97)
132 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x49, 0x35)
133 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4A, 0x6A)
134 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4B, 0xD4)
135 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4C, 0xB3)
136 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4D, 0x7D)
137 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4E, 0xFA)
138 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4F, 0xEF)
139 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x50, 0xC5)
140 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x51, 0x91)
141 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x52, 0x39)
142 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x53, 0x72)
143 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x54, 0xE4)
144 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x55, 0xD3)
145 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x56, 0xBD)
146 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x57, 0x61)
147 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x58, 0xC2)
148 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x59, 0x9F)
149 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5A, 0x25)
150 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5B, 0x4A)
151 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5C, 0x94)
152 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5D, 0x33)
153 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5E, 0x66)
154 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5F, 0xCC)
155 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x60, 0x83)
156 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x61, 0x1D)
157 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x62, 0x3A)
158 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x63, 0x74)
159 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x64, 0xE8)
160 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x65, 0xCB)
161 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x66, 0x8D)
162 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x67, 0x01)
163 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x68, 0x02)
164 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x69, 0x04)
165 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6A, 0x08)
166 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6B, 0x10)
167 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6C, 0x20)
168 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6D, 0x40)
169 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6E, 0x80)
170 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6F, 0x1B)
171 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x70, 0x36)
172 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x71, 0x6C)
173 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x72, 0xD8)
174 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x73, 0xAB)
175 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x74, 0x4D)
176 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x75, 0x9A)
177 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x76, 0x2F)
178 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x77, 0x5E)
179 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x78, 0xBC)
180 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x79, 0x63)
181 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7A, 0xC6)
182 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7B, 0x97)
183 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7C, 0x35)
184 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7D, 0x6A)
185 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7E, 0xD4)
186 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7F, 0xB3)
187 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x80, 0x7D)
188 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x81, 0xFA)
189 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x82, 0xEF)
190 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x83, 0xC5)
191 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x84, 0x91)
192 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x85, 0x39)
193 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x86, 0x72)
194 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x87, 0xE4)
195 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x88, 0xD3)
196 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x89, 0xBD)
197 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8A, 0x61)
198 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8B, 0xC2)
199 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8C, 0x9F)
200 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8D, 0x25)
201 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8E, 0x4A)
202 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8F, 0x94)
203 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x90, 0x33)
204 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x91, 0x66)
205 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x92, 0xCC)
206 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x93, 0x83)
207 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x94, 0x1D)
208 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x95, 0x3A)
209 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x96, 0x74)
210 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x97, 0xE8)
211 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x98, 0xCB)
212 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x99, 0x8D)
213 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9A, 0x01)
214 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9B, 0x02)
215 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9C, 0x04)
216 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9D, 0x08)
217 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9E, 0x10)
218 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9F, 0x20)
219 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA0, 0x40)
220 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA1, 0x80)
221 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA2, 0x1B)
222 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA3, 0x36)
223 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA4, 0x6C)
224 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA5, 0xD8)
225 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA6, 0xAB)
226 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA7, 0x4D)
227 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA8, 0x9A)
228 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA9, 0x2F)
229 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAA, 0x5E)
230 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAB, 0xBC)
231 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAC, 0x63)
232 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAD, 0xC6)
233 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAE, 0x97)
234 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAF, 0x35)
235 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB0, 0x6A)
236 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB1, 0xD4)
237 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB2, 0xB3)
238 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB3, 0x7D)
239 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB4, 0xFA)
240 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB5, 0xEF)
241 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB6, 0xC5)
242 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB7, 0x91)
243 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB8, 0x39)
244 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB9, 0x72)
245 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBA, 0xE4)
246 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBB, 0xD3)
247 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBC, 0xBD)
248 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBD, 0x61)
249 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBE, 0xC2)
250 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBF, 0x9F)
251 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC0, 0x25)
252 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC1, 0x4A)
253 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC2, 0x94)
254 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC3, 0x33)
255 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC4, 0x66)
256 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC5, 0xCC)
257 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC6, 0x83)
258 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC7, 0x1D)
259 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC8, 0x3A)
260 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC9, 0x74)
261 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCA, 0xE8)
262 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCB, 0xCB)
263 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCC, 0x8D)
264 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCD, 0x01)
265 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCE, 0x02)
266 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCF, 0x04)
267 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD0, 0x08)
268 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD1, 0x10)
269 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD2, 0x20)
270 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD3, 0x40)
271 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD4, 0x80)
272 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD5, 0x1B)
273 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD6, 0x36)
274 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD7, 0x6C)
275 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD8, 0xD8)
276 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD9, 0xAB)
277 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDA, 0x4D)
278 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDB, 0x9A)
279 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDC, 0x2F)
280 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDD, 0x5E)
281 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDE, 0xBC)
282 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDF, 0x63)
283 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE0, 0xC6)
284 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE1, 0x97)
285 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE2, 0x35)
286 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE3, 0x6A)
287 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE4, 0xD4)
288 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE5, 0xB3)
289 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE6, 0x7D)
290 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE7, 0xFA)
291 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE8, 0xEF)
292 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE9, 0xC5)
293 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEA, 0x91)
294 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEB, 0x39)
295 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEC, 0x72)
296 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xED, 0xE4)
297 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEE, 0xD3)
298 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEF, 0xBD)
299 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF0, 0x61)
300 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF1, 0xC2)
301 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF2, 0x9F)
302 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF3, 0x25)
303 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF4, 0x4A)
304 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF5, 0x94)
305 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF6, 0x33)
306 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF7, 0x66)
307 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF8, 0xCC)
308 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF9, 0x83)
309 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFA, 0x1D)
310 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFB, 0x3A)
311 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFC, 0x74)
312 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFD, 0xE8)
313 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFE, 0xCB)
314 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFF, 0x8D)
315 
316 class AESKeyInit
317 {
318  public:
319  template <std::size_t Offset, std::size_t N, typename T,
320  std::size_t KeySize, std::size_t Rp1>
321  static void eval(const std::array<T, KeySize> &key,
322  std::array<__m128i, Rp1> &ks, __m128i &xmm)
323  {
324  init<Offset, N>(key, ks, xmm, std::integral_constant < bool, N<Rp1>());
325  }
326 
327  private:
328  template <std::size_t, std::size_t, typename T, std::size_t KeySize,
329  std::size_t Rp1>
330  static void init(const std::array<T, KeySize> &,
331  std::array<__m128i, Rp1> &, __m128i &, std::false_type)
332  {
333  }
334 
335  template <std::size_t Offset, std::size_t N, typename T,
336  std::size_t KeySize, std::size_t Rp1>
337  static void init(const std::array<T, KeySize> &key,
338  std::array<__m128i, Rp1> &ks, __m128i &xmm, std::true_type)
339  {
340  M128I<> tmp;
341  tmp.load(key.data());
342  std::get<N>(ks) = xmm = tmp.value();
343  }
344 }; // class AESKeyInit
345 
346 template <typename T, std::size_t Rounds, typename KeySeqGenerator>
347 class AESKeySeq
348 {
349  public:
350  using key_type = typename KeySeqGenerator::key_type;
351 
352  void reset(const key_type &key)
353  {
354  KeySeqGenerator generator;
355  generator(key, key_seq_);
356  }
357 
358  template <typename U>
359  void operator()(
360  const key_type &, std::array<M128I<U>, Rounds + 1> &rk) const
361  {
362  rk = key_seq_;
363  }
364 
365  private:
366  std::array<M128I<>, Rounds + 1> key_seq_;
367 }; // class AESKeySeq
368 
369 template <typename T>
370 class AES128KeySeqGenerator
371 {
372  public:
373  using key_type = std::array<T, 16 / sizeof(T)>;
374 
375  template <std::size_t Rp1>
376  void operator()(const key_type &key, std::array<M128I<>, Rp1> &key_seq)
377  {
378  std::array<__m128i, Rp1> ks;
379  AESKeyInit::eval<0, 0>(key, ks, xmm1_);
380  generate_seq<1>(ks, std::integral_constant<bool, 1 < Rp1>());
381  std::memcpy(key_seq.data(), ks.data(), sizeof(__m128i) * Rp1);
382  }
383 
384  private:
385  __m128i xmm1_;
386  __m128i xmm2_;
387  __m128i xmm3_;
388 
389  template <std::size_t, std::size_t Rp1>
390  void generate_seq(std::array<__m128i, Rp1> &, std::false_type)
391  {
392  }
393 
394  template <std::size_t N, std::size_t Rp1>
395  void generate_seq(std::array<__m128i, Rp1> &ks, std::true_type)
396  {
397  xmm2_ = _mm_aeskeygenassist_si128(xmm1_, AESRoundConstant<N>::value);
398  expand_key();
399  std::get<N>(ks) = xmm1_;
400  generate_seq<N + 1>(ks, std::integral_constant<bool, N + 1 < Rp1>());
401  }
402 
403  void expand_key()
404  {
405  xmm2_ = _mm_shuffle_epi32(xmm2_, 0xFF); // pshufd xmm2, xmm2, 0xFF
406  xmm3_ = _mm_slli_si128(xmm1_, 0x04); // pshufb xmm3, xmm5
407  xmm1_ = _mm_xor_si128(xmm1_, xmm3_); // pxor xmm1, xmm3
408  xmm3_ = _mm_slli_si128(xmm3_, 0x04); // pslldq xmm3, 0x04
409  xmm1_ = _mm_xor_si128(xmm1_, xmm3_); // pxor xmm1, xmm3
410  xmm3_ = _mm_slli_si128(xmm3_, 0x04); // pslldq xmm3, 0x04
411  xmm1_ = _mm_xor_si128(xmm1_, xmm3_); // pxor xmm1, xmm3
412  xmm1_ = _mm_xor_si128(xmm1_, xmm2_); // pxor xmm1, xmm2
413  }
414 }; // class AES128KeySeq
415 
416 template <typename T>
417 class AES192KeySeqGenerator
418 {
419  public:
420  using key_type = std::array<T, 24 / sizeof(T)>;
421 
422  template <std::size_t Rp1>
423  void operator()(const key_type &key, std::array<M128I<>, Rp1> &key_seq)
424  {
425  std::array<__m128i, Rp1> ks;
426 
427  std::array<std::uint64_t, 3> key_tmp;
428  std::memcpy(key_tmp.data(), key.data(), 24);
429  AESKeyInit::eval<0, 0>(key_tmp, ks, xmm1_);
430  std::get<0>(key_tmp) = std::get<2>(key_tmp);
431  std::get<1>(key_tmp) = 0;
432  AESKeyInit::eval<0, 1>(key_tmp, ks, xmm7_);
433 
434  xmm3_ = _mm_setzero_si128();
435  xmm6_ = _mm_setzero_si128();
436  xmm4_ = _mm_shuffle_epi32(xmm7_, 0x4F); // pshufd xmm4, xmm7, 0x4F
437 
438  std::array<unsigned char, Rp1 * 16 + 16> ks_tmp;
439  generate_seq<1, Rp1>(
440  ks_tmp.data(), std::integral_constant<bool, 24 < Rp1 * 16>());
441  copy_key(
442  ks, ks_tmp.data(), std::integral_constant<bool, 24 < Rp1 * 16>());
443 
444  std::memcpy(key_seq.data(), ks.data(), sizeof(__m128i) * Rp1);
445  }
446 
447  private:
448  __m128i xmm1_;
449  __m128i xmm2_;
450  __m128i xmm3_;
451  __m128i xmm4_;
452  __m128i xmm5_;
453  __m128i xmm6_;
454  __m128i xmm7_;
455 
456  template <std::size_t, std::size_t>
457  void generate_seq(unsigned char *, std::false_type)
458  {
459  }
460 
461  template <std::size_t N, std::size_t Rp1>
462  void generate_seq(unsigned char *ks_ptr, std::true_type)
463  {
464  generate_key<N>(ks_ptr);
465  complete_key<N>(
466  ks_ptr, std::integral_constant<bool, N * 24 + 16 < Rp1 * 16>());
467  generate_seq<N + 1, Rp1>(
468  ks_ptr, std::integral_constant<bool, N * 24 + 24 < Rp1 * 16>());
469  }
470 
471  template <std::size_t N>
472  void generate_key(unsigned char *ks_ptr)
473  {
474  // In entry, N * 24 < Rp1 * 16
475  // Required Storage: N * 24 + 16;
476 
477  xmm2_ = _mm_aeskeygenassist_si128(xmm4_, AESRoundConstant<N>::value);
478  generate_key_expansion();
479  _mm_storeu_si128(reinterpret_cast<__m128i *>(ks_ptr + N * 24), xmm1_);
480  }
481 
482  template <std::size_t>
483  void complete_key(unsigned char *, std::false_type)
484  {
485  }
486 
487  template <std::size_t N>
488  void complete_key(unsigned char *ks_ptr, std::true_type)
489  {
490  // In entry, N * 24 + 16 < Rp1 * 16
491  // Required storage: N * 24 + 32
492 
493  complete_key_expansion();
494  _mm_storeu_si128(
495  reinterpret_cast<__m128i *>(ks_ptr + N * 24 + 16), xmm7_);
496  }
497 
498  void generate_key_expansion()
499  {
500  xmm2_ = _mm_shuffle_epi32(xmm2_, 0xFF); // pshufd xmm2, xmm2, 0xFF
501  xmm3_ = _mm_castps_si128(_mm_shuffle_ps( // shufps xmm3, xmm1, 0x10
502  _mm_castsi128_ps(xmm3_), _mm_castsi128_ps(xmm1_), 0x10));
503  xmm1_ = _mm_xor_si128(xmm1_, xmm3_); // pxor xmm1, xmm3
504  xmm3_ = _mm_castps_si128(_mm_shuffle_ps( // shufps xmm3, xmm1, 0x10
505  _mm_castsi128_ps(xmm3_), _mm_castsi128_ps(xmm1_), 0x8C));
506  xmm1_ = _mm_xor_si128(xmm1_, xmm3_); // pxor xmm1, xmm3
507  xmm1_ = _mm_xor_si128(xmm1_, xmm2_); // pxor xmm1, xmm2
508  }
509 
510  void complete_key_expansion()
511  {
512  xmm5_ = _mm_load_si128(&xmm4_); // movdqa xmm5, xmm4
513  xmm5_ = _mm_slli_si128(xmm5_, 0x04); // pslldq xmm5, 0x04
514  xmm6_ = _mm_castps_si128(_mm_shuffle_ps( // shufps xmm6, xmm1, 0x10
515  _mm_castsi128_ps(xmm6_), _mm_castsi128_ps(xmm1_), 0xF0));
516  xmm6_ = _mm_xor_si128(xmm6_, xmm5_); // pxor xmm6, xmm5
517  xmm4_ = _mm_xor_si128(xmm4_, xmm6_); // pxor xmm4, xmm6
518  xmm7_ = _mm_shuffle_epi32(xmm4_, 0x0E); // pshufd xmm7, xmm4, 0x0E
519  }
520 
521  template <std::size_t Rp1>
522  void copy_key(
523  std::array<__m128i, Rp1> &, const unsigned char *, std::false_type)
524  {
525  }
526 
527  template <std::size_t Rp1>
528  void copy_key(std::array<__m128i, Rp1> &ks, const unsigned char *ks_ptr,
529  std::true_type)
530  {
531  unsigned char *dst = reinterpret_cast<unsigned char *>(ks.data());
532  std::memcpy(dst + 24, ks_ptr + 24, Rp1 * 16 - 24);
533  }
534 }; // class AES192KeySeq
535 
536 template <typename T>
537 class AES256KeySeqGenerator
538 {
539  public:
540  using key_type = std::array<T, 32 / sizeof(T)>;
541 
542  template <std::size_t Rp1>
543  void operator()(const key_type &key, std::array<M128I<>, Rp1> &key_seq)
544  {
545  std::array<__m128i, Rp1> ks;
546  AESKeyInit::eval<0, 0>(key, ks, xmm1_);
547  AESKeyInit::eval<16 / sizeof(T), 1>(key, ks, xmm3_);
548  generate_seq<2>(ks, std::integral_constant<bool, 2 < Rp1>());
549  std::memcpy(key_seq.data(), ks.data(), sizeof(__m128i) * Rp1);
550  }
551 
552  private:
553  __m128i xmm1_;
554  __m128i xmm2_;
555  __m128i xmm3_;
556  __m128i xmm4_;
557 
558  template <std::size_t, std::size_t Rp1>
559  void generate_seq(std::array<__m128i, Rp1> &, std::false_type)
560  {
561  }
562 
563  template <std::size_t N, std::size_t Rp1>
564  void generate_seq(std::array<__m128i, Rp1> &ks, std::true_type)
565  {
566  generate_key<N>(ks, std::integral_constant<bool, N % 2 == 0>());
567  generate_seq<N + 1>(ks, std::integral_constant<bool, N + 1 < Rp1>());
568  }
569 
570  template <std::size_t N, std::size_t Rp1>
571  void generate_key(std::array<__m128i, Rp1> &ks, std::true_type)
572  {
573  xmm2_ =
574  _mm_aeskeygenassist_si128(xmm3_, AESRoundConstant<N / 2>::value);
575  expand_key(std::true_type());
576  std::get<N>(ks) = xmm1_;
577  }
578 
579  template <std::size_t N, std::size_t Rp1>
580  void generate_key(std::array<__m128i, Rp1> &ks, std::false_type)
581  {
582  xmm4_ = _mm_aeskeygenassist_si128(xmm1_, 0);
583  expand_key(std::false_type());
584  std::get<N>(ks) = xmm3_;
585  }
586 
587  void expand_key(std::true_type)
588  {
589  xmm2_ = _mm_shuffle_epi32(xmm2_, 0xFF); // pshufd xmm2, xmm2, 0xFF
590  xmm4_ = _mm_slli_si128(xmm1_, 0x04); // pshufb xmm4, xmm5
591  xmm1_ = _mm_xor_si128(xmm1_, xmm4_); // pxor xmm1, xmm4
592  xmm4_ = _mm_slli_si128(xmm4_, 0x04); // pslldq xmm4, 0x04
593  xmm1_ = _mm_xor_si128(xmm1_, xmm4_); // pxor xmm1, xmm4
594  xmm4_ = _mm_slli_si128(xmm4_, 0x04); // pslldq xmm4, 0x04
595  xmm1_ = _mm_xor_si128(xmm1_, xmm4_); // pxor xmm1, xmm4
596  xmm1_ = _mm_xor_si128(xmm1_, xmm2_); // pxor xmm1, xmm2
597  }
598 
599  void expand_key(std::false_type)
600  {
601  xmm2_ = _mm_shuffle_epi32(xmm4_, 0xAA); // pshufd xmm2, xmm4, 0xAA
602  xmm4_ = _mm_slli_si128(xmm3_, 0x04); // pshufb xmm4, xmm5
603  xmm3_ = _mm_xor_si128(xmm3_, xmm4_); // pxor xmm3, xmm4
604  xmm4_ = _mm_slli_si128(xmm4_, 0x04); // pslldq xmm4, 0x04
605  xmm3_ = _mm_xor_si128(xmm3_, xmm4_); // pxor xmm3, xmm4
606  xmm4_ = _mm_slli_si128(xmm4_, 0x04); // pslldq xmm4, 0x04
607  xmm3_ = _mm_xor_si128(xmm3_, xmm4_); // pxor xmm3, xmm4
608  xmm3_ = _mm_xor_si128(xmm3_, xmm2_); // pxor xmm1, xmm2
609  }
610 }; // class AESKey256
611 
612 } // namespace vsmc::internal
613 
616 template <typename ResultType, std::size_t Rounds>
617 using AES128KeySeq = internal::AESKeySeq<ResultType, Rounds,
618  internal::AES128KeySeqGenerator<ResultType>>;
619 
622 template <typename ResultType, std::size_t Rounds>
623 using AES192KeySeq = internal::AESKeySeq<ResultType, Rounds,
624  internal::AES192KeySeqGenerator<ResultType>>;
625 
628 template <typename ResultType, std::size_t Rounds>
629 using AES256KeySeq = internal::AESKeySeq<ResultType, Rounds,
630  internal::AES256KeySeqGenerator<ResultType>>;
631 
634 template <typename ResultType, std::size_t Blocks = VSMC_RNG_AES_BLOCKS>
635 using AES128Engine =
636  AESNIEngine<ResultType, AES128KeySeq<ResultType, 10>, 10, Blocks>;
637 
640 template <typename ResultType, std::size_t Blocks = VSMC_RNG_AES_BLOCKS>
641 using AES192Engine =
642  AESNIEngine<ResultType, AES192KeySeq<ResultType, 12>, 12, Blocks>;
643 
646 template <typename ResultType, std::size_t Blocks = VSMC_RNG_AES_BLOCKS>
647 using AES256Engine =
648  AESNIEngine<ResultType, AES256KeySeq<ResultType, 14>, 14, Blocks>;
649 
652 using AES128_1x32 = AES128Engine<std::uint32_t, 1>;
653 
656 using AES128_2x32 = AES128Engine<std::uint32_t, 2>;
657 
660 using AES128_4x32 = AES128Engine<std::uint32_t, 4>;
661 
664 using AES128_8x32 = AES128Engine<std::uint32_t, 8>;
665 
668 using AES128_1x64 = AES128Engine<std::uint64_t, 1>;
669 
672 using AES128_2x64 = AES128Engine<std::uint64_t, 2>;
673 
676 using AES128_4x64 = AES128Engine<std::uint64_t, 4>;
677 
680 using AES128_8x64 = AES128Engine<std::uint64_t, 8>;
681 
684 using AES128 = AES128Engine<std::uint32_t>;
685 
688 using AES128_64 = AES128Engine<std::uint64_t>;
689 
692 using AES192_1x32 = AES192Engine<std::uint32_t, 1>;
693 
696 using AES192_2x32 = AES192Engine<std::uint32_t, 2>;
697 
700 using AES192_4x32 = AES192Engine<std::uint32_t, 4>;
701 
704 using AES192_8x32 = AES192Engine<std::uint32_t, 8>;
705 
708 using AES192_1x64 = AES192Engine<std::uint64_t, 1>;
709 
712 using AES192_2x64 = AES192Engine<std::uint64_t, 2>;
713 
716 using AES192_4x64 = AES192Engine<std::uint64_t, 4>;
717 
720 using AES192_8x64 = AES192Engine<std::uint64_t, 8>;
721 
724 using AES192 = AES192Engine<std::uint32_t>;
725 
728 using AES192_64 = AES192Engine<std::uint64_t>;
729 
732 using AES256_1x32 = AES256Engine<std::uint32_t, 1>;
733 
736 using AES256_2x32 = AES256Engine<std::uint32_t, 2>;
737 
740 using AES256_4x32 = AES256Engine<std::uint32_t, 4>;
741 
744 using AES256_8x32 = AES256Engine<std::uint32_t, 8>;
745 
748 using AES256_1x64 = AES256Engine<std::uint64_t, 1>;
749 
752 using AES256_2x64 = AES256Engine<std::uint64_t, 2>;
753 
756 using AES256_4x64 = AES256Engine<std::uint64_t, 4>;
757 
760 using AES256_8x64 = AES256Engine<std::uint64_t, 8>;
761 
764 using AES256 = AES256Engine<std::uint32_t>;
765 
768 using AES256_64 = AES256Engine<std::uint64_t>;
769 
770 } // namespace vsmc
771 
772 #endif // VSMC_RNG_AES_HPP
vsmc::internal::AES192KeySeqGenerator::operator()
void operator()(const key_type &key, std::array< M128I<>, Rp1 > &key_seq)
Definition: aes.hpp:423
vsmc
Definition: monitor.hpp:49
vsmc::internal::AES192KeySeqGenerator::key_type
std::array< T, 24/sizeof(T)> key_type
Definition: aes.hpp:420
vsmc::internal::AES256KeySeqGenerator::key_type
std::array< T, 32/sizeof(T)> key_type
Definition: aes.hpp:540
vsmc::internal::AESKeySeq::reset
void reset(const key_type &key)
Definition: aes.hpp:352
vsmc::internal::AESKeySeq::key_type
typename KeySeqGenerator::key_type key_type
Definition: aes.hpp:350
vsmc::CounterEngine
Counter based RNG engine.
Definition: counter.hpp:290
VSMC_DEFINE_RNG_AES_ROUND_CONSTANT
#define VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(N, val)
Definition: aes.hpp:38
vsmc::internal::AESKeyInit::eval
static void eval(const std::array< T, KeySize > &key, std::array< __m128i, Rp1 > &ks, __m128i &xmm)
Definition: aes.hpp:321
vsmc::internal::AES256KeySeqGenerator::operator()
void operator()(const key_type &key, std::array< M128I<>, Rp1 > &key_seq)
Definition: aes.hpp:543
vsmc::internal::AES128KeySeqGenerator::key_type
std::array< T, 16/sizeof(T)> key_type
Definition: aes.hpp:373
vsmc::internal::AES128KeySeqGenerator::operator()
void operator()(const key_type &key, std::array< M128I<>, Rp1 > &key_seq)
Definition: aes.hpp:376
aes_ni.hpp
vsmc::internal::AESKeySeq::operator()
void operator()(const key_type &, std::array< M128I< U >, Rounds+1 > &rk) const
Definition: aes.hpp:359
Generated by   doxygen 1.8.11