Warning: This file is not a C or C++ file. It does not have highlighting.
1 | /*===----------------- keylockerintrin.h - KL Intrinsics -------------------=== |
---|---|
2 | * |
3 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
4 | * of this software and associated documentation files (the "Software"), to deal |
5 | * in the Software without restriction, including without limitation the rights |
6 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
7 | * copies of the Software, and to permit persons to whom the Software is |
8 | * furnished to do so, subject to the following conditions: |
9 | * |
10 | * The above copyright notice and this permission notice shall be included in |
11 | * all copies or substantial portions of the Software. |
12 | * |
13 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
14 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
15 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
16 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
17 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
18 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
19 | * THE SOFTWARE. |
20 | * |
21 | *===-----------------------------------------------------------------------=== |
22 | */ |
23 | |
24 | #ifndef __IMMINTRIN_H |
25 | #error "Never use <keylockerintrin.h> directly; include <immintrin.h> instead." |
26 | #endif |
27 | |
28 | #ifndef _KEYLOCKERINTRIN_H |
29 | #define _KEYLOCKERINTRIN_H |
30 | |
31 | #if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \ |
32 | defined(__KL__) |
33 | |
34 | /* Define the default attributes for the functions in this file. */ |
35 | #define __DEFAULT_FN_ATTRS \ |
36 | __attribute__((__always_inline__, __nodebug__, __target__("kl"),\ |
37 | __min_vector_width__(128))) |
38 | |
39 | /// Load internal wrapping key from __intkey, __enkey_lo and __enkey_hi. __ctl |
40 | /// will assigned to EAX, whch specifies the KeySource and whether backing up |
41 | /// the key is permitted. The 256-bit encryption key is loaded from the two |
42 | /// explicit operands (__enkey_lo and __enkey_hi). The 128-bit integrity key is |
43 | /// loaded from the implicit operand XMM0 which assigned by __intkey. |
44 | /// |
45 | /// \headerfile <x86intrin.h> |
46 | /// |
47 | /// This intrinsic corresponds to the <c> LOADIWKEY </c> instructions. |
48 | /// |
49 | /// \code{.operation} |
50 | /// IF CPL > 0 // LOADKWKEY only allowed at ring 0 (supervisor mode) |
51 | /// GP (0) |
52 | /// FI |
53 | /// IF “LOADIWKEY exiting” VM execution control set |
54 | /// VMexit |
55 | /// FI |
56 | /// IF __ctl[4:1] > 1 // Reserved KeySource encoding used |
57 | /// GP (0) |
58 | /// FI |
59 | /// IF __ctl[31:5] != 0 // Reserved bit in __ctl is set |
60 | /// GP (0) |
61 | /// FI |
62 | /// IF __ctl[0] AND (CPUID.19H.ECX[0] == 0) // NoBackup is not supported on this part |
63 | /// GP (0) |
64 | /// FI |
65 | /// IF (__ctl[4:1] == 1) AND (CPUID.19H.ECX[1] == 0) // KeySource of 1 is not supported on this part |
66 | /// GP (0) |
67 | /// FI |
68 | /// IF (__ctl[4:1] == 0) // KeySource of 0. |
69 | /// IWKey.Encryption Key[127:0] := __enkey_hi[127:0]: |
70 | /// IWKey.Encryption Key[255:128] := __enkey_lo[127:0] |
71 | /// IWKey.IntegrityKey[127:0] := __intkey[127:0] |
72 | /// IWKey.NoBackup := __ctl[0] |
73 | /// IWKey.KeySource := __ctl[4:1] |
74 | /// ZF := 0 |
75 | /// ELSE // KeySource of 1. See RDSEED definition for details of randomness |
76 | /// IF HW_NRND_GEN.ready == 1 // Full-entropy random data from RDSEED was received |
77 | /// IWKey.Encryption Key[127:0] := __enkey_hi[127:0] XOR HW_NRND_GEN.data[127:0] |
78 | /// IWKey.Encryption Key[255:128] := __enkey_lo[127:0] XOR HW_NRND_GEN.data[255:128] |
79 | /// IWKey.Encryption Key[255:0] := __enkey_hi[127:0]:__enkey_lo[127:0] XOR HW_NRND_GEN.data[255:0] |
80 | /// IWKey.IntegrityKey[127:0] := __intkey[127:0] XOR HW_NRND_GEN.data[383:256] |
81 | /// IWKey.NoBackup := __ctl[0] |
82 | /// IWKey.KeySource := __ctl[4:1] |
83 | /// ZF := 0 |
84 | /// ELSE // Random data was not returned from RDSEED. IWKey was not loaded |
85 | /// ZF := 1 |
86 | /// FI |
87 | /// FI |
88 | /// dst := ZF |
89 | /// OF := 0 |
90 | /// SF := 0 |
91 | /// AF := 0 |
92 | /// PF := 0 |
93 | /// CF := 0 |
94 | /// \endcode |
95 | static __inline__ void __DEFAULT_FN_ATTRS |
96 | _mm_loadiwkey (unsigned int __ctl, __m128i __intkey, |
97 | __m128i __enkey_lo, __m128i __enkey_hi) { |
98 | __builtin_ia32_loadiwkey (__intkey, __enkey_lo, __enkey_hi, __ctl); |
99 | } |
100 | |
101 | /// Wrap a 128-bit AES key from __key into a key handle and output in |
102 | /// ((__m128i*)__h) to ((__m128i*)__h) + 2 and a 32-bit value as return. |
103 | /// The explicit source operand __htype specifies handle restrictions. |
104 | /// |
105 | /// \headerfile <x86intrin.h> |
106 | /// |
107 | /// This intrinsic corresponds to the <c> ENCODEKEY128 </c> instructions. |
108 | /// |
109 | /// \code{.operation} |
110 | /// InputKey[127:0] := __key[127:0] |
111 | /// KeyMetadata[2:0] := __htype[2:0] |
112 | /// KeyMetadata[23:3] := 0 // Reserved for future usage |
113 | /// KeyMetadata[27:24] := 0 // KeyType is AES-128 (value of 0) |
114 | /// KeyMetadata[127:28] := 0 // Reserved for future usage |
115 | /// Handle[383:0] := WrapKey128(InputKey[127:0], KeyMetadata[127:0], |
116 | /// IWKey.Integrity Key[127:0], IWKey.Encryption Key[255:0]) |
117 | /// dst[0] := IWKey.NoBackup |
118 | /// dst[4:1] := IWKey.KeySource[3:0] |
119 | /// dst[31:5] := 0 |
120 | /// MEM[__h+127:__h] := Handle[127:0] // AAD |
121 | /// MEM[__h+255:__h+128] := Handle[255:128] // Integrity Tag |
122 | /// MEM[__h+383:__h+256] := Handle[383:256] // CipherText |
123 | /// OF := 0 |
124 | /// SF := 0 |
125 | /// ZF := 0 |
126 | /// AF := 0 |
127 | /// PF := 0 |
128 | /// CF := 0 |
129 | /// \endcode |
130 | static __inline__ unsigned int __DEFAULT_FN_ATTRS |
131 | _mm_encodekey128_u32(unsigned int __htype, __m128i __key, void *__h) { |
132 | return __builtin_ia32_encodekey128_u32(__htype, (__v2di)__key, __h); |
133 | } |
134 | |
135 | /// Wrap a 256-bit AES key from __key_hi:__key_lo into a key handle, then |
136 | /// output handle in ((__m128i*)__h) to ((__m128i*)__h) + 3 and |
137 | /// a 32-bit value as return. |
138 | /// The explicit source operand __htype specifies handle restrictions. |
139 | /// |
140 | /// \headerfile <x86intrin.h> |
141 | /// |
142 | /// This intrinsic corresponds to the <c> ENCODEKEY256 </c> instructions. |
143 | /// |
144 | /// \code{.operation} |
145 | /// InputKey[127:0] := __key_lo[127:0] |
146 | /// InputKey[255:128] := __key_hi[255:128] |
147 | /// KeyMetadata[2:0] := __htype[2:0] |
148 | /// KeyMetadata[23:3] := 0 // Reserved for future usage |
149 | /// KeyMetadata[27:24] := 1 // KeyType is AES-256 (value of 1) |
150 | /// KeyMetadata[127:28] := 0 // Reserved for future usage |
151 | /// Handle[511:0] := WrapKey256(InputKey[255:0], KeyMetadata[127:0], |
152 | /// IWKey.Integrity Key[127:0], IWKey.Encryption Key[255:0]) |
153 | /// dst[0] := IWKey.NoBackup |
154 | /// dst[4:1] := IWKey.KeySource[3:0] |
155 | /// dst[31:5] := 0 |
156 | /// MEM[__h+127:__h] := Handle[127:0] // AAD |
157 | /// MEM[__h+255:__h+128] := Handle[255:128] // Tag |
158 | /// MEM[__h+383:__h+256] := Handle[383:256] // CipherText[127:0] |
159 | /// MEM[__h+511:__h+384] := Handle[511:384] // CipherText[255:128] |
160 | /// OF := 0 |
161 | /// SF := 0 |
162 | /// ZF := 0 |
163 | /// AF := 0 |
164 | /// PF := 0 |
165 | /// CF := 0 |
166 | /// \endcode |
167 | static __inline__ unsigned int __DEFAULT_FN_ATTRS |
168 | _mm_encodekey256_u32(unsigned int __htype, __m128i __key_lo, __m128i __key_hi, |
169 | void *__h) { |
170 | return __builtin_ia32_encodekey256_u32(__htype, (__v2di)__key_lo, |
171 | (__v2di)__key_hi, __h); |
172 | } |
173 | |
174 | /// The AESENC128KL performs 10 rounds of AES to encrypt the __idata using |
175 | /// the 128-bit key in the handle from the __h. It stores the result in the |
176 | /// __odata. And return the affected ZF flag status. |
177 | /// |
178 | /// \headerfile <x86intrin.h> |
179 | /// |
180 | /// This intrinsic corresponds to the <c> AESENC128KL </c> instructions. |
181 | /// |
182 | /// \code{.operation} |
183 | /// Handle[383:0] := MEM[__h+383:__h] // Load is not guaranteed to be atomic. |
184 | /// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) || |
185 | /// (Handle[127:0] AND (CPL > 0)) || |
186 | /// Handle[383:256] || |
187 | /// HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128 ) |
188 | /// IF (IllegalHandle) |
189 | /// ZF := 1 |
190 | /// ELSE |
191 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey) |
192 | /// IF (Authentic == 0) |
193 | /// ZF := 1 |
194 | /// ELSE |
195 | /// MEM[__odata+127:__odata] := AES128Encrypt (__idata[127:0], UnwrappedKey) |
196 | /// ZF := 0 |
197 | /// FI |
198 | /// FI |
199 | /// dst := ZF |
200 | /// OF := 0 |
201 | /// SF := 0 |
202 | /// AF := 0 |
203 | /// PF := 0 |
204 | /// CF := 0 |
205 | /// \endcode |
206 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
207 | _mm_aesenc128kl_u8(__m128i* __odata, __m128i __idata, const void *__h) { |
208 | return __builtin_ia32_aesenc128kl_u8((__v2di *)__odata, (__v2di)__idata, __h); |
209 | } |
210 | |
211 | /// The AESENC256KL performs 14 rounds of AES to encrypt the __idata using |
212 | /// the 256-bit key in the handle from the __h. It stores the result in the |
213 | /// __odata. And return the affected ZF flag status. |
214 | /// |
215 | /// \headerfile <x86intrin.h> |
216 | /// |
217 | /// This intrinsic corresponds to the <c> AESENC256KL </c> instructions. |
218 | /// |
219 | /// \code{.operation} |
220 | /// Handle[511:0] := MEM[__h+511:__h] // Load is not guaranteed to be atomic. |
221 | /// IllegalHandle := ( HandleReservedBitSet (Handle[511:0]) || |
222 | /// (Handle[127:0] AND (CPL > 0)) || |
223 | /// Handle[255:128] || |
224 | /// HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES256 ) |
225 | /// IF (IllegalHandle) |
226 | /// ZF := 1 |
227 | /// MEM[__odata+127:__odata] := 0 |
228 | /// ELSE |
229 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey) |
230 | /// IF (Authentic == 0) |
231 | /// ZF := 1 |
232 | /// MEM[__odata+127:__odata] := 0 |
233 | /// ELSE |
234 | /// MEM[__odata+127:__odata] := AES256Encrypt (__idata[127:0], UnwrappedKey) |
235 | /// ZF := 0 |
236 | /// FI |
237 | /// FI |
238 | /// dst := ZF |
239 | /// OF := 0 |
240 | /// SF := 0 |
241 | /// AF := 0 |
242 | /// PF := 0 |
243 | /// CF := 0 |
244 | /// \endcode |
245 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
246 | _mm_aesenc256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) { |
247 | return __builtin_ia32_aesenc256kl_u8((__v2di *)__odata, (__v2di)__idata, __h); |
248 | } |
249 | |
250 | /// The AESDEC128KL performs 10 rounds of AES to decrypt the __idata using |
251 | /// the 128-bit key in the handle from the __h. It stores the result in the |
252 | /// __odata. And return the affected ZF flag status. |
253 | /// |
254 | /// \headerfile <x86intrin.h> |
255 | /// |
256 | /// This intrinsic corresponds to the <c> AESDEC128KL </c> instructions. |
257 | /// |
258 | /// \code{.operation} |
259 | /// Handle[383:0] := MEM[__h+383:__h] // Load is not guaranteed to be atomic. |
260 | /// IllegalHandle := (HandleReservedBitSet (Handle[383:0]) || |
261 | /// (Handle[127:0] AND (CPL > 0)) || |
262 | /// Handle[383:256] || |
263 | /// HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128) |
264 | /// IF (IllegalHandle) |
265 | /// ZF := 1 |
266 | /// MEM[__odata+127:__odata] := 0 |
267 | /// ELSE |
268 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey) |
269 | /// IF (Authentic == 0) |
270 | /// ZF := 1 |
271 | /// MEM[__odata+127:__odata] := 0 |
272 | /// ELSE |
273 | /// MEM[__odata+127:__odata] := AES128Decrypt (__idata[127:0], UnwrappedKey) |
274 | /// ZF := 0 |
275 | /// FI |
276 | /// FI |
277 | /// dst := ZF |
278 | /// OF := 0 |
279 | /// SF := 0 |
280 | /// AF := 0 |
281 | /// PF := 0 |
282 | /// CF := 0 |
283 | /// \endcode |
284 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
285 | _mm_aesdec128kl_u8(__m128i* __odata, __m128i __idata, const void *__h) { |
286 | return __builtin_ia32_aesdec128kl_u8((__v2di *)__odata, (__v2di)__idata, __h); |
287 | } |
288 | |
289 | /// The AESDEC256KL performs 10 rounds of AES to decrypt the __idata using |
290 | /// the 256-bit key in the handle from the __h. It stores the result in the |
291 | /// __odata. And return the affected ZF flag status. |
292 | /// |
293 | /// \headerfile <x86intrin.h> |
294 | /// |
295 | /// This intrinsic corresponds to the <c> AESDEC256KL </c> instructions. |
296 | /// |
297 | /// \code{.operation} |
298 | /// Handle[511:0] := MEM[__h+511:__h] |
299 | /// IllegalHandle := (HandleReservedBitSet (Handle[511:0]) || |
300 | /// (Handle[127:0] AND (CPL > 0)) || |
301 | /// Handle[383:256] || |
302 | /// HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES256) |
303 | /// IF (IllegalHandle) |
304 | /// ZF := 1 |
305 | /// MEM[__odata+127:__odata] := 0 |
306 | /// ELSE |
307 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey) |
308 | /// IF (Authentic == 0) |
309 | /// ZF := 1 |
310 | /// MEM[__odata+127:__odata] := 0 |
311 | /// ELSE |
312 | /// MEM[__odata+127:__odata] := AES256Decrypt (__idata[127:0], UnwrappedKey) |
313 | /// ZF := 0 |
314 | /// FI |
315 | /// FI |
316 | /// dst := ZF |
317 | /// OF := 0 |
318 | /// SF := 0 |
319 | /// AF := 0 |
320 | /// PF := 0 |
321 | /// CF := 0 |
322 | /// \endcode |
323 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
324 | _mm_aesdec256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) { |
325 | return __builtin_ia32_aesdec256kl_u8((__v2di *)__odata, (__v2di)__idata, __h); |
326 | } |
327 | |
328 | #undef __DEFAULT_FN_ATTRS |
329 | |
330 | #endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \ |
331 | || defined(__KL__) */ |
332 | |
333 | #if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \ |
334 | defined(__WIDEKL__) |
335 | |
336 | /* Define the default attributes for the functions in this file. */ |
337 | #define __DEFAULT_FN_ATTRS \ |
338 | __attribute__((__always_inline__, __nodebug__, __target__("kl,widekl"),\ |
339 | __min_vector_width__(128))) |
340 | |
341 | /// Encrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle |
342 | /// at __h and store each resultant block back from __odata to __odata+7. And |
343 | /// return the affected ZF flag status. |
344 | /// |
345 | /// \headerfile <x86intrin.h> |
346 | /// |
347 | /// This intrinsic corresponds to the <c> AESENCWIDE128KL </c> instructions. |
348 | /// |
349 | /// \code{.operation} |
350 | /// Handle := MEM[__h+383:__h] |
351 | /// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) || |
352 | /// (Handle[127:0] AND (CPL > 0)) || |
353 | /// Handle[255:128] || |
354 | /// HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128 ) |
355 | /// IF (IllegalHandle) |
356 | /// ZF := 1 |
357 | /// FOR i := 0 to 7 |
358 | /// __odata[i] := 0 |
359 | /// ENDFOR |
360 | /// ELSE |
361 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey) |
362 | /// IF Authentic == 0 |
363 | /// ZF := 1 |
364 | /// FOR i := 0 to 7 |
365 | /// __odata[i] := 0 |
366 | /// ENDFOR |
367 | /// ELSE |
368 | /// FOR i := 0 to 7 |
369 | /// __odata[i] := AES128Encrypt (__idata[i], UnwrappedKey) |
370 | /// ENDFOR |
371 | /// ZF := 0 |
372 | /// FI |
373 | /// FI |
374 | /// dst := ZF |
375 | /// OF := 0 |
376 | /// SF := 0 |
377 | /// AF := 0 |
378 | /// PF := 0 |
379 | /// CF := 0 |
380 | /// \endcode |
381 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
382 | _mm_aesencwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) { |
383 | return __builtin_ia32_aesencwide128kl_u8((__v2di *)__odata, |
384 | (const __v2di *)__idata, __h); |
385 | } |
386 | |
387 | /// Encrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle |
388 | /// at __h and store each resultant block back from __odata to __odata+7. And |
389 | /// return the affected ZF flag status. |
390 | /// |
391 | /// \headerfile <x86intrin.h> |
392 | /// |
393 | /// This intrinsic corresponds to the <c> AESENCWIDE256KL </c> instructions. |
394 | /// |
395 | /// \code{.operation} |
396 | /// Handle[511:0] := MEM[__h+511:__h] |
397 | /// IllegalHandle := ( HandleReservedBitSet (Handle[511:0]) || |
398 | /// (Handle[127:0] AND (CPL > 0)) || |
399 | /// Handle[255:128] || |
400 | /// HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES512 ) |
401 | /// IF (IllegalHandle) |
402 | /// ZF := 1 |
403 | /// FOR i := 0 to 7 |
404 | /// __odata[i] := 0 |
405 | /// ENDFOR |
406 | /// ELSE |
407 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey) |
408 | /// IF Authentic == 0 |
409 | /// ZF := 1 |
410 | /// FOR i := 0 to 7 |
411 | /// __odata[i] := 0 |
412 | /// ENDFOR |
413 | /// ELSE |
414 | /// FOR i := 0 to 7 |
415 | /// __odata[i] := AES256Encrypt (__idata[i], UnwrappedKey) |
416 | /// ENDFOR |
417 | /// ZF := 0 |
418 | /// FI |
419 | /// FI |
420 | /// dst := ZF |
421 | /// OF := 0 |
422 | /// SF := 0 |
423 | /// AF := 0 |
424 | /// PF := 0 |
425 | /// CF := 0 |
426 | /// \endcode |
427 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
428 | _mm_aesencwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) { |
429 | return __builtin_ia32_aesencwide256kl_u8((__v2di *)__odata, |
430 | (const __v2di *)__idata, __h); |
431 | } |
432 | |
433 | /// Decrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle |
434 | /// at __h and store each resultant block back from __odata to __odata+7. And |
435 | /// return the affected ZF flag status. |
436 | /// |
437 | /// \headerfile <x86intrin.h> |
438 | /// |
439 | /// This intrinsic corresponds to the <c> AESDECWIDE128KL </c> instructions. |
440 | /// |
441 | /// \code{.operation} |
442 | /// Handle[383:0] := MEM[__h+383:__h] |
443 | /// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) || |
444 | /// (Handle[127:0] AND (CPL > 0)) || |
445 | /// Handle[255:128] || |
446 | /// HandleKeyType (Handle) != HANDLE_KEY_TYPE_AES128 ) |
447 | /// IF (IllegalHandle) |
448 | /// ZF := 1 |
449 | /// FOR i := 0 to 7 |
450 | /// __odata[i] := 0 |
451 | /// ENDFOR |
452 | /// ELSE |
453 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey) |
454 | /// IF Authentic == 0 |
455 | /// ZF := 1 |
456 | /// FOR i := 0 to 7 |
457 | /// __odata[i] := 0 |
458 | /// ENDFOR |
459 | /// ELSE |
460 | /// FOR i := 0 to 7 |
461 | /// __odata[i] := AES128Decrypt (__idata[i], UnwrappedKey) |
462 | /// ENDFOR |
463 | /// ZF := 0 |
464 | /// FI |
465 | /// FI |
466 | /// dst := ZF |
467 | /// OF := 0 |
468 | /// SF := 0 |
469 | /// AF := 0 |
470 | /// PF := 0 |
471 | /// CF := 0 |
472 | /// \endcode |
473 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
474 | _mm_aesdecwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) { |
475 | return __builtin_ia32_aesdecwide128kl_u8((__v2di *)__odata, |
476 | (const __v2di *)__idata, __h); |
477 | } |
478 | |
479 | /// Decrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle |
480 | /// at __h and store each resultant block back from __odata to __odata+7. And |
481 | /// return the affected ZF flag status. |
482 | /// |
483 | /// \headerfile <x86intrin.h> |
484 | /// |
485 | /// This intrinsic corresponds to the <c> AESDECWIDE256KL </c> instructions. |
486 | /// |
487 | /// \code{.operation} |
488 | /// Handle[511:0] := MEM[__h+511:__h] |
489 | /// IllegalHandle = ( HandleReservedBitSet (Handle[511:0]) || |
490 | /// (Handle[127:0] AND (CPL > 0)) || |
491 | /// Handle[255:128] || |
492 | /// HandleKeyType (Handle) != HANDLE_KEY_TYPE_AES512 ) |
493 | /// If (IllegalHandle) |
494 | /// ZF := 1 |
495 | /// FOR i := 0 to 7 |
496 | /// __odata[i] := 0 |
497 | /// ENDFOR |
498 | /// ELSE |
499 | /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey) |
500 | /// IF Authentic == 0 |
501 | /// ZF := 1 |
502 | /// FOR i := 0 to 7 |
503 | /// __odata[i] := 0 |
504 | /// ENDFOR |
505 | /// ELSE |
506 | /// FOR i := 0 to 7 |
507 | /// __odata[i] := AES256Decrypt (__idata[i], UnwrappedKey) |
508 | /// ENDFOR |
509 | /// ZF := 0 |
510 | /// FI |
511 | /// FI |
512 | /// dst := ZF |
513 | /// OF := 0 |
514 | /// SF := 0 |
515 | /// AF := 0 |
516 | /// PF := 0 |
517 | /// CF := 0 |
518 | /// \endcode |
519 | static __inline__ unsigned char __DEFAULT_FN_ATTRS |
520 | _mm_aesdecwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) { |
521 | return __builtin_ia32_aesdecwide256kl_u8((__v2di *)__odata, |
522 | (const __v2di *)__idata, __h); |
523 | } |
524 | |
525 | #undef __DEFAULT_FN_ATTRS |
526 | |
527 | #endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \ |
528 | || defined(__WIDEKL__) */ |
529 | |
530 | #endif /* _KEYLOCKERINTRIN_H */ |
531 |
Warning: This file is not a C or C++ file. It does not have highlighting.