EXTERNAL_HEADERS/corecrypto/cc_priv.h

   1 /*
   2  *  cc_priv.h
   3  *  corecrypto
   4  *
   5  *  Created by Michael Brouwer on 12/1/10.
   6  *  Copyright 2010,2011 Apple Inc. All rights reserved.
   7  *
   8  */
   9
  10 #ifndef _CORECRYPTO_CC_PRIV_H_
  11 #define _CORECRYPTO_CC_PRIV_H_
  12
  13 #include <corecrypto/cc.h>
  14 #include <stdint.h>
  15
  16 /* defines the following macros :
  17
  18  CC_MEMCPY  : optimized memcpy.
  19  CC_MEMMOVE : optimized memmove.
  20  CC_MEMSET  : optimized memset.
  21  CC_BZERO   : optimized bzero.
  22
  23  CC_STORE32_BE : store 32 bit value in big endian in unaligned buffer.
  24  CC_STORE32_LE : store 32 bit value in little endian in unaligned buffer.
  25  CC_STORE64_BE : store 64 bit value in big endian in unaligned buffer.
  26  CC_STORE64_LE : store 64 bit value in little endian in unaligned buffer.
  27
  28  CC_LOAD32_BE : load 32 bit value in big endian from unaligned buffer.
  29  CC_LOAD32_LE : load 32 bit value in little endian from unaligned buffer.
  30  CC_LOAD64_BE : load 64 bit value in big endian from unaligned buffer.
  31  CC_LOAD64_LE : load 64 bit value in little endian from unaligned buffer.
  32
  33  CC_ROR  : Rotate Right 32 bits. Rotate count can be a variable.
  34  CC_ROL  : Rotate Left 32 bits. Rotate count can be a variable.
  35  CC_RORc : Rotate Right 32 bits. Rotate count must be a constant.
  36  CC_ROLc : Rotate Left 32 bits. Rotate count must be a constant.
  37
  38  CC_ROR64  : Rotate Right 64 bits. Rotate count can be a variable.
  39  CC_ROL64  : Rotate Left 64 bits. Rotate count can be a variable.
  40  CC_ROR64c : Rotate Right 64 bits. Rotate count must be a constant.
  41  CC_ROL64c : Rotate Left 64 bits. Rotate count must be a constant.
  42
  43  CC_BSWAP  : byte swap a 32 bits variable.
  44
  45  CC_H2BE32 : convert a 32 bits value between host and big endian order.
  46  CC_H2LE32 : convert a 32 bits value between host and little endian order.
  47
  48 The following are not defined yet... define them if needed.
  49
  50  CC_BSWAPc   : byte swap a 32 bits constant
  51
  52  CC_BSWAP64  : byte swap a 64 bits variable
  53  CC_BSWAP64c : byte swap a 64 bits constant
  54
  55  CC_READ_LE32 : read a 32 bits little endian value
  56  CC_READ_LE64 : read a 64 bits little endian value
  57  CC_READ_BE32 : read a 32 bits big endian value
  58  CC_READ_BE64 : read a 64 bits big endian value
  59
  60  CC_WRITE_LE32 : write a 32 bits little endian value
  61  CC_WRITE_LE64 : write a 64 bits little endian value
  62  CC_WRITE_BE32 : write a 32 bits big endian value
  63  CC_WRITE_BE64 : write a 64 bits big endian value
  64
  65  CC_H2BE64 : convert a 64 bits value between host and big endian order
  66  CC_H2LE64 : convert a 64 bits value between host and little endian order
  67
  68 */
  69
  70 /* TODO: optimized versions */
  71 #define CC_MEMCPY(D,S,L) memcpy((D),(S),(L))
  72 #define CC_MEMMOVE(D,S,L) memmove((D),(S),(L))
  73 #define CC_MEMSET(D,V,L) memset((D),(V),(L))
  74 #define CC_BZERO(D,L) memset((D),0,(L))
  75
  76
  77 // MARK: - Loads and Store
  78
  79 // MARK: -- 32 bits - little endian
  80
  81 // MARK: --- Default version
  82
  83 #define CC_STORE32_LE(x, y) do {                                    \
  84     ((unsigned char *)(y))[3] = (unsigned char)(((x)>>24)&255);         \
  85     ((unsigned char *)(y))[2] = (unsigned char)(((x)>>16)&255);         \
  86     ((unsigned char *)(y))[1] = (unsigned char)(((x)>>8)&255);          \
  87     ((unsigned char *)(y))[0] = (unsigned char)((x)&255);                       \
  88 } while(0)
  89
  90 #define CC_LOAD32_LE(x, y) do {                                     \
  91 x = ((uint32_t)(((unsigned char *)(y))[3] & 255)<<24) |                     \
  92     ((uint32_t)(((unsigned char *)(y))[2] & 255)<<16) |                     \
  93     ((uint32_t)(((unsigned char *)(y))[1] & 255)<<8)  |                     \
  94     ((uint32_t)(((unsigned char *)(y))[0] & 255));                                  \
  95 } while(0)
  96
  97 // MARK: -- 64 bits - little endian
  98
  99 #define CC_STORE64_LE(x, y) do {                                    \
 100     ((unsigned char *)(y))[7] = (unsigned char)(((x)>>56)&255);     \
 101     ((unsigned char *)(y))[6] = (unsigned char)(((x)>>48)&255);         \
 102     ((unsigned char *)(y))[5] = (unsigned char)(((x)>>40)&255);         \
 103     ((unsigned char *)(y))[4] = (unsigned char)(((x)>>32)&255);         \
 104     ((unsigned char *)(y))[3] = (unsigned char)(((x)>>24)&255);         \
 105     ((unsigned char *)(y))[2] = (unsigned char)(((x)>>16)&255);         \
 106     ((unsigned char *)(y))[1] = (unsigned char)(((x)>>8)&255);          \
 107     ((unsigned char *)(y))[0] = (unsigned char)((x)&255);                       \
 108 } while(0)
 109
 110 #define CC_LOAD64_LE(x, y) do {                                     \
 111 x = (((uint64_t)(((unsigned char *)(y))[7] & 255))<<56) |           \
 112     (((uint64_t)(((unsigned char *)(y))[6] & 255))<<48) |           \
 113     (((uint64_t)(((unsigned char *)(y))[5] & 255))<<40) |           \
 114     (((uint64_t)(((unsigned char *)(y))[4] & 255))<<32) |           \
 115     (((uint64_t)(((unsigned char *)(y))[3] & 255))<<24) |           \
 116     (((uint64_t)(((unsigned char *)(y))[2] & 255))<<16) |           \
 117     (((uint64_t)(((unsigned char *)(y))[1] & 255))<<8)  |           \
 118     (((uint64_t)(((unsigned char *)(y))[0] & 255)));                \
 119 } while(0)
 120
 121 // MARK: -- 32 bits - big endian
 122 // MARK: --- intel version
 123
 124 #if (defined(__i386__) || defined(__x86_64__))
 125
 126 #define CC_STORE32_BE(x, y)     \
 127     __asm__ __volatile__ (      \
 128     "bswapl %0     \n\t"        \
 129     "movl   %0,(%1)\n\t"        \
 130     "bswapl %0     \n\t"        \
 131     ::"r"(x), "r"(y))
 132
 133 #define CC_LOAD32_BE(x, y)      \
 134     __asm__ __volatile__ (      \
 135     "movl (%1),%0\n\t"          \
 136     "bswapl %0\n\t"             \
 137     :"=r"(x): "r"(y))
 138
 139 #else
 140 // MARK: --- default version
 141 #define CC_STORE32_BE(x, y) do {                                \
 142     ((unsigned char *)(y))[0] = (unsigned char)(((x)>>24)&255); \
 143     ((unsigned char *)(y))[1] = (unsigned char)(((x)>>16)&255); \
 144     ((unsigned char *)(y))[2] = (unsigned char)(((x)>>8)&255);  \
 145     ((unsigned char *)(y))[3] = (unsigned char)((x)&255);       \
 146 } while(0)
 147
 148 #define CC_LOAD32_BE(x, y) do {                             \
 149 x = ((uint32_t)(((unsigned char *)(y))[0] & 255)<<24) |     \
 150     ((uint32_t)(((unsigned char *)(y))[1] & 255)<<16) |         \
 151     ((uint32_t)(((unsigned char *)(y))[2] & 255)<<8)  |         \
 152     ((uint32_t)(((unsigned char *)(y))[3] & 255));          \
 153 } while(0)
 154
 155 #endif
 156
 157 // MARK: -- 64 bits - big endian
 158
 159 // MARK: --- intel 64 bits version
 160
 161 #if defined(__x86_64__)
 162
 163 #define CC_STORE64_BE(x, y)   \
 164 __asm__ __volatile__ (        \
 165 "bswapq %0     \n\t"          \
 166 "movq   %0,(%1)\n\t"          \
 167 "bswapq %0     \n\t"          \
 168 ::"r"(x), "r"(y))
 169
 170 #define CC_LOAD64_BE(x, y)    \
 171 __asm__ __volatile__ (        \
 172 "movq (%1),%0\n\t"            \
 173 "bswapq %0\n\t"               \
 174 :"=r"(x): "r"(y))
 175
 176 #else
 177
 178 // MARK: --- default version
 179
 180 #define CC_STORE64_BE(x, y) do {                                    \
 181     ((unsigned char *)(y))[0] = (unsigned char)(((x)>>56)&255);         \
 182     ((unsigned char *)(y))[1] = (unsigned char)(((x)>>48)&255);         \
 183     ((unsigned char *)(y))[2] = (unsigned char)(((x)>>40)&255);         \
 184     ((unsigned char *)(y))[3] = (unsigned char)(((x)>>32)&255);         \
 185     ((unsigned char *)(y))[4] = (unsigned char)(((x)>>24)&255);         \
 186     ((unsigned char *)(y))[5] = (unsigned char)(((x)>>16)&255);         \
 187     ((unsigned char *)(y))[6] = (unsigned char)(((x)>>8)&255);          \
 188     ((unsigned char *)(y))[7] = (unsigned char)((x)&255);                       \
 189 } while(0)
 190
 191 #define CC_LOAD64_BE(x, y) do {                                     \
 192 x = (((uint64_t)(((unsigned char *)(y))[0] & 255))<<56) |           \
 193     (((uint64_t)(((unsigned char *)(y))[1] & 255))<<48) |           \
 194     (((uint64_t)(((unsigned char *)(y))[2] & 255))<<40) |           \
 195     (((uint64_t)(((unsigned char *)(y))[3] & 255))<<32) |           \
 196     (((uint64_t)(((unsigned char *)(y))[4] & 255))<<24) |           \
 197     (((uint64_t)(((unsigned char *)(y))[5] & 255))<<16) |           \
 198     (((uint64_t)(((unsigned char *)(y))[6] & 255))<<8)  |               \
 199     (((uint64_t)(((unsigned char *)(y))[7] & 255)));                \
 200 } while(0)
 201
 202 #endif
 203
 204 // MARK: - 32-bit Rotates
 205
 206 #if defined(_MSC_VER)
 207 // MARK: -- MSVC version
 208
 209 #include <stdlib.h>
 210 #pragma intrinsic(_lrotr,_lrotl)
 211 #define CC_ROR(x,n) _lrotr(x,n)
 212 #define CC_ROL(x,n) _lrotl(x,n)
 213 #define CC_RORc(x,n) _lrotr(x,n)
 214 #define CC_ROLc(x,n) _lrotl(x,n)
 215
 216 #elif (defined(__i386__) || defined(__x86_64__))
 217 // MARK: -- intel asm version
 218
 219 static inline uint32_t CC_ROL(uint32_t word, int i)
 220 {
 221     __asm__ ("roll %%cl,%0"
 222          :"=r" (word)
 223          :"0" (word),"c" (i));
 224     return word;
 225 }
 226
 227 static inline uint32_t CC_ROR(uint32_t word, int i)
 228 {
 229     __asm__ ("rorl %%cl,%0"
 230          :"=r" (word)
 231          :"0" (word),"c" (i));
 232     return word;
 233 }
 234
 235 /* Need to be a macro here, because 'i' is an immediate (constant) */
 236 #define CC_ROLc(word, i)                \
 237 ({  uint32_t _word=(word);              \
 238     __asm__ __volatile__ ("roll %2,%0"  \
 239         :"=r" (_word)                   \
 240         :"0" (_word),"I" (i));          \
 241     _word;                              \
 242 })
 243
 244
 245 #define CC_RORc(word, i)                \
 246 ({  uint32_t _word=(word);              \
 247     __asm__ __volatile__ ("rorl %2,%0"  \
 248         :"=r" (_word)                   \
 249         :"0" (_word),"I" (i));          \
 250     _word;                              \
 251 })
 252
 253 #else
 254
 255 // MARK: -- default version
 256
 257 static inline uint32_t CC_ROL(uint32_t word, int i)
 258 {
 259     return ( (word<<(i&31)) | (word>>(32-(i&31))) );
 260 }
 261
 262 static inline uint32_t CC_ROR(uint32_t word, int i)
 263 {
 264     return ( (word>>(i&31)) | (word<<(32-(i&31))) );
 265 }
 266
 267 #define CC_ROLc(x, y) CC_ROL(x, y)
 268 #define CC_RORc(x, y) CC_ROR(x, y)
 269
 270 #endif
 271
 272 // MARK: - 64 bits rotates
 273
 274 #if defined(__x86_64__)
 275 // MARK: -- intel 64 asm version
 276
 277 static inline uint64_t CC_ROL64(uint64_t word, int i)
 278 {
 279     __asm__("rolq %%cl,%0"
 280         :"=r" (word)
 281         :"0" (word),"c" (i));
 282     return word;
 283 }
 284
 285 static inline uint64_t CC_ROR64(uint64_t word, int i)
 286 {
 287     __asm__("rorq %%cl,%0"
 288         :"=r" (word)
 289         :"0" (word),"c" (i));
 290     return word;
 291 }
 292
 293 /* Need to be a macro here, because 'i' is an immediate (constant) */
 294 #define CC_ROL64c(word, i)      \
 295 ({                              \
 296     uint64_t _word=(word);      \
 297     __asm__("rolq %2,%0"        \
 298         :"=r" (_word)           \
 299         :"0" (_word),"J" (i));  \
 300     _word;                      \
 301 })
 302
 303 #define CC_ROR64c(word, i)      \
 304 ({                              \
 305     uint64_t _word=(word);      \
 306     __asm__("rorq %2,%0"        \
 307         :"=r" (_word)           \
 308         :"0" (_word),"J" (i));  \
 309     _word;                      \
 310 })
 311
 312
 313 #else /* Not x86_64  */
 314
 315 // MARK: -- default C version
 316
 317 static inline uint64_t CC_ROL64(uint64_t word, int i)
 318 {
 319     return ( (word<<(i&63)) | (word>>(64-(i&63))) );
 320 }
 321
 322 static inline uint64_t CC_ROR64(uint64_t word, int i)
 323 {
 324     return ( (word>>(i&63)) | (word<<(64-(i&63))) );
 325 }
 326
 327 #define CC_ROL64c(x, y) CC_ROL64(x, y)
 328 #define CC_ROR64c(x, y) CC_ROR64(x, y)
 329
 330 #endif
 331
 332
 333 // MARK: - Byte Swaps
 334
 335 static inline uint32_t CC_BSWAP(uint32_t x)
 336 {
 337     return (
 338         ((x>>24)&0x000000FF) |
 339         ((x<<24)&0xFF000000) |
 340         ((x>>8) &0x0000FF00) |
 341         ((x<<8) &0x00FF0000)
 342     );
 343 }
 344
 345 #define CC_BSWAP64(x) \
 346 ((uint64_t)((((uint64_t)(x) & 0xff00000000000000ULL) >> 56) | \
 347 (((uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \
 348 (((uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \
 349 (((uint64_t)(x) & 0x000000ff00000000ULL) >>  8) | \
 350 (((uint64_t)(x) & 0x00000000ff000000ULL) <<  8) | \
 351 (((uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \
 352 (((uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \
 353 (((uint64_t)(x) & 0x00000000000000ffULL) << 56)))
 354
 355 #ifdef __LITTLE_ENDIAN__
 356 #define CC_H2BE32(x) CC_BSWAP(x)
 357 #define CC_H2LE32(x) (x)
 358 #else
 359 #define CC_H2BE32(x) (x)
 360 #define CC_H2LE32(x) CC_BSWAP(x)
 361 #endif
 362
 363
 364 /* extract a byte portably */
 365 #ifdef _MSC_VER
 366 #define cc_byte(x, n) ((unsigned char)((x) >> (8 * (n))))
 367 #else
 368 #define cc_byte(x, n) (((x) >> (8 * (n))) & 255)
 369 #endif
 370
 371 /* HEAVISIDE_STEP (shifted by one)
 372    function f(x): x->0, when x=0
 373                   x->1, when x>0
 374    Can also be seen as a bitwise operation:
 375       f(x): x -> y
 376         y[0]=(OR x[i]) for all i (all bits)
 377         y[i]=0 for all i>0
 378    Run in constant time (log2(<bitsize of x>))
 379    Useful to run constant time checks
 380 */
 381 #define HEAVISIDE_STEP_UINT64(x) {unsigned long t; \
 382     t=(((uint64_t)x>>32) | (unsigned long)x); \
 383     t=((t>>16) | t); \
 384     t=((t>>8) | t); \
 385     t=((t>>4) | t); \
 386     t=((t>>2) | t); \
 387     t=((t>>1) | t); \
 388     x=t & 0x1;}
 389
 390 #define HEAVISIDE_STEP_UINT32(x) {uint16_t t; \
 391     t=(((unsigned long)x>>16) | (uint16_t)x); \
 392     t=((t>>8) | t); \
 393     t=((t>>4) | t); \
 394     t=((t>>2) | t); \
 395     t=((t>>1) | t); \
 396     x=t & 0x1;}
 397
 398 #define HEAVISIDE_STEP_UINT16(x) {uint8_t t; \
 399     t=(((uint16_t)x>>8) | (uint8_t)x); \
 400     t=((t>>4) | t); \
 401     t=((t>>2) | t); \
 402     t=((t>>1) | t); \
 403     x=t & 0x1;}
 404
 405 #define HEAVISIDE_STEP_UINT8(x) {uint8_t t; \
 406     t=(((uint8_t)x>>4) | (uint8_t)x); \
 407     t=((t>>2) | t); \
 408     t=((t>>1) | t); \
 409     x=t & 0x1;}
 410
 411 #define CC_HEAVISIDE_STEP(x) { \
 412     if (sizeof(x) == 1) {HEAVISIDE_STEP_UINT8(x);}  \
 413     else if (sizeof(x) == 2) {HEAVISIDE_STEP_UINT16(x);} \
 414     else if (sizeof(x) == 4) {HEAVISIDE_STEP_UINT32(x);} \
 415     else if (sizeof(x) == 8) {HEAVISIDE_STEP_UINT64(x);} \
 416     else {x=((x==0)?0:1);} \
 417     }
 418
 419
 420 /* Set a variable to the biggest power of 2 which can be represented */
 421 #define MAX_POWER_OF_2(x)   ((__typeof__(x))1<<(8*sizeof(x)-1))
 422
 423
 424 #endif /* _CORECRYPTO_CC_PRIV_H_ */