Fix up macros.
Macros need a healthy dose of parentheses to avoid expression-level misparses. Most of this comes from the clang-tidy CL here: https://android-review.googlesource.com/c/235696/ Also switch most of the macros to use do { ... } while (0) to avoid all the excessive comma operators and statement-level misparses. Change-Id: I4c2ee51e347d2aa8c74a2d82de63838b03bbb0f9 Reviewed-on: https://boringssl-review.googlesource.com/11660 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
This commit is contained in:
David Benjamin
Adam Langley
parent
840445d406
commit
b1133e9565
@ -70,7 +70,7 @@
|
||||
/* Utility functions for manipulating fields and offsets */
|
||||
|
||||
/* Add 'offset' to 'addr' */
|
||||
#define offset2ptr(addr, offset) (void *)(((char *) addr) + offset)
|
||||
#define offset2ptr(addr, offset) (void *)(((char *)(addr)) + (offset))
|
||||
|
||||
/* Given an ASN1_ITEM CHOICE type return the selector value */
|
||||
int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
|
||||
|
||||
@ -80,7 +80,7 @@
|
||||
: "+m"(r), "+d"(high) \
|
||||
: "r"(carry), "g"(0) \
|
||||
: "cc"); \
|
||||
carry = high; \
|
||||
(carry) = high; \
|
||||
} while (0)
|
||||
|
||||
#define mul(r, a, word, carry) \
|
||||
@ -91,7 +91,8 @@
|
||||
: "+r"(carry), "+d"(high) \
|
||||
: "a"(low), "g"(0) \
|
||||
: "cc"); \
|
||||
(r) = carry, carry = high; \
|
||||
(r) = (carry); \
|
||||
(carry) = high; \
|
||||
} while (0)
|
||||
#undef sqr
|
||||
#define sqr(r0, r1, a) asm("mulq %2" : "=a"(r0), "=d"(r1) : "a"(a) : "cc");
|
||||
@ -256,14 +257,14 @@ BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
|
||||
: "cc"); \
|
||||
} while (0)
|
||||
|
||||
#define sqr_add_c(a, i, c0, c1, c2) \
|
||||
do { \
|
||||
BN_ULONG t1, t2; \
|
||||
asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"(a[i]) : "cc"); \
|
||||
asm("addq %3,%0; adcq %4,%1; adcq %5,%2" \
|
||||
: "+r"(c0), "+r"(c1), "+r"(c2) \
|
||||
: "r"(t1), "r"(t2), "g"(0) \
|
||||
: "cc"); \
|
||||
#define sqr_add_c(a, i, c0, c1, c2) \
|
||||
do { \
|
||||
BN_ULONG t1, t2; \
|
||||
asm("mulq %2" : "=a"(t1), "=d"(t2) : "a"((a)[i]) : "cc"); \
|
||||
asm("addq %3,%0; adcq %4,%1; adcq %5,%2" \
|
||||
: "+r"(c0), "+r"(c1), "+r"(c2) \
|
||||
: "r"(t1), "r"(t2), "g"(0) \
|
||||
: "cc"); \
|
||||
} while (0)
|
||||
|
||||
#define mul_add_c2(a, b, c0, c1, c2) \
|
||||
|
||||
@ -67,34 +67,34 @@
|
||||
!(defined(OPENSSL_X86) || (defined(OPENSSL_X86_64) && defined(__GNUC__)))
|
||||
|
||||
#ifdef BN_ULLONG
|
||||
#define mul_add(r, a, w, c) \
|
||||
{ \
|
||||
BN_ULLONG t; \
|
||||
t = (BN_ULLONG)w * (a) + (r) + (c); \
|
||||
(r) = Lw(t); \
|
||||
(c) = Hw(t); \
|
||||
}
|
||||
#define mul_add(r, a, w, c) \
|
||||
do { \
|
||||
BN_ULLONG t; \
|
||||
t = (BN_ULLONG)(w) * (a) + (r) + (c); \
|
||||
(r) = Lw(t); \
|
||||
(c) = Hw(t); \
|
||||
} while (0)
|
||||
|
||||
#define mul(r, a, w, c) \
|
||||
{ \
|
||||
BN_ULLONG t; \
|
||||
t = (BN_ULLONG)w * (a) + (c); \
|
||||
(r) = Lw(t); \
|
||||
(c) = Hw(t); \
|
||||
}
|
||||
#define mul(r, a, w, c) \
|
||||
do { \
|
||||
BN_ULLONG t; \
|
||||
t = (BN_ULLONG)(w) * (a) + (c); \
|
||||
(r) = Lw(t); \
|
||||
(c) = Hw(t); \
|
||||
} while (0)
|
||||
|
||||
#define sqr(r0, r1, a) \
|
||||
{ \
|
||||
do { \
|
||||
BN_ULLONG t; \
|
||||
t = (BN_ULLONG)(a) * (a); \
|
||||
(r0) = Lw(t); \
|
||||
(r1) = Hw(t); \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#else
|
||||
|
||||
#define mul_add(r, a, w, c) \
|
||||
{ \
|
||||
do { \
|
||||
BN_ULONG high, low, ret, tmp = (a); \
|
||||
ret = (r); \
|
||||
BN_UMULT_LOHI(low, high, w, tmp); \
|
||||
@ -104,23 +104,23 @@
|
||||
ret += low; \
|
||||
(c) += (ret < low) ? 1 : 0; \
|
||||
(r) = ret; \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#define mul(r, a, w, c) \
|
||||
{ \
|
||||
do { \
|
||||
BN_ULONG high, low, ret, ta = (a); \
|
||||
BN_UMULT_LOHI(low, high, w, ta); \
|
||||
ret = low + (c); \
|
||||
(c) = high; \
|
||||
(c) += (ret < low) ? 1 : 0; \
|
||||
(r) = ret; \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#define sqr(r0, r1, a) \
|
||||
{ \
|
||||
do { \
|
||||
BN_ULONG tmp = (a); \
|
||||
BN_UMULT_LOHI(r0, r1, tmp, tmp); \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#endif /* !BN_ULLONG */
|
||||
|
||||
@ -369,42 +369,46 @@ BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b,
|
||||
do { \
|
||||
BN_ULONG hi; \
|
||||
BN_ULLONG t = (BN_ULLONG)(a) * (b); \
|
||||
t += c0; /* no carry */ \
|
||||
c0 = (BN_ULONG)Lw(t); \
|
||||
t += (c0); /* no carry */ \
|
||||
(c0) = (BN_ULONG)Lw(t); \
|
||||
hi = (BN_ULONG)Hw(t); \
|
||||
c1 = (c1 + hi) & BN_MASK2; \
|
||||
if (c1 < hi) \
|
||||
c2++; \
|
||||
(c1) = ((c1) + (hi)) & BN_MASK2; \
|
||||
if ((c1) < hi) { \
|
||||
(c2)++; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define mul_add_c2(a, b, c0, c1, c2) \
|
||||
do { \
|
||||
BN_ULONG hi; \
|
||||
BN_ULLONG t = (BN_ULLONG)(a) * (b); \
|
||||
BN_ULLONG tt = t + c0; /* no carry */ \
|
||||
c0 = (BN_ULONG)Lw(tt); \
|
||||
hi = (BN_ULONG)Hw(tt); \
|
||||
c1 = (c1 + hi) & BN_MASK2; \
|
||||
if (c1 < hi) \
|
||||
c2++; \
|
||||
t += c0; /* no carry */ \
|
||||
c0 = (BN_ULONG)Lw(t); \
|
||||
hi = (BN_ULONG)Hw(t); \
|
||||
c1 = (c1 + hi) & BN_MASK2; \
|
||||
if (c1 < hi) \
|
||||
c2++; \
|
||||
#define mul_add_c2(a, b, c0, c1, c2) \
|
||||
do { \
|
||||
BN_ULONG hi; \
|
||||
BN_ULLONG t = (BN_ULLONG)(a) * (b); \
|
||||
BN_ULLONG tt = t + (c0); /* no carry */ \
|
||||
(c0) = (BN_ULONG)Lw(tt); \
|
||||
hi = (BN_ULONG)Hw(tt); \
|
||||
(c1) = ((c1) + hi) & BN_MASK2; \
|
||||
if ((c1) < hi) { \
|
||||
(c2)++; \
|
||||
} \
|
||||
t += (c0); /* no carry */ \
|
||||
(c0) = (BN_ULONG)Lw(t); \
|
||||
hi = (BN_ULONG)Hw(t); \
|
||||
(c1) = ((c1) + hi) & BN_MASK2; \
|
||||
if ((c1) < hi) { \
|
||||
(c2)++; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define sqr_add_c(a, i, c0, c1, c2) \
|
||||
do { \
|
||||
BN_ULONG hi; \
|
||||
BN_ULLONG t = (BN_ULLONG)a[i] * a[i]; \
|
||||
t += c0; /* no carry */ \
|
||||
c0 = (BN_ULONG)Lw(t); \
|
||||
hi = (BN_ULONG)Hw(t); \
|
||||
c1 = (c1 + hi) & BN_MASK2; \
|
||||
if (c1 < hi) \
|
||||
c2++; \
|
||||
#define sqr_add_c(a, i, c0, c1, c2) \
|
||||
do { \
|
||||
BN_ULONG hi; \
|
||||
BN_ULLONG t = (BN_ULLONG)(a)[i] * (a)[i]; \
|
||||
t += (c0); /* no carry */ \
|
||||
(c0) = (BN_ULONG)Lw(t); \
|
||||
hi = (BN_ULONG)Hw(t); \
|
||||
(c1) = ((c1) + hi) & BN_MASK2; \
|
||||
if ((c1) < hi) { \
|
||||
(c2)++; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define sqr_add_c2(a, i, j, c0, c1, c2) mul_add_c2((a)[i], (a)[j], c0, c1, c2)
|
||||
@ -418,10 +422,10 @@ BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b,
|
||||
BN_ULONG ta = (a), tb = (b); \
|
||||
BN_ULONG lo, hi; \
|
||||
BN_UMULT_LOHI(lo, hi, ta, tb); \
|
||||
c0 += lo; \
|
||||
hi += (c0 < lo) ? 1 : 0; \
|
||||
c1 += hi; \
|
||||
c2 += (c1 < hi) ? 1 : 0; \
|
||||
(c0) += lo; \
|
||||
hi += ((c0) < lo) ? 1 : 0; \
|
||||
(c1) += hi; \
|
||||
(c2) += ((c1) < hi) ? 1 : 0; \
|
||||
} while (0)
|
||||
|
||||
#define mul_add_c2(a, b, c0, c1, c2) \
|
||||
@ -429,14 +433,14 @@ BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b,
|
||||
BN_ULONG ta = (a), tb = (b); \
|
||||
BN_ULONG lo, hi, tt; \
|
||||
BN_UMULT_LOHI(lo, hi, ta, tb); \
|
||||
c0 += lo; \
|
||||
tt = hi + ((c0 < lo) ? 1 : 0); \
|
||||
c1 += tt; \
|
||||
c2 += (c1 < tt) ? 1 : 0; \
|
||||
c0 += lo; \
|
||||
(c0) += lo; \
|
||||
tt = hi + (((c0) < lo) ? 1 : 0); \
|
||||
(c1) += tt; \
|
||||
(c2) += ((c1) < tt) ? 1 : 0; \
|
||||
(c0) += lo; \
|
||||
hi += (c0 < lo) ? 1 : 0; \
|
||||
c1 += hi; \
|
||||
c2 += (c1 < hi) ? 1 : 0; \
|
||||
(c1) += hi; \
|
||||
(c2) += ((c1) < hi) ? 1 : 0; \
|
||||
} while (0)
|
||||
|
||||
#define sqr_add_c(a, i, c0, c1, c2) \
|
||||
@ -444,10 +448,10 @@ BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b,
|
||||
BN_ULONG ta = (a)[i]; \
|
||||
BN_ULONG lo, hi; \
|
||||
BN_UMULT_LOHI(lo, hi, ta, ta); \
|
||||
c0 += lo; \
|
||||
(c0) += lo; \
|
||||
hi += (c0 < lo) ? 1 : 0; \
|
||||
c1 += hi; \
|
||||
c2 += (c1 < hi) ? 1 : 0; \
|
||||
(c1) += hi; \
|
||||
(c2) += ((c1) < hi) ? 1 : 0; \
|
||||
} while (0)
|
||||
|
||||
#define sqr_add_c2(a, i, j, c0, c1, c2) mul_add_c2((a)[i], (a)[j], c0, c1, c2)
|
||||
|
||||
@ -188,10 +188,10 @@ BIGNUM *bn_expand(BIGNUM *bn, size_t bits);
|
||||
#endif
|
||||
|
||||
|
||||
#define STATIC_BIGNUM(x) \
|
||||
{ \
|
||||
(BN_ULONG *)x, sizeof(x) / sizeof(BN_ULONG), \
|
||||
sizeof(x) / sizeof(BN_ULONG), 0, BN_FLG_STATIC_DATA \
|
||||
#define STATIC_BIGNUM(x) \
|
||||
{ \
|
||||
(BN_ULONG *)(x), sizeof(x) / sizeof(BN_ULONG), \
|
||||
sizeof(x) / sizeof(BN_ULONG), 0, BN_FLG_STATIC_DATA \
|
||||
}
|
||||
|
||||
#if defined(BN_ULLONG)
|
||||
|
||||
@ -60,63 +60,68 @@
|
||||
#include "internal.h"
|
||||
|
||||
|
||||
#define c2l(c, l) \
|
||||
(l = ((uint32_t)(*((c)++))), l |= ((uint32_t)(*((c)++))) << 8L, \
|
||||
l |= ((uint32_t)(*((c)++))) << 16L, \
|
||||
l |= ((uint32_t)(*((c)++))) << 24L)
|
||||
#define c2l(c, l) \
|
||||
do { \
|
||||
(l) = ((uint32_t)(*((c)++))); \
|
||||
(l) |= ((uint32_t)(*((c)++))) << 8L; \
|
||||
(l) |= ((uint32_t)(*((c)++))) << 16L; \
|
||||
(l) |= ((uint32_t)(*((c)++))) << 24L; \
|
||||
} while (0)
|
||||
|
||||
#define c2ln(c, l1, l2, n) \
|
||||
{ \
|
||||
c += n; \
|
||||
l1 = l2 = 0; \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
l2 = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 7: \
|
||||
l2 |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 6: \
|
||||
l2 |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 5: \
|
||||
l2 |= ((uint32_t)(*(--(c)))); \
|
||||
case 4: \
|
||||
l1 = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 3: \
|
||||
l1 |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 2: \
|
||||
l1 |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 1: \
|
||||
l1 |= ((uint32_t)(*(--(c)))); \
|
||||
} \
|
||||
}
|
||||
#define c2ln(c, l1, l2, n) \
|
||||
do { \
|
||||
(c) += (n); \
|
||||
(l1) = (l2) = 0; \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
(l2) = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 7: \
|
||||
(l2) |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 6: \
|
||||
(l2) |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 5: \
|
||||
(l2) |= ((uint32_t)(*(--(c)))); \
|
||||
case 4: \
|
||||
(l1) = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 3: \
|
||||
(l1) |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 2: \
|
||||
(l1) |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 1: \
|
||||
(l1) |= ((uint32_t)(*(--(c)))); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define l2c(l, c) \
|
||||
(*((c)++) = (uint8_t)(((l)) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 8L) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 16L) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 24L) & 0xff))
|
||||
#define l2c(l, c) \
|
||||
do { \
|
||||
*((c)++) = (uint8_t)(((l)) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 8L) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 16L) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 24L) & 0xff); \
|
||||
} while (0)
|
||||
|
||||
#define l2cn(l1, l2, c, n) \
|
||||
{ \
|
||||
c += n; \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
#define l2cn(l1, l2, c, n) \
|
||||
do { \
|
||||
(c) += (n); \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
*(--(c)) = (uint8_t)(((l2) >> 24L) & 0xff); \
|
||||
case 7: \
|
||||
case 7: \
|
||||
*(--(c)) = (uint8_t)(((l2) >> 16L) & 0xff); \
|
||||
case 6: \
|
||||
case 6: \
|
||||
*(--(c)) = (uint8_t)(((l2) >> 8L) & 0xff); \
|
||||
case 5: \
|
||||
case 5: \
|
||||
*(--(c)) = (uint8_t)(((l2)) & 0xff); \
|
||||
case 4: \
|
||||
case 4: \
|
||||
*(--(c)) = (uint8_t)(((l1) >> 24L) & 0xff); \
|
||||
case 3: \
|
||||
case 3: \
|
||||
*(--(c)) = (uint8_t)(((l1) >> 16L) & 0xff); \
|
||||
case 2: \
|
||||
case 2: \
|
||||
*(--(c)) = (uint8_t)(((l1) >> 8L) & 0xff); \
|
||||
case 1: \
|
||||
case 1: \
|
||||
*(--(c)) = (uint8_t)(((l1)) & 0xff); \
|
||||
} \
|
||||
}
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
typedef struct rc2_key_st { uint16_t data[64]; } RC2_KEY;
|
||||
|
||||
|
||||
@ -264,23 +264,27 @@ void EVP_tls_cbc_copy_mac(uint8_t *out, unsigned md_size,
|
||||
|
||||
/* u32toBE serialises an unsigned, 32-bit number (n) as four bytes at (p) in
|
||||
* big-endian order. The value of p is advanced by four. */
|
||||
#define u32toBE(n, p) \
|
||||
(*((p)++)=(uint8_t)(n>>24), \
|
||||
*((p)++)=(uint8_t)(n>>16), \
|
||||
*((p)++)=(uint8_t)(n>>8), \
|
||||
*((p)++)=(uint8_t)(n))
|
||||
#define u32toBE(n, p) \
|
||||
do { \
|
||||
*((p)++) = (uint8_t)((n) >> 24); \
|
||||
*((p)++) = (uint8_t)((n) >> 16); \
|
||||
*((p)++) = (uint8_t)((n) >> 8); \
|
||||
*((p)++) = (uint8_t)((n)); \
|
||||
} while (0)
|
||||
|
||||
/* u64toBE serialises an unsigned, 64-bit number (n) as eight bytes at (p) in
|
||||
* big-endian order. The value of p is advanced by eight. */
|
||||
#define u64toBE(n, p) \
|
||||
(*((p)++)=(uint8_t)(n>>56), \
|
||||
*((p)++)=(uint8_t)(n>>48), \
|
||||
*((p)++)=(uint8_t)(n>>40), \
|
||||
*((p)++)=(uint8_t)(n>>32), \
|
||||
*((p)++)=(uint8_t)(n>>24), \
|
||||
*((p)++)=(uint8_t)(n>>16), \
|
||||
*((p)++)=(uint8_t)(n>>8), \
|
||||
*((p)++)=(uint8_t)(n))
|
||||
#define u64toBE(n, p) \
|
||||
do { \
|
||||
*((p)++) = (uint8_t)((n) >> 56); \
|
||||
*((p)++) = (uint8_t)((n) >> 48); \
|
||||
*((p)++) = (uint8_t)((n) >> 40); \
|
||||
*((p)++) = (uint8_t)((n) >> 32); \
|
||||
*((p)++) = (uint8_t)((n) >> 24); \
|
||||
*((p)++) = (uint8_t)((n) >> 16); \
|
||||
*((p)++) = (uint8_t)((n) >> 8); \
|
||||
*((p)++) = (uint8_t)((n)); \
|
||||
} while (0)
|
||||
|
||||
/* These functions serialize the state of a hash and thus perform the standard
|
||||
* "final" operation without adding the padding and length that such a function
|
||||
|
||||
@ -291,7 +291,7 @@ static const uint32_t DES_SPtrans[8][64] = {
|
||||
|
||||
#define HPERM_OP(a, t, n, m) \
|
||||
((t) = ((((a) << (16 - (n))) ^ (a)) & (m)), \
|
||||
(a) = (a) ^ (t) ^ (t >> (16 - (n))))
|
||||
(a) = (a) ^ (t) ^ ((t) >> (16 - (n))))
|
||||
|
||||
void DES_set_key(const DES_cblock *key, DES_key_schedule *schedule) {
|
||||
static const int shifts2[16] = {0, 0, 1, 1, 1, 1, 1, 1,
|
||||
|
||||
@ -64,45 +64,51 @@ extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#define c2l(c, l) \
|
||||
(l = ((uint32_t)(*((c)++))), l |= ((uint32_t)(*((c)++))) << 8L, \
|
||||
l |= ((uint32_t)(*((c)++))) << 16L, l |= ((uint32_t)(*((c)++))) << 24L)
|
||||
#define c2l(c, l) \
|
||||
do { \
|
||||
(l) = ((uint32_t)(*((c)++))); \
|
||||
(l) |= ((uint32_t)(*((c)++))) << 8L; \
|
||||
(l) |= ((uint32_t)(*((c)++))) << 16L; \
|
||||
(l) |= ((uint32_t)(*((c)++))) << 24L; \
|
||||
} while (0)
|
||||
|
||||
#define l2c(l, c) \
|
||||
(*((c)++) = (unsigned char)(((l)) & 0xff), \
|
||||
*((c)++) = (unsigned char)(((l) >> 8L) & 0xff), \
|
||||
*((c)++) = (unsigned char)(((l) >> 16L) & 0xff), \
|
||||
*((c)++) = (unsigned char)(((l) >> 24L) & 0xff))
|
||||
#define l2c(l, c) \
|
||||
do { \
|
||||
*((c)++) = (unsigned char)(((l)) & 0xff); \
|
||||
*((c)++) = (unsigned char)(((l) >> 8L) & 0xff); \
|
||||
*((c)++) = (unsigned char)(((l) >> 16L) & 0xff); \
|
||||
*((c)++) = (unsigned char)(((l) >> 24L) & 0xff); \
|
||||
} while (0)
|
||||
|
||||
/* NOTE - c is not incremented as per c2l */
|
||||
#define c2ln(c, l1, l2, n) \
|
||||
{ \
|
||||
c += n; \
|
||||
l1 = l2 = 0; \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
l2 = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 7: \
|
||||
l2 |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 6: \
|
||||
l2 |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 5: \
|
||||
l2 |= ((uint32_t)(*(--(c)))); \
|
||||
case 4: \
|
||||
l1 = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 3: \
|
||||
l1 |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 2: \
|
||||
l1 |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 1: \
|
||||
l1 |= ((uint32_t)(*(--(c)))); \
|
||||
} \
|
||||
}
|
||||
#define c2ln(c, l1, l2, n) \
|
||||
do { \
|
||||
(c) += (n); \
|
||||
(l1) = (l2) = 0; \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
(l2) = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 7: \
|
||||
(l2) |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 6: \
|
||||
(l2) |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 5: \
|
||||
(l2) |= ((uint32_t)(*(--(c)))); \
|
||||
case 4: \
|
||||
(l1) = ((uint32_t)(*(--(c)))) << 24L; \
|
||||
case 3: \
|
||||
(l1) |= ((uint32_t)(*(--(c)))) << 16L; \
|
||||
case 2: \
|
||||
(l1) |= ((uint32_t)(*(--(c)))) << 8L; \
|
||||
case 1: \
|
||||
(l1) |= ((uint32_t)(*(--(c)))); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* NOTE - c is not incremented as per l2c */
|
||||
#define l2cn(l1, l2, c, n) \
|
||||
{ \
|
||||
c += n; \
|
||||
do { \
|
||||
(c) += (n); \
|
||||
switch (n) { \
|
||||
case 8: \
|
||||
*(--(c)) = (unsigned char)(((l2) >> 24L) & 0xff); \
|
||||
@ -121,7 +127,7 @@ extern "C" {
|
||||
case 1: \
|
||||
*(--(c)) = (unsigned char)(((l1)) & 0xff); \
|
||||
} \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
/* IP and FP
|
||||
* The problem is more of a geometric problem that random bit fiddling.
|
||||
@ -160,44 +166,50 @@ When I finally started to think of the problem in 2D
|
||||
I first got ~42 operations without xors. When I remembered
|
||||
how to use xors :-) I got it to its final state.
|
||||
*/
|
||||
#define PERM_OP(a, b, t, n, m) \
|
||||
((t) = ((((a) >> (n)) ^ (b)) & (m)), (b) ^= (t), (a) ^= ((t) << (n)))
|
||||
#define PERM_OP(a, b, t, n, m) \
|
||||
do { \
|
||||
(t) = ((((a) >> (n)) ^ (b)) & (m)); \
|
||||
(b) ^= (t); \
|
||||
(a) ^= ((t) << (n)); \
|
||||
} while (0)
|
||||
|
||||
#define IP(l, r) \
|
||||
{ \
|
||||
do { \
|
||||
uint32_t tt; \
|
||||
PERM_OP(r, l, tt, 4, 0x0f0f0f0fL); \
|
||||
PERM_OP(l, r, tt, 16, 0x0000ffffL); \
|
||||
PERM_OP(r, l, tt, 2, 0x33333333L); \
|
||||
PERM_OP(l, r, tt, 8, 0x00ff00ffL); \
|
||||
PERM_OP(r, l, tt, 1, 0x55555555L); \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#define FP(l, r) \
|
||||
{ \
|
||||
do { \
|
||||
uint32_t tt; \
|
||||
PERM_OP(l, r, tt, 1, 0x55555555L); \
|
||||
PERM_OP(r, l, tt, 8, 0x00ff00ffL); \
|
||||
PERM_OP(l, r, tt, 2, 0x33333333L); \
|
||||
PERM_OP(r, l, tt, 16, 0x0000ffffL); \
|
||||
PERM_OP(l, r, tt, 4, 0x0f0f0f0fL); \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#define LOAD_DATA(ks, R, S, u, t, E0, E1) \
|
||||
u = R ^ ks->subkeys[S][0]; \
|
||||
t = R ^ ks->subkeys[S][1]
|
||||
do { \
|
||||
(u) = (R) ^ (ks)->subkeys[S][0]; \
|
||||
(t) = (R) ^ (ks)->subkeys[S][1]; \
|
||||
} while (0)
|
||||
|
||||
#define D_ENCRYPT(ks, LL, R, S) \
|
||||
{ \
|
||||
do { \
|
||||
LOAD_DATA(ks, R, S, u, t, E0, E1); \
|
||||
t = ROTATE(t, 4); \
|
||||
LL ^= \
|
||||
(LL) ^= \
|
||||
DES_SPtrans[0][(u >> 2L) & 0x3f] ^ DES_SPtrans[2][(u >> 10L) & 0x3f] ^ \
|
||||
DES_SPtrans[4][(u >> 18L) & 0x3f] ^ \
|
||||
DES_SPtrans[6][(u >> 26L) & 0x3f] ^ DES_SPtrans[1][(t >> 2L) & 0x3f] ^ \
|
||||
DES_SPtrans[3][(t >> 10L) & 0x3f] ^ \
|
||||
DES_SPtrans[5][(t >> 18L) & 0x3f] ^ DES_SPtrans[7][(t >> 26L) & 0x3f]; \
|
||||
}
|
||||
} while (0)
|
||||
|
||||
#define ITERATIONS 16
|
||||
#define HALF_ITERATIONS 8
|
||||
|
||||
@ -140,29 +140,39 @@ extern "C" {
|
||||
|
||||
#if defined(DATA_ORDER_IS_BIG_ENDIAN)
|
||||
|
||||
#define HOST_c2l(c, l) \
|
||||
(void)(l = (((uint32_t)(*((c)++))) << 24), \
|
||||
l |= (((uint32_t)(*((c)++))) << 16), \
|
||||
l |= (((uint32_t)(*((c)++))) << 8), l |= (((uint32_t)(*((c)++)))))
|
||||
#define HOST_c2l(c, l) \
|
||||
do { \
|
||||
(l) = (((uint32_t)(*((c)++))) << 24); \
|
||||
(l) |= (((uint32_t)(*((c)++))) << 16); \
|
||||
(l) |= (((uint32_t)(*((c)++))) << 8); \
|
||||
(l) |= (((uint32_t)(*((c)++)))); \
|
||||
} while (0)
|
||||
|
||||
#define HOST_l2c(l, c) \
|
||||
(void)(*((c)++) = (uint8_t)(((l) >> 24) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 16) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 8) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l)) & 0xff))
|
||||
#define HOST_l2c(l, c) \
|
||||
do { \
|
||||
*((c)++) = (uint8_t)(((l) >> 24) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 16) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 8) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l)) & 0xff); \
|
||||
} while (0)
|
||||
|
||||
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
|
||||
|
||||
#define HOST_c2l(c, l) \
|
||||
(void)(l = (((uint32_t)(*((c)++)))), l |= (((uint32_t)(*((c)++))) << 8), \
|
||||
l |= (((uint32_t)(*((c)++))) << 16), \
|
||||
l |= (((uint32_t)(*((c)++))) << 24))
|
||||
#define HOST_c2l(c, l) \
|
||||
do { \
|
||||
(l) = (((uint32_t)(*((c)++)))); \
|
||||
(l) |= (((uint32_t)(*((c)++))) << 8); \
|
||||
(l) |= (((uint32_t)(*((c)++))) << 16); \
|
||||
(l) |= (((uint32_t)(*((c)++))) << 24); \
|
||||
} while (0)
|
||||
|
||||
#define HOST_l2c(l, c) \
|
||||
(void)(*((c)++) = (uint8_t)(((l)) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 8) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 16) & 0xff), \
|
||||
*((c)++) = (uint8_t)(((l) >> 24) & 0xff))
|
||||
#define HOST_l2c(l, c) \
|
||||
do { \
|
||||
*((c)++) = (uint8_t)(((l)) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 8) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 16) & 0xff); \
|
||||
*((c)++) = (uint8_t)(((l) >> 24) & 0xff); \
|
||||
} while (0)
|
||||
|
||||
#endif /* DATA_ORDER */
|
||||
|
||||
|
||||
@ -175,9 +175,9 @@ static void longfelem_scalar(longfelem out, const u64 scalar) {
|
||||
out[7] *= scalar;
|
||||
}
|
||||
|
||||
#define two105m41m9 (((limb)1) << 105) - (((limb)1) << 41) - (((limb)1) << 9)
|
||||
#define two105m41m9 ((((limb)1) << 105) - (((limb)1) << 41) - (((limb)1) << 9))
|
||||
#define two105 (((limb)1) << 105)
|
||||
#define two105m41p9 (((limb)1) << 105) - (((limb)1) << 41) + (((limb)1) << 9)
|
||||
#define two105m41p9 ((((limb)1) << 105) - (((limb)1) << 41) + (((limb)1) << 9))
|
||||
|
||||
/* zero105 is 0 mod p */
|
||||
static const felem zero105 = {two105m41m9, two105, two105m41p9, two105m41p9};
|
||||
@ -211,9 +211,11 @@ static void felem_diff(felem out, const felem in) {
|
||||
out[3] -= in[3];
|
||||
}
|
||||
|
||||
#define two107m43m11 (((limb)1) << 107) - (((limb)1) << 43) - (((limb)1) << 11)
|
||||
#define two107m43m11 \
|
||||
((((limb)1) << 107) - (((limb)1) << 43) - (((limb)1) << 11))
|
||||
#define two107 (((limb)1) << 107)
|
||||
#define two107m43p11 (((limb)1) << 107) - (((limb)1) << 43) + (((limb)1) << 11)
|
||||
#define two107m43p11 \
|
||||
((((limb)1) << 107) - (((limb)1) << 43) + (((limb)1) << 11))
|
||||
|
||||
/* zero107 is 0 mod p */
|
||||
static const felem zero107 = {two107m43m11, two107, two107m43p11, two107m43p11};
|
||||
@ -272,10 +274,10 @@ static void longfelem_diff(longfelem out, const longfelem in) {
|
||||
out[7] -= in[7];
|
||||
}
|
||||
|
||||
#define two64m0 (((limb)1) << 64) - 1
|
||||
#define two110p32m0 (((limb)1) << 110) + (((limb)1) << 32) - 1
|
||||
#define two64m46 (((limb)1) << 64) - (((limb)1) << 46)
|
||||
#define two64m32 (((limb)1) << 64) - (((limb)1) << 32)
|
||||
#define two64m0 ((((limb)1) << 64) - 1)
|
||||
#define two110p32m0 ((((limb)1) << 110) + (((limb)1) << 32) - 1)
|
||||
#define two64m46 ((((limb)1) << 64) - (((limb)1) << 46))
|
||||
#define two64m32 ((((limb)1) << 64) - (((limb)1) << 32))
|
||||
|
||||
/* zero110 is 0 mod p. */
|
||||
static const felem zero110 = {two64m0, two110p32m0, two64m46, two64m32};
|
||||
@ -594,9 +596,9 @@ static void felem_small_mul(longfelem out, const smallfelem small1,
|
||||
smallfelem_mul(out, small1, small2);
|
||||
}
|
||||
|
||||
#define two100m36m4 (((limb)1) << 100) - (((limb)1) << 36) - (((limb)1) << 4)
|
||||
#define two100m36m4 ((((limb)1) << 100) - (((limb)1) << 36) - (((limb)1) << 4))
|
||||
#define two100 (((limb)1) << 100)
|
||||
#define two100m36p4 (((limb)1) << 100) - (((limb)1) << 36) + (((limb)1) << 4)
|
||||
#define two100m36p4 ((((limb)1) << 100) - (((limb)1) << 36) + (((limb)1) << 4))
|
||||
|
||||
/* zero100 is 0 mod p */
|
||||
static const felem zero100 = {two100m36m4, two100, two100m36p4, two100m36p4};
|
||||
|
||||
@ -114,23 +114,23 @@ void md4_block_data_order(uint32_t *state, const uint8_t *data, size_t num);
|
||||
|
||||
#define ROTATE(a, n) (((a) << (n)) | ((a) >> (32 - (n))))
|
||||
|
||||
#define R0(a, b, c, d, k, s, t) \
|
||||
{ \
|
||||
a += ((k) + (t)+F((b), (c), (d))); \
|
||||
a = ROTATE(a, s); \
|
||||
};
|
||||
#define R0(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + F((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
} while (0)
|
||||
|
||||
#define R1(a, b, c, d, k, s, t) \
|
||||
{ \
|
||||
a += ((k) + (t)+G((b), (c), (d))); \
|
||||
a = ROTATE(a, s); \
|
||||
};
|
||||
#define R1(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + G((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
} while (0)
|
||||
|
||||
#define R2(a, b, c, d, k, s, t) \
|
||||
{ \
|
||||
a += ((k) + (t)+H((b), (c), (d))); \
|
||||
a = ROTATE(a, s); \
|
||||
};
|
||||
#define R2(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + H((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
} while (0)
|
||||
|
||||
void md4_block_data_order(uint32_t *state, const uint8_t *data, size_t num) {
|
||||
uint32_t A, B, C, D, l;
|
||||
|
||||
@ -122,32 +122,40 @@ void md5_block_data_order(uint32_t *state, const uint8_t *data, size_t num);
|
||||
* simplified to the code below. Wei attributes these optimizations
|
||||
* to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
|
||||
*/
|
||||
#define F(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
|
||||
#define G(b,c,d) ((((b) ^ (c)) & (d)) ^ (c))
|
||||
#define H(b,c,d) ((b) ^ (c) ^ (d))
|
||||
#define I(b,c,d) (((~(d)) | (b)) ^ (c))
|
||||
#define F(b, c, d) ((((c) ^ (d)) & (b)) ^ (d))
|
||||
#define G(b, c, d) ((((b) ^ (c)) & (d)) ^ (c))
|
||||
#define H(b, c, d) ((b) ^ (c) ^ (d))
|
||||
#define I(b, c, d) (((~(d)) | (b)) ^ (c))
|
||||
|
||||
#define ROTATE(a, n) (((a) << (n)) | ((a) >> (32 - (n))))
|
||||
|
||||
#define R0(a,b,c,d,k,s,t) { \
|
||||
a+=((k)+(t)+F((b),(c),(d))); \
|
||||
a=ROTATE(a,s); \
|
||||
a+=b; };\
|
||||
#define R0(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + F((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
(a) += (b); \
|
||||
} while (0)
|
||||
|
||||
#define R1(a,b,c,d,k,s,t) { \
|
||||
a+=((k)+(t)+G((b),(c),(d))); \
|
||||
a=ROTATE(a,s); \
|
||||
a+=b; };
|
||||
#define R1(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + G((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
(a) += (b); \
|
||||
} while (0)
|
||||
|
||||
#define R2(a,b,c,d,k,s,t) { \
|
||||
a+=((k)+(t)+H((b),(c),(d))); \
|
||||
a=ROTATE(a,s); \
|
||||
a+=b; };
|
||||
#define R2(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + H((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
(a) += (b); \
|
||||
} while (0)
|
||||
|
||||
#define R3(a,b,c,d,k,s,t) { \
|
||||
a+=((k)+(t)+I((b),(c),(d))); \
|
||||
a=ROTATE(a,s); \
|
||||
a+=b; };
|
||||
#define R3(a, b, c, d, k, s, t) \
|
||||
do { \
|
||||
(a) += ((k) + (t) + I((b), (c), (d))); \
|
||||
(a) = ROTATE(a, s); \
|
||||
(a) += (b); \
|
||||
} while (0)
|
||||
|
||||
#ifndef md5_block_data_order
|
||||
#ifdef X
|
||||
|
||||
@ -74,17 +74,17 @@
|
||||
#endif
|
||||
|
||||
#define PACK(s) ((size_t)(s) << (sizeof(size_t) * 8 - 16))
|
||||
#define REDUCE1BIT(V) \
|
||||
do { \
|
||||
if (sizeof(size_t) == 8) { \
|
||||
uint64_t T = UINT64_C(0xe100000000000000) & (0 - (V.lo & 1)); \
|
||||
V.lo = (V.hi << 63) | (V.lo >> 1); \
|
||||
V.hi = (V.hi >> 1) ^ T; \
|
||||
} else { \
|
||||
uint32_t T = 0xe1000000U & (0 - (uint32_t)(V.lo & 1)); \
|
||||
V.lo = (V.hi << 63) | (V.lo >> 1); \
|
||||
V.hi = (V.hi >> 1) ^ ((uint64_t)T << 32); \
|
||||
} \
|
||||
#define REDUCE1BIT(V) \
|
||||
do { \
|
||||
if (sizeof(size_t) == 8) { \
|
||||
uint64_t T = UINT64_C(0xe100000000000000) & (0 - ((V).lo & 1)); \
|
||||
(V).lo = ((V).hi << 63) | ((V).lo >> 1); \
|
||||
(V).hi = ((V).hi >> 1) ^ T; \
|
||||
} else { \
|
||||
uint32_t T = 0xe1000000U & (0 - (uint32_t)((V).lo & 1)); \
|
||||
(V).lo = ((V).hi << 63) | ((V).lo >> 1); \
|
||||
(V).hi = ((V).hi >> 1) ^ ((uint64_t)T << 32); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// kSizeTWithoutLower4Bits is a mask that can be used to zero the lower four
|
||||
@ -313,7 +313,7 @@ void gcm_ghash_4bit(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
|
||||
size_t len);
|
||||
#endif
|
||||
|
||||
#define GCM_MUL(ctx, Xi) gcm_gmult_4bit(ctx->Xi.u, ctx->Htable)
|
||||
#define GCM_MUL(ctx, Xi) gcm_gmult_4bit((ctx)->Xi.u, (ctx)->Htable)
|
||||
#if defined(GHASH_ASM)
|
||||
#define GHASH(ctx, in, len) gcm_ghash_4bit((ctx)->Xi.u, (ctx)->Htable, in, len)
|
||||
/* GHASH_CHUNK is "stride parameter" missioned to mitigate cache
|
||||
@ -418,10 +418,10 @@ void gcm_ghash_p8(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
|
||||
|
||||
#ifdef GCM_FUNCREF_4BIT
|
||||
#undef GCM_MUL
|
||||
#define GCM_MUL(ctx, Xi) (*gcm_gmult_p)(ctx->Xi.u, ctx->Htable)
|
||||
#define GCM_MUL(ctx, Xi) (*gcm_gmult_p)((ctx)->Xi.u, (ctx)->Htable)
|
||||
#ifdef GHASH
|
||||
#undef GHASH
|
||||
#define GHASH(ctx, in, len) (*gcm_ghash_p)(ctx->Xi.u, ctx->Htable, in, len)
|
||||
#define GHASH(ctx, in, len) (*gcm_ghash_p)((ctx)->Xi.u, (ctx)->Htable, in, len)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
@ -119,7 +119,10 @@ uint8_t *SHA1(const uint8_t *data, size_t len, uint8_t *out) {
|
||||
#define HASH_BLOCK_DATA_ORDER sha1_block_data_order
|
||||
#define ROTATE(a, n) (((a) << (n)) | ((a) >> (32 - (n))))
|
||||
#define Xupdate(a, ix, ia, ib, ic, id) \
|
||||
((a) = (ia ^ ib ^ ic ^ id), ix = (a) = ROTATE((a), 1))
|
||||
do { \
|
||||
(a) = ((ia) ^ (ib) ^ (ic) ^ (id)); \
|
||||
(ix) = (a) = ROTATE((a), 1); \
|
||||
} while (0)
|
||||
|
||||
#ifndef SHA1_ASM
|
||||
static
|
||||
@ -143,34 +146,46 @@ void sha1_block_data_order(uint32_t *state, const uint8_t *data, size_t num);
|
||||
#define F_40_59(b, c, d) (((b) & (c)) | (((b) | (c)) & (d)))
|
||||
#define F_60_79(b, c, d) F_20_39(b, c, d)
|
||||
|
||||
#define BODY_00_15(i, a, b, c, d, e, f, xi) \
|
||||
(f) = xi + (e) + K_00_19 + ROTATE((a), 5) + F_00_19((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30);
|
||||
#define BODY_00_15(i, a, b, c, d, e, f, xi) \
|
||||
do { \
|
||||
(f) = (xi) + (e) + K_00_19 + ROTATE((a), 5) + F_00_19((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30); \
|
||||
} while (0)
|
||||
|
||||
#define BODY_16_19(i, a, b, c, d, e, f, xi, xa, xb, xc, xd) \
|
||||
Xupdate(f, xi, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_00_19 + ROTATE((a), 5) + F_00_19((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30);
|
||||
#define BODY_16_19(i, a, b, c, d, e, f, xi, xa, xb, xc, xd) \
|
||||
do { \
|
||||
Xupdate(f, xi, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_00_19 + ROTATE((a), 5) + F_00_19((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30); \
|
||||
} while (0)
|
||||
|
||||
#define BODY_20_31(i, a, b, c, d, e, f, xi, xa, xb, xc, xd) \
|
||||
Xupdate(f, xi, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_20_39 + ROTATE((a), 5) + F_20_39((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30);
|
||||
#define BODY_20_31(i, a, b, c, d, e, f, xi, xa, xb, xc, xd) \
|
||||
do { \
|
||||
Xupdate(f, xi, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_20_39 + ROTATE((a), 5) + F_20_39((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30); \
|
||||
} while (0)
|
||||
|
||||
#define BODY_32_39(i, a, b, c, d, e, f, xa, xb, xc, xd) \
|
||||
Xupdate(f, xa, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_20_39 + ROTATE((a), 5) + F_20_39((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30);
|
||||
#define BODY_32_39(i, a, b, c, d, e, f, xa, xb, xc, xd) \
|
||||
do { \
|
||||
Xupdate(f, xa, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_20_39 + ROTATE((a), 5) + F_20_39((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30); \
|
||||
} while (0)
|
||||
|
||||
#define BODY_40_59(i, a, b, c, d, e, f, xa, xb, xc, xd) \
|
||||
Xupdate(f, xa, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_40_59 + ROTATE((a), 5) + F_40_59((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30);
|
||||
#define BODY_40_59(i, a, b, c, d, e, f, xa, xb, xc, xd) \
|
||||
do { \
|
||||
Xupdate(f, xa, xa, xb, xc, xd); \
|
||||
(f) += (e) + K_40_59 + ROTATE((a), 5) + F_40_59((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30); \
|
||||
} while (0)
|
||||
|
||||
#define BODY_60_79(i, a, b, c, d, e, f, xa, xb, xc, xd) \
|
||||
Xupdate(f, xa, xa, xb, xc, xd); \
|
||||
(f) = xa + (e) + K_60_79 + ROTATE((a), 5) + F_60_79((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30);
|
||||
#define BODY_60_79(i, a, b, c, d, e, f, xa, xb, xc, xd) \
|
||||
do { \
|
||||
Xupdate(f, xa, xa, xb, xc, xd); \
|
||||
(f) = (xa) + (e) + K_60_79 + ROTATE((a), 5) + F_60_79((b), (c), (d)); \
|
||||
(b) = ROTATE((b), 30); \
|
||||
} while (0)
|
||||
|
||||
#ifdef X
|
||||
#undef X
|
||||
@ -199,51 +214,51 @@ static void sha1_block_data_order(uint32_t *state, const uint8_t *data,
|
||||
E = state[4];
|
||||
|
||||
for (;;) {
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(0) = l;
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(1) = l;
|
||||
BODY_00_15(0, A, B, C, D, E, T, X(0));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(2) = l;
|
||||
BODY_00_15(1, T, A, B, C, D, E, X(1));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(3) = l;
|
||||
BODY_00_15(2, E, T, A, B, C, D, X(2));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(4) = l;
|
||||
BODY_00_15(3, D, E, T, A, B, C, X(3));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(5) = l;
|
||||
BODY_00_15(4, C, D, E, T, A, B, X(4));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(6) = l;
|
||||
BODY_00_15(5, B, C, D, E, T, A, X(5));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(7) = l;
|
||||
BODY_00_15(6, A, B, C, D, E, T, X(6));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(8) = l;
|
||||
BODY_00_15(7, T, A, B, C, D, E, X(7));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(9) = l;
|
||||
BODY_00_15(8, E, T, A, B, C, D, X(8));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(10) = l;
|
||||
BODY_00_15(9, D, E, T, A, B, C, X(9));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(11) = l;
|
||||
BODY_00_15(10, C, D, E, T, A, B, X(10));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(12) = l;
|
||||
BODY_00_15(11, B, C, D, E, T, A, X(11));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(13) = l;
|
||||
BODY_00_15(12, A, B, C, D, E, T, X(12));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(14) = l;
|
||||
BODY_00_15(13, T, A, B, C, D, E, X(13));
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(15) = l;
|
||||
BODY_00_15(14, E, T, A, B, C, D, X(14));
|
||||
BODY_00_15(15, D, E, T, A, B, C, X(15));
|
||||
|
||||
@ -227,8 +227,8 @@ void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
|
||||
/* Macro to test if a field should be copied from src to dest */
|
||||
|
||||
#define test_x509_verify_param_copy(field, def) \
|
||||
(to_overwrite || \
|
||||
((src->field != def) && (to_default || (dest->field == def))))
|
||||
(to_overwrite || \
|
||||
((src->field != (def)) && (to_default || (dest->field == (def)))))
|
||||
|
||||
/* As above but for ID fields */
|
||||
|
||||
@ -513,7 +513,7 @@ const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param)
|
||||
static const X509_VERIFY_PARAM_ID _empty_id =
|
||||
{ NULL, 0U, NULL, NULL, 0, NULL, 0 };
|
||||
|
||||
#define vpm_empty_id (X509_VERIFY_PARAM_ID *)&_empty_id
|
||||
#define vpm_empty_id ((X509_VERIFY_PARAM_ID *)&_empty_id)
|
||||
|
||||
/*
|
||||
* Default verify parameters: these are used for various applications and can
|
||||
|
||||
@ -180,8 +180,8 @@ struct X509_POLICY_TREE_st {
|
||||
|
||||
/* Useful macros */
|
||||
|
||||
#define node_data_critical(data) (data->flags & POLICY_DATA_FLAG_CRITICAL)
|
||||
#define node_critical(node) node_data_critical(node->data)
|
||||
#define node_data_critical(data) ((data)->flags & POLICY_DATA_FLAG_CRITICAL)
|
||||
#define node_critical(node) node_data_critical((node)->data)
|
||||
|
||||
/* Internal functions */
|
||||
|
||||
|
||||
@ -647,7 +647,7 @@ static int check_purpose_ssl_client(const X509_PURPOSE *xp, const X509 *x,
|
||||
* key types.
|
||||
*/
|
||||
#define KU_TLS \
|
||||
KU_DIGITAL_SIGNATURE|KU_KEY_ENCIPHERMENT|KU_KEY_AGREEMENT
|
||||
(KU_DIGITAL_SIGNATURE|KU_KEY_ENCIPHERMENT|KU_KEY_AGREEMENT)
|
||||
|
||||
static int check_purpose_ssl_server(const X509_PURPOSE *xp, const X509 *x,
|
||||
int ca)
|
||||
|
||||
@ -79,15 +79,15 @@ static void ripemd160_block_data_order(uint32_t h[5], const uint8_t *data,
|
||||
do { \
|
||||
unsigned long ll; \
|
||||
ll = (c)->h[0]; \
|
||||
(void)HOST_l2c(ll, (s)); \
|
||||
HOST_l2c(ll, (s)); \
|
||||
ll = (c)->h[1]; \
|
||||
(void)HOST_l2c(ll, (s)); \
|
||||
HOST_l2c(ll, (s)); \
|
||||
ll = (c)->h[2]; \
|
||||
(void)HOST_l2c(ll, (s)); \
|
||||
HOST_l2c(ll, (s)); \
|
||||
ll = (c)->h[3]; \
|
||||
(void)HOST_l2c(ll, (s)); \
|
||||
HOST_l2c(ll, (s)); \
|
||||
ll = (c)->h[4]; \
|
||||
(void)HOST_l2c(ll, (s)); \
|
||||
HOST_l2c(ll, (s)); \
|
||||
} while (0)
|
||||
#define HASH_BLOCK_DATA_ORDER ripemd160_block_data_order
|
||||
|
||||
|
||||
@ -86,51 +86,51 @@ static void ripemd160_block_data_order(uint32_t h[5], const uint8_t *data,
|
||||
D = h[3];
|
||||
E = h[4];
|
||||
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(0) = l;
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(1) = l;
|
||||
RIP1(A, B, C, D, E, WL00, SL00);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(2) = l;
|
||||
RIP1(E, A, B, C, D, WL01, SL01);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(3) = l;
|
||||
RIP1(D, E, A, B, C, WL02, SL02);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(4) = l;
|
||||
RIP1(C, D, E, A, B, WL03, SL03);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(5) = l;
|
||||
RIP1(B, C, D, E, A, WL04, SL04);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(6) = l;
|
||||
RIP1(A, B, C, D, E, WL05, SL05);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(7) = l;
|
||||
RIP1(E, A, B, C, D, WL06, SL06);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(8) = l;
|
||||
RIP1(D, E, A, B, C, WL07, SL07);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(9) = l;
|
||||
RIP1(C, D, E, A, B, WL08, SL08);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(10) = l;
|
||||
RIP1(B, C, D, E, A, WL09, SL09);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(11) = l;
|
||||
RIP1(A, B, C, D, E, WL10, SL10);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(12) = l;
|
||||
RIP1(E, A, B, C, D, WL11, SL11);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(13) = l;
|
||||
RIP1(D, E, A, B, C, WL12, SL12);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(14) = l;
|
||||
RIP1(C, D, E, A, B, WL13, SL13);
|
||||
(void)HOST_c2l(data, l);
|
||||
HOST_c2l(data, l);
|
||||
X(15) = l;
|
||||
RIP1(B, C, D, E, A, WL14, SL14);
|
||||
RIP1(A, B, C, D, E, WL15, SL15);
|
||||
|
||||
@ -467,7 +467,7 @@ enum {
|
||||
#define ERR_R_OVERFLOW (5 | ERR_R_FATAL)
|
||||
|
||||
#define ERR_PACK(lib, reason) \
|
||||
(((((uint32_t)lib) & 0xff) << 24) | ((((uint32_t)reason) & 0xfff)))
|
||||
(((((uint32_t)(lib)) & 0xff) << 24) | ((((uint32_t)(reason)) & 0xfff)))
|
||||
|
||||
#define ERR_GET_LIB(packed_error) ((int)(((packed_error) >> 24) & 0xff))
|
||||
#define ERR_GET_FUNC(packed_error) 0
|
||||
|
||||
@ -2898,7 +2898,7 @@ OPENSSL_EXPORT int SSL_total_renegotiations(const SSL *ssl);
|
||||
|
||||
/* SSL_MAX_CERT_LIST_DEFAULT is the default maximum length, in bytes, of a peer
|
||||
* certificate chain. */
|
||||
#define SSL_MAX_CERT_LIST_DEFAULT 1024 * 100
|
||||
#define SSL_MAX_CERT_LIST_DEFAULT (1024 * 100)
|
||||
|
||||
/* SSL_CTX_get_max_cert_list returns the maximum length, in bytes, of a peer
|
||||
* certificate chain accepted by |ctx|. */
|
||||
@ -3343,14 +3343,14 @@ OPENSSL_EXPORT const COMP_METHOD *SSL_get_current_expansion(SSL *s);
|
||||
/* SSL_get_server_tmp_key returns zero. */
|
||||
OPENSSL_EXPORT int *SSL_get_server_tmp_key(SSL *ssl, EVP_PKEY **out_key);
|
||||
|
||||
#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg))
|
||||
#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)(arg)))
|
||||
#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
|
||||
#define SSL_SESSION_set_app_data(s, a) \
|
||||
(SSL_SESSION_set_ex_data(s, 0, (char *)a))
|
||||
(SSL_SESSION_set_ex_data(s, 0, (char *)(a)))
|
||||
#define SSL_SESSION_get_app_data(s) (SSL_SESSION_get_ex_data(s, 0))
|
||||
#define SSL_CTX_get_app_data(ctx) (SSL_CTX_get_ex_data(ctx, 0))
|
||||
#define SSL_CTX_set_app_data(ctx, arg) \
|
||||
(SSL_CTX_set_ex_data(ctx, 0, (char *)arg))
|
||||
(SSL_CTX_set_ex_data(ctx, 0, (char *)(arg)))
|
||||
|
||||
#define OpenSSL_add_ssl_algorithms() SSL_library_init()
|
||||
#define SSLeay_add_ssl_algorithms() SSL_library_init()
|
||||
|
||||
@ -286,7 +286,7 @@ struct x509_cert_pair_st {
|
||||
|
||||
/* standard trust ids */
|
||||
|
||||
#define X509_TRUST_DEFAULT -1 /* Only valid in purpose settings */
|
||||
#define X509_TRUST_DEFAULT (-1) /* Only valid in purpose settings */
|
||||
|
||||
#define X509_TRUST_COMPAT 1
|
||||
#define X509_TRUST_SSL_CLIENT 2
|
||||
|
||||
@ -110,7 +110,7 @@ certificate chain.
|
||||
*/
|
||||
|
||||
/* The following are legacy constants that should not be used. */
|
||||
#define X509_LU_RETRY -1
|
||||
#define X509_LU_RETRY (-1)
|
||||
#define X509_LU_FAIL 0
|
||||
|
||||
#define X509_LU_X509 1
|
||||
|
||||
@ -230,7 +230,7 @@ X509_NAME *dpname;
|
||||
/* All existing reasons */
|
||||
#define CRLDP_ALL_REASONS 0x807f
|
||||
|
||||
#define CRL_REASON_NONE -1
|
||||
#define CRL_REASON_NONE (-1)
|
||||
#define CRL_REASON_UNSPECIFIED 0
|
||||
#define CRL_REASON_KEY_COMPROMISE 1
|
||||
#define CRL_REASON_CA_COMPROMISE 2
|
||||
@ -376,8 +376,8 @@ struct ISSUING_DIST_POINT_st
|
||||
/* onlysomereasons present */
|
||||
#define IDP_REASONS 0x40
|
||||
|
||||
#define X509V3_conf_err(val) ERR_add_error_data(6, "section:", val->section, \
|
||||
",name:", val->name, ",value:", val->value);
|
||||
#define X509V3_conf_err(val) ERR_add_error_data(6, "section:", (val)->section, \
|
||||
",name:", (val)->name, ",value:", (val)->value);
|
||||
|
||||
#define X509V3_set_ctx_test(ctx) \
|
||||
X509V3_set_ctx(ctx, NULL, NULL, NULL, NULL, CTX_TEST)
|
||||
@ -389,7 +389,7 @@ struct ISSUING_DIST_POINT_st
|
||||
(X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \
|
||||
(X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \
|
||||
NULL, NULL, \
|
||||
(void *)table}
|
||||
(void *)(table)}
|
||||
|
||||
#define EXT_IA5STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING), \
|
||||
0,0,0,0, \
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user