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,2014, 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 <> struct AESRoundConstantValue< N > : \
40  public cxx11::integral_constant<int, val > {};
41 
44 #ifndef VSMC_RNG_AES_BLOCKS
45 #define VSMC_RNG_AES_BLOCKS 1
46 #endif
47 
48 namespace vsmc {
49 
50 namespace internal {
51 
52 template <std::size_t N> struct AESRoundConstantValue;
53 
54 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x00, 0x8D)
55 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x01, 0x01)
56 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x02, 0x02)
57 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x03, 0x04)
58 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x04, 0x08)
59 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x05, 0x10)
60 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x06, 0x20)
61 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x07, 0x40)
62 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x08, 0x80)
63 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x09, 0x1B)
64 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0A, 0x36)
65 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0B, 0x6C)
66 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0C, 0xD8)
67 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0D, 0xAB)
68 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0E, 0x4D)
69 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x0F, 0x9A)
70 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x10, 0x2F)
71 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x11, 0x5E)
72 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x12, 0xBC)
73 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x13, 0x63)
74 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x14, 0xC6)
75 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x15, 0x97)
76 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x16, 0x35)
77 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x17, 0x6A)
78 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x18, 0xD4)
79 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x19, 0xB3)
80 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1A, 0x7D)
81 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1B, 0xFA)
82 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1C, 0xEF)
83 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1D, 0xC5)
84 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1E, 0x91)
85 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x1F, 0x39)
86 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x20, 0x72)
87 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x21, 0xE4)
88 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x22, 0xD3)
89 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x23, 0xBD)
90 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x24, 0x61)
91 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x25, 0xC2)
92 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x26, 0x9F)
93 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x27, 0x25)
94 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x28, 0x4A)
95 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x29, 0x94)
96 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2A, 0x33)
97 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2B, 0x66)
98 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2C, 0xCC)
99 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2D, 0x83)
100 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2E, 0x1D)
101 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x2F, 0x3A)
102 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x30, 0x74)
103 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x31, 0xE8)
104 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x32, 0xCB)
105 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x33, 0x8D)
106 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x34, 0x01)
107 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x35, 0x02)
108 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x36, 0x04)
109 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x37, 0x08)
110 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x38, 0x10)
111 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x39, 0x20)
112 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3A, 0x40)
113 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3B, 0x80)
114 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3C, 0x1B)
115 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3D, 0x36)
116 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3E, 0x6C)
117 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x3F, 0xD8)
118 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x40, 0xAB)
119 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x41, 0x4D)
120 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x42, 0x9A)
121 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x43, 0x2F)
122 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x44, 0x5E)
123 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x45, 0xBC)
124 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x46, 0x63)
125 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x47, 0xC6)
126 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x48, 0x97)
127 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x49, 0x35)
128 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4A, 0x6A)
129 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4B, 0xD4)
130 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4C, 0xB3)
131 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4D, 0x7D)
132 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4E, 0xFA)
133 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x4F, 0xEF)
134 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x50, 0xC5)
135 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x51, 0x91)
136 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x52, 0x39)
137 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x53, 0x72)
138 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x54, 0xE4)
139 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x55, 0xD3)
140 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x56, 0xBD)
141 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x57, 0x61)
142 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x58, 0xC2)
143 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x59, 0x9F)
144 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5A, 0x25)
145 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5B, 0x4A)
146 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5C, 0x94)
147 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5D, 0x33)
148 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5E, 0x66)
149 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x5F, 0xCC)
150 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x60, 0x83)
151 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x61, 0x1D)
152 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x62, 0x3A)
153 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x63, 0x74)
154 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x64, 0xE8)
155 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x65, 0xCB)
156 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x66, 0x8D)
157 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x67, 0x01)
158 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x68, 0x02)
159 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x69, 0x04)
160 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6A, 0x08)
161 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6B, 0x10)
162 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6C, 0x20)
163 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6D, 0x40)
164 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6E, 0x80)
165 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x6F, 0x1B)
166 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x70, 0x36)
167 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x71, 0x6C)
168 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x72, 0xD8)
169 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x73, 0xAB)
170 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x74, 0x4D)
171 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x75, 0x9A)
172 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x76, 0x2F)
173 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x77, 0x5E)
174 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x78, 0xBC)
175 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x79, 0x63)
176 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7A, 0xC6)
177 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7B, 0x97)
178 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7C, 0x35)
179 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7D, 0x6A)
180 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7E, 0xD4)
181 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x7F, 0xB3)
182 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x80, 0x7D)
183 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x81, 0xFA)
184 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x82, 0xEF)
185 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x83, 0xC5)
186 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x84, 0x91)
187 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x85, 0x39)
188 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x86, 0x72)
189 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x87, 0xE4)
190 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x88, 0xD3)
191 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x89, 0xBD)
192 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8A, 0x61)
193 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8B, 0xC2)
194 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8C, 0x9F)
195 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8D, 0x25)
196 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8E, 0x4A)
197 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x8F, 0x94)
198 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x90, 0x33)
199 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x91, 0x66)
200 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x92, 0xCC)
201 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x93, 0x83)
202 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x94, 0x1D)
203 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x95, 0x3A)
204 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x96, 0x74)
205 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x97, 0xE8)
206 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x98, 0xCB)
207 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x99, 0x8D)
208 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9A, 0x01)
209 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9B, 0x02)
210 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9C, 0x04)
211 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9D, 0x08)
212 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9E, 0x10)
213 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0x9F, 0x20)
214 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA0, 0x40)
215 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA1, 0x80)
216 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA2, 0x1B)
217 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA3, 0x36)
218 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA4, 0x6C)
219 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA5, 0xD8)
220 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA6, 0xAB)
221 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA7, 0x4D)
222 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA8, 0x9A)
223 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xA9, 0x2F)
224 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAA, 0x5E)
225 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAB, 0xBC)
226 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAC, 0x63)
227 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAD, 0xC6)
228 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAE, 0x97)
229 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xAF, 0x35)
230 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB0, 0x6A)
231 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB1, 0xD4)
232 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB2, 0xB3)
233 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB3, 0x7D)
234 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB4, 0xFA)
235 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB5, 0xEF)
236 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB6, 0xC5)
237 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB7, 0x91)
238 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB8, 0x39)
239 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xB9, 0x72)
240 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBA, 0xE4)
241 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBB, 0xD3)
242 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBC, 0xBD)
243 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBD, 0x61)
244 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBE, 0xC2)
245 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xBF, 0x9F)
246 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC0, 0x25)
247 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC1, 0x4A)
248 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC2, 0x94)
249 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC3, 0x33)
250 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC4, 0x66)
251 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC5, 0xCC)
252 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC6, 0x83)
253 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC7, 0x1D)
254 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC8, 0x3A)
255 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xC9, 0x74)
256 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCA, 0xE8)
257 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCB, 0xCB)
258 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCC, 0x8D)
259 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCD, 0x01)
260 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCE, 0x02)
261 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xCF, 0x04)
262 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD0, 0x08)
263 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD1, 0x10)
264 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD2, 0x20)
265 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD3, 0x40)
266 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD4, 0x80)
267 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD5, 0x1B)
268 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD6, 0x36)
269 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD7, 0x6C)
270 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD8, 0xD8)
271 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xD9, 0xAB)
272 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDA, 0x4D)
273 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDB, 0x9A)
274 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDC, 0x2F)
275 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDD, 0x5E)
276 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDE, 0xBC)
277 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xDF, 0x63)
278 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE0, 0xC6)
279 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE1, 0x97)
280 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE2, 0x35)
281 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE3, 0x6A)
282 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE4, 0xD4)
283 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE5, 0xB3)
284 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE6, 0x7D)
285 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE7, 0xFA)
286 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE8, 0xEF)
287 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xE9, 0xC5)
288 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEA, 0x91)
289 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEB, 0x39)
290 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEC, 0x72)
291 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xED, 0xE4)
292 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEE, 0xD3)
293 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xEF, 0xBD)
294 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF0, 0x61)
295 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF1, 0xC2)
296 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF2, 0x9F)
297 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF3, 0x25)
298 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF4, 0x4A)
299 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF5, 0x94)
300 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF6, 0x33)
301 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF7, 0x66)
302 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF8, 0xCC)
303 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xF9, 0x83)
304 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFA, 0x1D)
305 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFB, 0x3A)
306 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFC, 0x74)
307 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFD, 0xE8)
308 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFE, 0xCB)
309 VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(0xFF, 0x8D)
310 
311 struct AESKeyInit
312 {
313  template <std::size_t Offset, std::size_t N,
314  typename T, std::size_t KeySize, std::size_t Rp1>
315  static void key_init (const Array<T, KeySize> &key,
316  Array<__m128i, Rp1> &key_seq, __m128i &xmm)
317  {
318  key_init_xmm<Offset, N>(key, key_seq, xmm,
319  cxx11::integral_constant<bool, N < Rp1>());
320  }
321 
322  private :
323 
324  template <std::size_t, std::size_t,
325  typename T, std::size_t KeySize, std::size_t Rp1>
326  static void key_init_xmm (const Array<T, KeySize> &,
327  Array<__m128i, Rp1> &, __m128i &, cxx11::false_type) {}
328 
329  template <std::size_t Offset, std::size_t N,
330  typename T, std::size_t KeySize,
331  std::size_t Rp1>
332  static void key_init_xmm (const Array<T, KeySize> &key,
333  Array<__m128i, Rp1> &key_seq, __m128i &xmm, cxx11::true_type)
334  {
335  m128i_pack<Offset>(key, xmm);
336  key_seq[Position<N>()] = xmm;
337  }
338 }; // struct AESKeyInit
339 
340 } // namespace vsmc::internal
341 
344 template <typename ResultType>
345 class AES128KeySeq
346 {
347  public :
348 
349  typedef Array<ResultType, 16 / sizeof(ResultType)> key_type;
350 
351  template <std::size_t Rp1>
352  void generate (const key_type &key, Array<__m128i, Rp1> &key_seq)
353  {
354  internal::AESKeyInit::key_init<0, 0>(key, key_seq, xmm1_);
355  generate_seq<1>(key_seq, cxx11::integral_constant<bool, 1 < Rp1>());
356  }
357 
358  private :
359 
360  __m128i xmm1_;
361  __m128i xmm2_;
362  __m128i xmm3_;
363 
364  template <std::size_t, std::size_t Rp1>
365  void generate_seq (Array<__m128i, Rp1> &, cxx11::false_type) {}
366 
367  template <std::size_t N, std::size_t Rp1>
368  void generate_seq (Array<__m128i, Rp1> &key_seq, cxx11::true_type)
369  {
370  xmm2_ = _mm_aeskeygenassist_si128(xmm1_,
371  internal::AESRoundConstantValue<N>::value);
372  expand_key();
373  key_seq[Position<N>()] = xmm1_;
374  generate_seq<N + 1>(key_seq,
375  cxx11::integral_constant<bool, N + 1 < Rp1>());
376  }
377 
378  void expand_key ()
379  {
380  xmm2_ = _mm_shuffle_epi32(xmm2_, 0xFF); // pshufd xmm2, xmm2, 0xFF
381  xmm3_ = _mm_slli_si128 (xmm1_, 0x04); // pshufb xmm3, xmm5
382  xmm1_ = _mm_xor_si128 (xmm1_, xmm3_); // pxor xmm1, xmm3
383  xmm3_ = _mm_slli_si128 (xmm3_, 0x04); // pslldq xmm3, 0x04
384  xmm1_ = _mm_xor_si128 (xmm1_, xmm3_); // pxor xmm1, xmm3
385  xmm3_ = _mm_slli_si128 (xmm3_, 0x04); // pslldq xmm3, 0x04
386  xmm1_ = _mm_xor_si128 (xmm1_, xmm3_); // pxor xmm1, xmm3
387  xmm1_ = _mm_xor_si128 (xmm1_, xmm2_); // pxor xmm1, xmm2
388  }
389 }; // class AES128KeySeq
390 
404 template <typename ResultType, std::size_t Blocks = VSMC_RNG_AES_BLOCKS>
405 class AES128Engine :
406  public AESNIEngine<ResultType, AES128KeySeq<ResultType>, true, 10, Blocks>
407 {
408 
409  public :
410 
411  typedef AESNIEngine<ResultType, AES128KeySeq<ResultType>, true, 10, Blocks>
412  base_eng_type;
413 
414  explicit AES128Engine (ResultType s = 0) : base_eng_type(s) {}
415 
416  template <typename SeedSeq>
417  explicit AES128Engine (SeedSeq &seq, typename cxx11::enable_if<
418  internal::is_seed_seq<SeedSeq,
419  typename base_eng_type::result_type,
420  typename base_eng_type::key_type,
421  AES128Engine<ResultType, Blocks>
422  >::value>::type * = VSMC_NULLPTR) : base_eng_type(seq) {}
423 
424  AES128Engine (const typename base_eng_type::key_type &k) :
425  base_eng_type(k) {}
426 }; // class AES128Engine
427 
430 typedef AES128Engine<uint32_t> AES128_32;
431 
434 typedef AES128Engine<uint32_t, 1> AES128_1x32;
435 
438 typedef AES128Engine<uint32_t, 2> AES128_2x32;
439 
442 typedef AES128Engine<uint32_t, 4> AES128_4x32;
443 
446 typedef AES128Engine<uint32_t, 8> AES128_8x32;
447 
450 typedef AES128Engine<uint64_t> AES128_64;
451 
454 typedef AES128Engine<uint64_t, 1> AES128_1x64;
455 
458 typedef AES128Engine<uint64_t, 2> AES128_2x64;
459 
462 typedef AES128Engine<uint64_t, 4> AES128_4x64;
463 
466 typedef AES128Engine<uint64_t, 8> AES128_8x64;
467 
470 template <typename ResultType>
471 class AES192KeySeq
472 {
473  public :
474 
475  typedef Array<ResultType, 24 / sizeof(ResultType)> key_type;
476 
477  template <std::size_t Rp1>
478  void generate (const key_type &key, Array<__m128i, Rp1> &key_seq)
479  {
480  Array<uint64_t, 3> key_tmp;
481  std::memcpy(key_tmp.data(), key.data(), 24);
482  internal::AESKeyInit::key_init<0, 0>(key_tmp, key_seq, xmm1_);
483  key_tmp.at<0>() = key_tmp.at<2>();
484  key_tmp.at<1>() = 0;
485  internal::AESKeyInit::key_init<0, 1>(key_tmp, key_seq, xmm7_);
486 
487  xmm3_ = _mm_setzero_si128();
488  xmm6_ = _mm_setzero_si128();
489  xmm4_ = _mm_shuffle_epi32(xmm7_, 0x4F); // pshufd xmm4, xmm7, 0x4F
490 
491  Array<unsigned char, Rp1 * 16 + 16> ks_tmp;
492  generate_seq<1, Rp1>(ks_tmp.data(),
493  cxx11::integral_constant<bool, 24 < Rp1 * 16>());
494  copy_key(key_seq, ks_tmp.data(),
495  cxx11::integral_constant<bool, 24 < Rp1 * 16>());
496  }
497 
498  private :
499 
500  __m128i xmm1_;
501  __m128i xmm2_;
502  __m128i xmm3_;
503  __m128i xmm4_;
504  __m128i xmm5_;
505  __m128i xmm6_;
506  __m128i xmm7_;
507 
508  template <std::size_t, std::size_t>
509  void generate_seq (unsigned char *, cxx11::false_type) {}
510 
511  template <std::size_t N, std::size_t Rp1>
512  void generate_seq (unsigned char *ks_ptr, cxx11::true_type)
513  {
514  generate_key<N>(ks_ptr);
515  complete_key<N>(ks_ptr,
516  cxx11::integral_constant<bool, N * 24 + 16 < Rp1 * 16>());
517  generate_seq<N + 1, Rp1>(ks_ptr,
518  cxx11::integral_constant<bool, N * 24 + 24 < Rp1 * 16>());
519  }
520 
521  template <std::size_t N>
522  void generate_key (unsigned char *ks_ptr)
523  {
524  // In entry, N * 24 < Rp1 * 16
525  // Required Storage: N * 24 + 16;
526 
527  xmm2_ = _mm_aeskeygenassist_si128(xmm4_,
528  internal::AESRoundConstantValue<N>::value);
529  generate_key_expansion();
530  _mm_storeu_si128(reinterpret_cast<__m128i *>(
531  ks_ptr + N * 24), xmm1_);
532  }
533 
534  template <std::size_t>
535  void complete_key (unsigned char *, cxx11::false_type) {}
536 
537  template <std::size_t N>
538  void complete_key (unsigned char *ks_ptr, cxx11::true_type)
539  {
540  // In entry, N * 24 + 16 < Rp1 * 16
541  // Required storage: N * 24 + 32
542 
543  complete_key_expansion();
544  _mm_storeu_si128(reinterpret_cast<__m128i *>(
545  ks_ptr + N * 24 + 16), xmm7_);
546  }
547 
548  void generate_key_expansion ()
549  {
550  xmm2_ = _mm_shuffle_epi32(xmm2_, 0xFF); // pshufd xmm2, xmm2, 0xFF
551  xmm3_ = _mm_castps_si128 (_mm_shuffle_ps( // shufps xmm3, xmm1, 0x10
552  _mm_castsi128_ps(xmm3_),
553  _mm_castsi128_ps(xmm1_), 0x10));
554  xmm1_ = _mm_xor_si128 (xmm1_, xmm3_); // pxor xmm1, xmm3
555  xmm3_ = _mm_castps_si128(_mm_shuffle_ps( // shufps xmm3, xmm1, 0x10
556  _mm_castsi128_ps(xmm3_),
557  _mm_castsi128_ps(xmm1_), 0x8C));
558  xmm1_ = _mm_xor_si128 (xmm1_, xmm3_); // pxor xmm1, xmm3
559  xmm1_ = _mm_xor_si128 (xmm1_, xmm2_); // pxor xmm1, xmm2
560  }
561 
562  void complete_key_expansion ()
563  {
564  xmm5_ = _mm_load_si128 (&xmm4_); // movdqa xmm5, xmm4
565  xmm5_ = _mm_slli_si128 (xmm5_, 0x04); // pslldq xmm5, 0x04
566  xmm6_ = _mm_castps_si128 (_mm_shuffle_ps( // shufps xmm6, xmm1, 0x10
567  _mm_castsi128_ps(xmm6_),
568  _mm_castsi128_ps(xmm1_), 0xF0));
569  xmm6_ = _mm_xor_si128 (xmm6_, xmm5_); // pxor xmm6, xmm5
570  xmm4_ = _mm_xor_si128 (xmm4_, xmm6_); // pxor xmm4, xmm6
571  xmm7_ = _mm_shuffle_epi32(xmm4_, 0x0E); // pshufd xmm7, xmm4, 0x0E
572  }
573 
574  template <std::size_t Rp1>
575  void copy_key (Array<__m128i, Rp1> &,
576  const unsigned char *, cxx11::false_type) {}
577 
578  template <std::size_t Rp1>
579  void copy_key (Array<__m128i, Rp1> &key_seq,
580  const unsigned char *ks_ptr, cxx11::true_type)
581  {
582  unsigned char *dst = reinterpret_cast<unsigned char *>(key_seq.data());
583  std::memcpy(dst + 24, ks_ptr + 24, Rp1 * 16 - 24);
584  }
585 }; // class AES192KeySeq
586 
592 template <typename ResultType, std::size_t Blocks = VSMC_RNG_AES_BLOCKS>
593 class AES192Engine :
594  public AESNIEngine<ResultType, AES192KeySeq<ResultType>, true, 12, Blocks>
595 {
596 
597  public :
598 
599  typedef AESNIEngine<ResultType, AES192KeySeq<ResultType>, true, 12, Blocks>
600  base_eng_type;
601 
602  explicit AES192Engine (ResultType s = 0) : base_eng_type(s) {}
603 
604  template <typename SeedSeq>
605  explicit AES192Engine (SeedSeq &seq, typename cxx11::enable_if<
606  internal::is_seed_seq<SeedSeq,
607  typename base_eng_type::result_type,
608  typename base_eng_type::key_type,
609  AES192Engine<ResultType, Blocks>
610  >::value>::type * = VSMC_NULLPTR) : base_eng_type(seq) {}
611 
612  AES192Engine (const typename base_eng_type::key_type &k) :
613  base_eng_type(k) {}
614 }; // class AES192Engine
615 
618 typedef AES192Engine<uint32_t> AES192_32;
619 
622 typedef AES192Engine<uint32_t, 1> AES192_1x32;
623 
626 typedef AES192Engine<uint32_t, 2> AES192_2x32;
627 
630 typedef AES192Engine<uint32_t, 4> AES192_4x32;
631 
634 typedef AES192Engine<uint32_t, 8> AES192_8x32;
635 
638 typedef AES192Engine<uint64_t> AES192_64;
639 
642 typedef AES192Engine<uint64_t, 1> AES192_1x64;
643 
646 typedef AES192Engine<uint64_t, 2> AES192_2x64;
647 
650 typedef AES192Engine<uint64_t, 4> AES192_4x64;
651 
654 typedef AES192Engine<uint64_t, 8> AES192_8x64;
655 
658 template <typename ResultType>
659 class AES256KeySeq
660 {
661  public :
662 
663  typedef Array<ResultType, 32 / sizeof(ResultType)> key_type;
664 
665  template <std::size_t Rp1>
666  void generate (const key_type &key, Array<__m128i, Rp1> &key_seq)
667  {
668  internal::AESKeyInit::key_init<0, 0>(key, key_seq, xmm1_);
669  internal::AESKeyInit::key_init<16 / sizeof(ResultType), 1>(
670  key, key_seq, xmm3_);
671  generate_seq<2>(key_seq, cxx11::integral_constant<bool, 2 < Rp1>());
672  }
673 
674  private :
675 
676  __m128i xmm1_;
677  __m128i xmm2_;
678  __m128i xmm3_;
679  __m128i xmm4_;
680 
681  template <std::size_t, std::size_t Rp1>
682  void generate_seq (Array<__m128i, Rp1> &, cxx11::false_type) {}
683 
684  template <std::size_t N, std::size_t Rp1>
685  void generate_seq (Array<__m128i, Rp1> &key_seq, cxx11::true_type)
686  {
687  generate_key<N>(key_seq, cxx11::integral_constant<bool, N % 2 == 0>());
688  generate_seq<N + 1>(key_seq,
689  cxx11::integral_constant<bool, N + 1 < Rp1>());
690  }
691 
692  template <std::size_t N, std::size_t Rp1>
693  void generate_key (Array<__m128i, Rp1> &key_seq, cxx11::true_type)
694  {
695  xmm2_ = _mm_aeskeygenassist_si128(xmm3_,
696  internal::AESRoundConstantValue<N / 2>::value);
697  expand_key(cxx11::true_type());
698  key_seq[Position<N>()] = xmm1_;
699  }
700 
701  template <std::size_t N, std::size_t Rp1>
702  void generate_key (Array<__m128i, Rp1> &key_seq, cxx11::false_type)
703  {
704  xmm4_ = _mm_aeskeygenassist_si128(xmm1_, 0);
705  expand_key(cxx11::false_type());
706  key_seq[Position<N>()] = xmm3_;
707  }
708 
709  void expand_key (cxx11::true_type)
710  {
711  xmm2_ = _mm_shuffle_epi32(xmm2_, 0xFF); // pshufd xmm2, xmm2, 0xFF
712  xmm4_ = _mm_slli_si128 (xmm1_, 0x04); // pshufb xmm4, xmm5
713  xmm1_ = _mm_xor_si128 (xmm1_, xmm4_); // pxor xmm1, xmm4
714  xmm4_ = _mm_slli_si128 (xmm4_, 0x04); // pslldq xmm4, 0x04
715  xmm1_ = _mm_xor_si128 (xmm1_, xmm4_); // pxor xmm1, xmm4
716  xmm4_ = _mm_slli_si128 (xmm4_, 0x04); // pslldq xmm4, 0x04
717  xmm1_ = _mm_xor_si128 (xmm1_, xmm4_); // pxor xmm1, xmm4
718  xmm1_ = _mm_xor_si128 (xmm1_, xmm2_); // pxor xmm1, xmm2
719  }
720 
721  void expand_key (cxx11::false_type)
722  {
723  xmm2_ = _mm_shuffle_epi32(xmm4_, 0xAA); // pshufd xmm2, xmm4, 0xAA
724  xmm4_ = _mm_slli_si128 (xmm3_, 0x04); // pshufb xmm4, xmm5
725  xmm3_ = _mm_xor_si128 (xmm3_, xmm4_); // pxor xmm3, xmm4
726  xmm4_ = _mm_slli_si128 (xmm4_, 0x04); // pslldq xmm4, 0x04
727  xmm3_ = _mm_xor_si128 (xmm3_, xmm4_); // pxor xmm3, xmm4
728  xmm4_ = _mm_slli_si128 (xmm4_, 0x04); // pslldq xmm4, 0x04
729  xmm3_ = _mm_xor_si128 (xmm3_, xmm4_); // pxor xmm3, xmm4
730  xmm3_ = _mm_xor_si128 (xmm3_, xmm2_); // pxor xmm1, xmm2
731  }
732 }; // class AESKey256
733 
739 template <typename ResultType, std::size_t Blocks = VSMC_RNG_AES_BLOCKS>
740 class AES256Engine :
741  public AESNIEngine<ResultType, AES256KeySeq<ResultType>, true, 14, Blocks>
742 {
743 
744  public :
745 
746  typedef AESNIEngine<ResultType, AES256KeySeq<ResultType>, true, 14, Blocks>
747  base_eng_type;
748 
749  explicit AES256Engine (ResultType s = 0) : base_eng_type(s) {}
750 
751  template <typename SeedSeq>
752  explicit AES256Engine (SeedSeq &seq, typename cxx11::enable_if<
753  internal::is_seed_seq<SeedSeq,
754  typename base_eng_type::result_type,
755  typename base_eng_type::key_type,
756  AES256Engine<ResultType, Blocks>
757  >::value>::type * = VSMC_NULLPTR) : base_eng_type(seq) {}
758 
759  AES256Engine (const typename base_eng_type::key_type &k) :
760  base_eng_type(k) {}
761 }; // class AES256Engine
762 
765 typedef AES256Engine<uint32_t> AES256_32;
766 
769 typedef AES256Engine<uint32_t, 1> AES256_1x32;
770 
773 typedef AES256Engine<uint32_t, 2> AES256_2x32;
774 
777 typedef AES256Engine<uint32_t, 4> AES256_4x32;
778 
781 typedef AES256Engine<uint32_t, 8> AES256_8x32;
782 
785 typedef AES256Engine<uint64_t> AES256_64;
786 
789 typedef AES256Engine<uint64_t, 1> AES256_1x64;
790 
793 typedef AES256Engine<uint64_t, 2> AES256_2x64;
794 
797 typedef AES256Engine<uint64_t, 4> AES256_4x64;
798 
801 typedef AES256Engine<uint64_t, 8> AES256_8x64;
802 
803 } // namespace vsmc
804 
805 #endif // VSMC_RNG_AES_HPP
vsmc::AES192Engine::AES192Engine
AES192Engine(ResultType s=0)
Definition: aes.hpp:602
vsmc
Definition: adapter.hpp:37
vsmc::AES128_2x32
AES128Engine< uint32_t, 2 > AES128_2x32
AES-128 RNG engine with 32-bits integers output and 2 blocks.
Definition: aes.hpp:438
vsmc::AES192_8x32
AES192Engine< uint32_t, 8 > AES192_8x32
AES-192 RNG engine with 32-bits integers output and 8 blocks.
Definition: aes.hpp:634
vsmc::AES192KeySeq::generate
void generate(const key_type &key, Array< __m128i, Rp1 > &key_seq)
Definition: aes.hpp:478
vsmc::AES256_8x64
AES256Engine< uint64_t, 8 > AES256_8x64
AES-256 RNG engine with 64-bits integers output and 8 blocks.
Definition: aes.hpp:801
vsmc::AES128_2x64
AES128Engine< uint64_t, 2 > AES128_2x64
AES-128 RNG engine with 64-bits integers output and 2 blocks.
Definition: aes.hpp:458
vsmc::internal::is_seed_seq
Definition: common.hpp:111
vsmc::AES192_8x64
AES192Engine< uint64_t, 8 > AES192_8x64
AES-192 RNG engine with 64-bits integers output and 8 blocks.
Definition: aes.hpp:654
vsmc::AES256_1x32
AES256Engine< uint32_t, 1 > AES256_1x32
AES-256 RNG engine with 32-bits integers output and 1 block.
Definition: aes.hpp:769
vsmc::AES192_1x64
AES192Engine< uint64_t, 1 > AES192_1x64
AES-192 RNG engine with 64-bits integers output and 1 block.
Definition: aes.hpp:642
vsmc::AES128Engine::AES128Engine
AES128Engine(const typename base_eng_type::key_type &k)
Definition: aes.hpp:424
vsmc::AES128_64
AES128Engine< uint64_t > AES128_64
AES-128 RNG engine with 64-bits integers output and default blocks.
Definition: aes.hpp:450
vsmc::AES192_32
AES192Engine< uint32_t > AES192_32
AES-192 RNG engine with 32-bits integers output and default blocks.
Definition: aes.hpp:618
vsmc::AES128_1x32
AES128Engine< uint32_t, 1 > AES128_1x32
AES-128 RNG engine with 32-bits integers output and 1 block.
Definition: aes.hpp:434
vsmc::AES256Engine::base_eng_type
AESNIEngine< ResultType, AES256KeySeq< ResultType >, true, 14, Blocks > base_eng_type
Definition: aes.hpp:747
vsmc::AES128_1x64
AES128Engine< uint64_t, 1 > AES128_1x64
AES-128 RNG engine with 64-bits integers output and 1 block.
Definition: aes.hpp:454
vsmc::AES128Engine::AES128Engine
AES128Engine(SeedSeq &seq, typename cxx11::enable_if< internal::is_seed_seq< SeedSeq, typename base_eng_type::result_type, typename base_eng_type::key_type, AES128Engine< ResultType, Blocks > >::value >::type *=nullptr)
Definition: aes.hpp:417
vsmc::cxx11::integral_constant
Definition: type_traits.hpp:108
vsmc::cxx11::false_type
integral_constant< bool, false > false_type
Definition: type_traits.hpp:246
vsmc::Position
Function template argument used for position.
Definition: defines.hpp:126
vsmc::AES256_64
AES256Engine< uint64_t > AES256_64
AES-256 RNG engine with 64-bits integers output and default blocks.
Definition: aes.hpp:785
vsmc::AES256Engine::AES256Engine
AES256Engine(const typename base_eng_type::key_type &k)
Definition: aes.hpp:759
vsmc::AES256_8x32
AES256Engine< uint32_t, 8 > AES256_8x32
AES-256 RNG engine with 32-bits integers output and 8 blocks.
Definition: aes.hpp:781
vsmc::AES256_32
AES256Engine< uint32_t > AES256_32
AES-256 RNG engine with 32-bits integers output and default blocks.
Definition: aes.hpp:765
vsmc::AES192Engine
AES-192 RNG engine.
Definition: aes.hpp:593
vsmc::cxx11::enable_if
Definition: type_traits.hpp:215
vsmc::AES128_8x32
AES128Engine< uint32_t, 8 > AES128_8x32
AES-128 RNG engine with 32-bits integers output and 8 blocks.
Definition: aes.hpp:446
vsmc::AES256_1x64
AES256Engine< uint64_t, 1 > AES256_1x64
AES-256 RNG engine with 64-bits integers output and 1 block.
Definition: aes.hpp:789
vsmc::AES128_4x32
AES128Engine< uint32_t, 4 > AES128_4x32
AES-128 RNG engine with 32-bits integers output and 4 blocks.
Definition: aes.hpp:442
vsmc::AES128Engine::base_eng_type
AESNIEngine< ResultType, AES128KeySeq< ResultType >, true, 10, Blocks > base_eng_type
Definition: aes.hpp:412
vsmc::AES192_1x32
AES192Engine< uint32_t, 1 > AES192_1x32
AES-192 RNG engine with 32-bits integers output and 1 block.
Definition: aes.hpp:622
vsmc::AES256KeySeq::generate
void generate(const key_type &key, Array< __m128i, Rp1 > &key_seq)
Definition: aes.hpp:666
vsmc::AESNIEngine
RNG engine using AES-NI instructions.
Definition: aes_ni.hpp:213
VSMC_NULLPTR
#define VSMC_NULLPTR
nullptr
Definition: defines.hpp:79
vsmc::AES128_32
AES128Engine< uint32_t > AES128_32
AES-128 RNG engine with 32-bits integers output and default blocks.
Definition: aes.hpp:430
vsmc::cxx11::true_type
integral_constant< bool, true > true_type
Definition: type_traits.hpp:245
vsmc::AES256_2x32
AES256Engine< uint32_t, 2 > AES256_2x32
AES-256 RNG engine with 32-bits integers output and 2 blocks.
Definition: aes.hpp:773
vsmc::AES128Engine::AES128Engine
AES128Engine(ResultType s=0)
Definition: aes.hpp:414
__m128i
vsmc::AES256Engine::AES256Engine
AES256Engine(ResultType s=0)
Definition: aes.hpp:749
vsmc::memcpy
void * memcpy(void *dst, const void *src, std::size_t n)
SIMD optimized memcpy with non-temporal store for large buffers.
Definition: cstring.hpp:923
vsmc::AES128_4x64
AES128Engine< uint64_t, 4 > AES128_4x64
AES-128 RNG engine with 64-bits integers output and 4 blocks.
Definition: aes.hpp:462
vsmc::Array::data
pointer data()
Definition: array.hpp:127
vsmc::AES192_2x32
AES192Engine< uint32_t, 2 > AES192_2x32
AES-192 RNG engine with 32-bits integers output and 2 blocks.
Definition: aes.hpp:626
vsmc::AES192Engine::AES192Engine
AES192Engine(SeedSeq &seq, typename cxx11::enable_if< internal::is_seed_seq< SeedSeq, typename base_eng_type::result_type, typename base_eng_type::key_type, AES192Engine< ResultType, Blocks > >::value >::type *=nullptr)
Definition: aes.hpp:605
vsmc::AES256_4x64
AES256Engine< uint64_t, 4 > AES256_4x64
AES-256 RNG engine with 64-bits integers output and 4 blocks.
Definition: aes.hpp:797
vsmc::AES192_4x64
AES192Engine< uint64_t, 4 > AES192_4x64
AES-192 RNG engine with 64-bits integers output and 4 blocks.
Definition: aes.hpp:650
vsmc::AES128KeySeq::generate
void generate(const key_type &key, Array< __m128i, Rp1 > &key_seq)
Definition: aes.hpp:352
vsmc::AES192_4x32
AES192Engine< uint32_t, 4 > AES192_4x32
AES-192 RNG engine with 32-bits integers output and 4 blocks.
Definition: aes.hpp:630
VSMC_DEFINE_RNG_AES_ROUND_CONSTANT
#define VSMC_DEFINE_RNG_AES_ROUND_CONSTANT(N, val)
Definition: aes.hpp:38
vsmc::AES128KeySeq
AES128Engine key sequence generator.
Definition: aes.hpp:345
vsmc::AES256_2x64
AES256Engine< uint64_t, 2 > AES256_2x64
AES-256 RNG engine with 64-bits integers output and 2 blocks.
Definition: aes.hpp:793
aes_ni.hpp
vsmc::Array
Static array.
Definition: array.hpp:79
vsmc::AES192Engine::AES192Engine
AES192Engine(const typename base_eng_type::key_type &k)
Definition: aes.hpp:612
vsmc::AES256Engine
AES-256 RNG engine.
Definition: aes.hpp:740
vsmc::AES192_64
AES192Engine< uint64_t > AES192_64
AES-192 RNG engine with 64-bits integers output and default blocks.
Definition: aes.hpp:638
vsmc::internal::AESKeyInit::key_init
static void key_init(const Array< T, KeySize > &key, Array< __m128i, Rp1 > &key_seq, __m128i &xmm)
Definition: aes.hpp:315
vsmc::AES128_8x64
AES128Engine< uint64_t, 8 > AES128_8x64
AES-128 RNG engine with 64-bits integers output and 8 blocks.
Definition: aes.hpp:466
vsmc::AES256KeySeq
AES256Engine key sequence generator.
Definition: aes.hpp:659
vsmc::AES256_4x32
AES256Engine< uint32_t, 4 > AES256_4x32
AES-256 RNG engine with 32-bits integers output and 4 blocks.
Definition: aes.hpp:777
vsmc::AES192Engine::base_eng_type
AESNIEngine< ResultType, AES192KeySeq< ResultType >, true, 12, Blocks > base_eng_type
Definition: aes.hpp:600
vsmc::AES256Engine::AES256Engine
AES256Engine(SeedSeq &seq, typename cxx11::enable_if< internal::is_seed_seq< SeedSeq, typename base_eng_type::result_type, typename base_eng_type::key_type, AES256Engine< ResultType, Blocks > >::value >::type *=nullptr)
Definition: aes.hpp:752
vsmc::AES128Engine
AES-128 RNG engine.
Definition: aes.hpp:405
vsmc::AES192_2x64
AES192Engine< uint64_t, 2 > AES192_2x64
AES-192 RNG engine with 64-bits integers output and 2 blocks.
Definition: aes.hpp:646
vsmc::AES192KeySeq
AES192Engine key sequence generator.
Definition: aes.hpp:471
Generated by   doxygen 1.8.9.1