1 /* Copyright (c) (2010-2012,2014-2022) Apple Inc. All rights reserved.
2 *
3 * corecrypto is licensed under Apple Inc.’s Internal Use License Agreement (which
4 * is contained in the License.txt file distributed with corecrypto) and only to
5 * people who accept that license. IMPORTANT: Any license rights granted to you by
6 * Apple Inc. (if any) are limited to internal use within your organization only on
7 * devices and computers you own or control, for the sole purpose of verifying the
8 * security characteristics and correct functioning of the Apple Software. You may
9 * not, directly or indirectly, redistribute the Apple Software or any portions thereof.
10 */
11
12 #ifndef _CORECRYPTO_CC_PRIV_H_
13 #define _CORECRYPTO_CC_PRIV_H_
14
15 #include <corecrypto/cc.h>
16
17 CC_PTRCHECK_CAPABLE_HEADER()
18
19 #if !CC_EXCLAVEKIT
20 // Fork handlers for the stateful components of corecrypto.
21 void cc_atfork_prepare(void);
22 void cc_atfork_parent(void);
23 void cc_atfork_child(void);
24 #endif
25
26 #ifndef __has_builtin
27 #define __has_builtin(x) 0
28 #endif
29
30 #ifndef __DECONST
31 #define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var))
32 #endif
33
34 /* defines the following macros :
35
36 CC_ARRAY_LEN: returns the number of elements in an array
37
38 CC_ROR : Rotate Right 32 bits. Rotate count can be a variable.
39 CC_ROL : Rotate Left 32 bits. Rotate count can be a variable.
40 CC_RORc : Rotate Right 32 bits. Rotate count must be a constant.
41 CC_ROLc : Rotate Left 32 bits. Rotate count must be a constant.
42
43 CC_ROR64 : Rotate Right 64 bits. Rotate count can be a variable.
44 CC_ROL64 : Rotate Left 64 bits. Rotate count can be a variable.
45 CC_ROR64c : Rotate Right 64 bits. Rotate count must be a constant.
46 CC_ROL64c : Rotate Left 64 bits. Rotate count must be a constant.
47
48 CC_BSWAP : byte swap a 32 bits variable.
49
50 CC_H2BE32 : convert a 32 bits value between host and big endian order.
51 CC_H2LE32 : convert a 32 bits value between host and little endian order.
52
53 CC_BSWAP64 : byte swap a 64 bits variable
54
55 CC_H2BE64 : convert a 64 bits value between host and big endian order
56 CC_H2LE64 : convert a 64 bits value between host and little endian order
57
58 */
59
60 // RTKitOSPlatform should replace CC_MEMCPY with memcpy
61 #define CC_MEMCPY(D,S,L) cc_memcpy((D),(S),(L))
62 #define CC_MEMMOVE(D,S,L) cc_memmove((D),(S),(L))
63 #define CC_MEMSET(D,V,L) cc_memset((D),(V),(L))
64
65 #if CC_EFI
66 void *cc_memcpy(void *dst, const void *src, size_t len);
67 #define cc_memcpy_nochk(dst, src, len) cc_memcpy((dst), (src), (len))
68 #elif __has_builtin(__builtin___memcpy_chk) && !defined(_MSC_VER) && !CC_SGX && !CC_ARM_ARCH_6M
69 #define cc_memcpy(dst, src, len) __builtin___memcpy_chk((dst), (src), (len), __builtin_object_size((dst), 1))
70 #define cc_memcpy_nochk(dst, src, len) __builtin___memcpy_chk((dst), (src), (len), __builtin_object_size((dst), 0))
71 #else
72 #define cc_memcpy(dst, src, len) memcpy((dst), (src), (len))
73 #define cc_memcpy_nochk(dst, src, len) memcpy((dst), (src), (len))
74 #endif
75
76 #if CC_EFI
77 void *cc_memmove(void *dst, const void *src, size_t len);
78 #elif __has_builtin(__builtin___memmove_chk) && !defined(_MSC_VER) && !CC_SGX && !CC_ARM_ARCH_6M
79 #define cc_memmove(dst, src, len) __builtin___memmove_chk((dst), (src), (len), __builtin_object_size((dst), 1))
80 #else
81 #define cc_memmove(dst, src, len) memmove((dst), (src), (len))
82 #endif
83
84 #if CC_EFI
85 void *cc_memset(void *dst, int val, size_t num);
86 #elif __has_builtin(__builtin___memset_chk) && !defined(_MSC_VER) && !CC_SGX && !CC_ARM_ARCH_6M
87 #define cc_memset(dst, val, len) __builtin___memset_chk((dst), (val), (len), __builtin_object_size((dst), 1))
88 #else
89 #define cc_memset(dst, val, len) memset((dst), (val), (len))
90 #endif
91
92 #define CC_ARRAY_LEN(x) (sizeof((x))/sizeof((x)[0]))
93
94 // MARK: - Loads and Store
95
96 // 64 bit load & store big endian
97 #if defined(__x86_64__) && !defined(_MSC_VER)
98 CC_INLINE void cc_store64_be(uint64_t x, uint8_t cc_sized_by(8) * y)
99 {
100 __asm__("bswapq %1 \n\t"
101 "movq %1, %0 \n\t"
102 "bswapq %1 \n\t"
103 : "=m"(*(y))
104 : "r"(x));
105 }
106 CC_INLINE uint64_t cc_load64_be(const uint8_t cc_sized_by(8) * y)
107 {
108 uint64_t x;
109 __asm__("movq %1, %0 \n\t"
110 "bswapq %0 \n\t"
111 : "=r"(x)
112 : "m"(*(y)));
113 return x;
114 }
115 #else
116 CC_INLINE void cc_store64_be(uint64_t x, uint8_t cc_sized_by(8) * y)
117 {
118 y[0] = (uint8_t)(x >> 56);
119 y[1] = (uint8_t)(x >> 48);
120 y[2] = (uint8_t)(x >> 40);
121 y[3] = (uint8_t)(x >> 32);
122 y[4] = (uint8_t)(x >> 24);
123 y[5] = (uint8_t)(x >> 16);
124 y[6] = (uint8_t)(x >> 8);
125 y[7] = (uint8_t)(x);
126 }
127 CC_INLINE uint64_t cc_load64_be(const uint8_t cc_sized_by(8) * y)
128 {
129 return (((uint64_t)(y[0])) << 56) | (((uint64_t)(y[1])) << 48) | (((uint64_t)(y[2])) << 40) | (((uint64_t)(y[3])) << 32) |
130 (((uint64_t)(y[4])) << 24) | (((uint64_t)(y[5])) << 16) | (((uint64_t)(y[6])) << 8) | ((uint64_t)(y[7]));
131 }
132 #endif
133
134 // 32 bit load & store big endian
135 #if (defined(__i386__) || defined(__x86_64__)) && !defined(_MSC_VER)
136 CC_INLINE void cc_store32_be(uint32_t x, uint8_t cc_sized_by(4) * y)
137 {
138 __asm__("bswapl %1 \n\t"
139 "movl %1, %0 \n\t"
140 "bswapl %1 \n\t"
141 : "=m"(*(y))
142 : "r"(x));
143 }
144 CC_INLINE uint32_t cc_load32_be(const uint8_t cc_sized_by(4) * y)
145 {
146 uint32_t x;
147 __asm__("movl %1, %0 \n\t"
148 "bswapl %0 \n\t"
149 : "=r"(x)
150 : "m"(*(y)));
151 return x;
152 }
153 #else
154 CC_INLINE void cc_store32_be(uint32_t x, uint8_t cc_sized_by(4) * y)
155 {
156 y[0] = (uint8_t)(x >> 24);
157 y[1] = (uint8_t)(x >> 16);
158 y[2] = (uint8_t)(x >> 8);
159 y[3] = (uint8_t)(x);
160 }
161 CC_INLINE uint32_t cc_load32_be(const uint8_t cc_sized_by(4) * y)
162 {
163 return (((uint32_t)(y[0])) << 24) | (((uint32_t)(y[1])) << 16) | (((uint32_t)(y[2])) << 8) | ((uint32_t)(y[3]));
164 }
165 #endif
166
167 CC_INLINE void cc_store16_be(uint16_t x, uint8_t cc_sized_by(2) * y)
168 {
169 y[0] = (uint8_t)(x >> 8);
170 y[1] = (uint8_t)(x);
171 }
172 CC_INLINE uint16_t cc_load16_be(const uint8_t cc_sized_by(2) * y)
173 {
174 return (uint16_t) (((uint16_t)(y[0])) << 8) | ((uint16_t)(y[1]));
175 }
176
177 // 64 bit load & store little endian
178 CC_INLINE void cc_store64_le(uint64_t x, uint8_t cc_sized_by(8) * y)
179 {
180 y[7] = (uint8_t)(x >> 56);
181 y[6] = (uint8_t)(x >> 48);
182 y[5] = (uint8_t)(x >> 40);
183 y[4] = (uint8_t)(x >> 32);
184 y[3] = (uint8_t)(x >> 24);
185 y[2] = (uint8_t)(x >> 16);
186 y[1] = (uint8_t)(x >> 8);
187 y[0] = (uint8_t)(x);
188 }
189 CC_INLINE uint64_t cc_load64_le(const uint8_t cc_sized_by(8) * y)
190 {
191 return (((uint64_t)(y[7])) << 56) | (((uint64_t)(y[6])) << 48) | (((uint64_t)(y[5])) << 40) | (((uint64_t)(y[4])) << 32) |
192 (((uint64_t)(y[3])) << 24) | (((uint64_t)(y[2])) << 16) | (((uint64_t)(y[1])) << 8) | ((uint64_t)(y[0]));
193 }
194
195 // 32 bit load & store little endian
196 CC_INLINE void cc_store32_le(uint32_t x, uint8_t cc_sized_by(4) * y)
197 {
198 y[3] = (uint8_t)(x >> 24);
199 y[2] = (uint8_t)(x >> 16);
200 y[1] = (uint8_t)(x >> 8);
201 y[0] = (uint8_t)(x);
202 }
203 CC_INLINE uint32_t cc_load32_le(const uint8_t cc_sized_by(4) * y)
204 {
205 return (((uint32_t)(y[3])) << 24) | (((uint32_t)(y[2])) << 16) | (((uint32_t)(y[1])) << 8) | ((uint32_t)(y[0]));
206 }
207
208 #if (CCN_UNIT_SIZE == 8)
209 #define cc_load_le cc_load64_le
210 #define cc_store_le cc_store64_le
211 #else
212 #define cc_load_le cc_load32_le
213 #define cc_store_le cc_store32_le
214 #endif
215
216 // MARK: - Byte Swaps
217
218 #if __has_builtin(__builtin_bswap32)
219 #define CC_BSWAP32(x) __builtin_bswap32(x)
220 #else
CC_BSWAP32(uint32_t x)221 CC_INLINE uint32_t CC_BSWAP32(uint32_t x)
222 {
223 return
224 ((x & 0xff000000) >> 24) |
225 ((x & 0x00ff0000) >> 8) |
226 ((x & 0x0000ff00) << 8) |
227 ((x & 0x000000ff) << 24);
228 }
229 #endif
230
231 #if __has_builtin(__builtin_bswap64)
232 #define CC_BSWAP64(x) __builtin_bswap64(x)
233 #else
CC_BSWAP64(uint64_t x)234 CC_INLINE uint64_t CC_BSWAP64(uint64_t x)
235 {
236 return
237 ((x & 0xff00000000000000ULL) >> 56) |
238 ((x & 0x00ff000000000000ULL) >> 40) |
239 ((x & 0x0000ff0000000000ULL) >> 24) |
240 ((x & 0x000000ff00000000ULL) >> 8) |
241 ((x & 0x00000000ff000000ULL) << 8) |
242 ((x & 0x0000000000ff0000ULL) << 24) |
243 ((x & 0x000000000000ff00ULL) << 40) |
244 ((x & 0x00000000000000ffULL) << 56);
245 }
246 #endif
247
248 #ifdef __LITTLE_ENDIAN__
249 #define CC_H2BE32(x) CC_BSWAP32(x)
250 #define CC_H2LE32(x) (x)
251 #define CC_H2BE64(x) CC_BSWAP64(x)
252 #define CC_H2LE64(x) (x)
253 #else
254 #define CC_H2BE32(x) (x)
255 #define CC_H2LE32(x) CC_BSWAP32(x)
256 #define CC_H2BE64(x) (x)
257 #define CC_H2LE64(x) CC_BSWAP64(x)
258 #endif
259
260 #define cc_ceiling(a,b) (((a)+((b)-1))/(b))
261 #define CC_BITLEN_TO_BYTELEN(x) cc_ceiling((x), 8)
262
263 #define CC_PROVIDES_ABORT (!(CC_BASEBAND || CC_EFI || CC_RTKITROM || CC_USE_SEPROM))
264
265 /*!
266 @function cc_abort
267 @abstract Abort execution unconditionally
268 */
269 CC_NORETURN
270 void cc_abort(const char *msg);
271
272 /*!
273 @function cc_try_abort
274 @abstract Abort execution iff the platform provides a function like @p abort() or @p panic()
275
276 @discussion If the platform does not provide a means to abort execution, this function does nothing; therefore, callers should return an error code after calling this function.
277 */
278 void cc_try_abort(const char *msg);
279
280 #if __has_builtin(__builtin_expect)
281 #define CC_LIKELY(cond) __builtin_expect(!!(cond), 1)
282 #define CC_UNLIKELY(cond) __builtin_expect(!!(cond), 0)
283 #else
284 #define CC_LIKELY(cond) cond
285 #define CC_UNLIKELY(cond) cond
286 #endif
287
288 #define cc_abort_if(cond, msg) \
289 do { \
290 if (CC_UNLIKELY(cond)) { \
291 cc_abort(msg); \
292 } \
293 } while (0)
294
295 void cc_try_abort_if(bool condition, const char *msg);
296
297 /*
298 Unfortunately, since we export this symbol, this declaration needs
299 to be in a public header to satisfy TAPI.
300
301 See fipspost_trace_priv.h for more details.
302 */
303 extern const void *fipspost_trace_vtable;
304
305
306 // MARK: -- Deprecated macros
307 /*
308 Use `cc_store32_be`, `cc_store32_le`, `cc_store64_be`, `cc_store64_le`, and
309 `cc_load32_be`, `cc_load32_le`, `cc_load64_be`, `cc_load64_le` instead.
310
311 CC_STORE32_BE : store 32 bit value in big endian in unaligned buffer.
312 CC_STORE32_LE : store 32 bit value in little endian in unaligned buffer.
313 CC_STORE64_BE : store 64 bit value in big endian in unaligned buffer.
314 CC_STORE64_LE : store 64 bit value in little endian in unaligned buffer.
315 CC_LOAD32_BE : load 32 bit value in big endian from unaligned buffer.
316 CC_LOAD32_LE : load 32 bit value in little endian from unaligned buffer.
317 CC_LOAD64_BE : load 64 bit value in big endian from unaligned buffer.
318 CC_LOAD64_LE : load 64 bit value in little endian from unaligned buffer.
319 CC_READ_LE32 : read a 32 bits little endian value
320 CC_WRITE_LE32 : write a 32 bits little endian value
321 CC_WRITE_LE64 : write a 64 bits little endian value
322 */
323
324 #define CC_STORE32_BE(x, y) cc_store32_be((uint32_t)(x), (uint8_t *)(y))
325 #define CC_STORE32_LE(x, y) cc_store32_le((uint32_t)(x), (uint8_t *)(y))
326 #define CC_STORE64_BE(x, y) cc_store64_be((uint64_t)(x), (uint8_t *)(y))
327 #define CC_STORE64_LE(x, y) cc_store64_le((uint64_t)(x), (uint8_t *)(y))
328
329 #define CC_LOAD32_BE(x, y) ((x) = cc_load32_be((uint8_t *)(y)))
330 #define CC_LOAD32_LE(x, y) ((x) = cc_load32_le((uint8_t *)(y)))
331 #define CC_LOAD64_BE(x, y) ((x) = cc_load64_be((uint8_t *)(y)))
332 #define CC_LOAD64_LE(x, y) ((x) = cc_load64_le((uint8_t *)(y)))
333
334 #define CC_READ_LE32(ptr) cc_load32_le((uint8_t *)(ptr))
335
336 #define CC_WRITE_LE32(ptr, x) cc_store32_le((uint32_t)(x), (uint8_t *)(ptr))
337 #define CC_WRITE_LE64(ptr, x) cc_store64_le((uint64_t)(x), (uint8_t *)(ptr))
338
339 #endif /* _CORECRYPTO_CC_PRIV_H_ */
340