Rename FX_SAFE_DWORD to FX_SAFE_UINT32

core/fdrm/crypto/fx_crypt_sha.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fdrm/crypto/include/fx_crypt.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ skipping 141 matching lines @@
   SHA_State s;
   CRYPT_SHA1Start(&s);
   CRYPT_SHA1Update(&s, data, size);
   CRYPT_SHA1Finish(&s, digest);
 }
 typedef struct {
   uint32_t total[2];
   uint32_t state[8];
   uint8_t buffer[64];
 } sha256_context;
-#define GET_FX_DWORD(n, b, i)                                           \
+#define GET_UINT32(n, b, i)                                             \
   {                                                                     \
     (n) = ((uint32_t)(b)[(i)] << 24) | ((uint32_t)(b)[(i) + 1] << 16) | \
           ((uint32_t)(b)[(i) + 2] << 8) | ((uint32_t)(b)[(i) + 3]);     \
   }
-#define PUT_FX_DWORD(n, b, i)            \
+#define PUT_UINT32(n, b, i)              \
   {                                      \
     (b)[(i)] = (uint8_t)((n) >> 24);     \
     (b)[(i) + 1] = (uint8_t)((n) >> 16); \
     (b)[(i) + 2] = (uint8_t)((n) >> 8);  \
     (b)[(i) + 3] = (uint8_t)((n));       \
   }
 void CRYPT_SHA256Start(void* context) {
   sha256_context* ctx = (sha256_context*)context;
   ctx->total[0] = 0;
   ctx->total[1] = 0;
   ctx->state[0] = 0x6A09E667;
   ctx->state[1] = 0xBB67AE85;
   ctx->state[2] = 0x3C6EF372;
   ctx->state[3] = 0xA54FF53A;
   ctx->state[4] = 0x510E527F;
   ctx->state[5] = 0x9B05688C;
   ctx->state[6] = 0x1F83D9AB;
   ctx->state[7] = 0x5BE0CD19;
 }
 static void sha256_process(sha256_context* ctx, const uint8_t data[64]) {
   uint32_t temp1, temp2, W[64];
   uint32_t A, B, C, D, E, F, G, H;
-  GET_FX_DWORD(W[0], data, 0);
-  GET_FX_DWORD(W[1], data, 4);
-  GET_FX_DWORD(W[2], data, 8);
-  GET_FX_DWORD(W[3], data, 12);
-  GET_FX_DWORD(W[4], data, 16);
-  GET_FX_DWORD(W[5], data, 20);
-  GET_FX_DWORD(W[6], data, 24);
-  GET_FX_DWORD(W[7], data, 28);
-  GET_FX_DWORD(W[8], data, 32);
-  GET_FX_DWORD(W[9], data, 36);
-  GET_FX_DWORD(W[10], data, 40);
-  GET_FX_DWORD(W[11], data, 44);
-  GET_FX_DWORD(W[12], data, 48);
-  GET_FX_DWORD(W[13], data, 52);
-  GET_FX_DWORD(W[14], data, 56);
-  GET_FX_DWORD(W[15], data, 60);
+  GET_UINT32(W[0], data, 0);
+  GET_UINT32(W[1], data, 4);
+  GET_UINT32(W[2], data, 8);
+  GET_UINT32(W[3], data, 12);
+  GET_UINT32(W[4], data, 16);
+  GET_UINT32(W[5], data, 20);
+  GET_UINT32(W[6], data, 24);
+  GET_UINT32(W[7], data, 28);
+  GET_UINT32(W[8], data, 32);
+  GET_UINT32(W[9], data, 36);
+  GET_UINT32(W[10], data, 40);
+  GET_UINT32(W[11], data, 44);
+  GET_UINT32(W[12], data, 48);
+  GET_UINT32(W[13], data, 52);
+  GET_UINT32(W[14], data, 56);
+  GET_UINT32(W[15], data, 60);
 #define SHR(x, n) ((x & 0xFFFFFFFF) >> n)
 #define ROTR(x, n) (SHR(x, n) | (x << (32 - n)))
 #define S0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))
 #define S1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
 #define S2(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
 #define S3(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
 #define F0(x, y, z) ((x & y) | (z & (x | y)))
 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 #define R(t) (W[t] = S1(W[t - 2]) + W[t - 7] + S0(W[t - 15]) + W[t - 16])
 #define P(a, b, c, d, e, f, g, h, x, K)      \
@@ skipping 117 matching lines @@
     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 void CRYPT_SHA256Finish(void* context, uint8_t digest[32]) {
   sha256_context* ctx = (sha256_context*)context;
   uint32_t last, padn;
   uint32_t high, low;
   uint8_t msglen[8];
   high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
   low = (ctx->total[0] << 3);
-  PUT_FX_DWORD(high, msglen, 0);
-  PUT_FX_DWORD(low, msglen, 4);
+  PUT_UINT32(high, msglen, 0);
+  PUT_UINT32(low, msglen, 4);
   last = ctx->total[0] & 0x3F;
   padn = (last < 56) ? (56 - last) : (120 - last);
   CRYPT_SHA256Update(ctx, sha256_padding, padn);
   CRYPT_SHA256Update(ctx, msglen, 8);
-  PUT_FX_DWORD(ctx->state[0], digest, 0);
-  PUT_FX_DWORD(ctx->state[1], digest, 4);
-  PUT_FX_DWORD(ctx->state[2], digest, 8);
-  PUT_FX_DWORD(ctx->state[3], digest, 12);
-  PUT_FX_DWORD(ctx->state[4], digest, 16);
-  PUT_FX_DWORD(ctx->state[5], digest, 20);
-  PUT_FX_DWORD(ctx->state[6], digest, 24);
-  PUT_FX_DWORD(ctx->state[7], digest, 28);
+  PUT_UINT32(ctx->state[0], digest, 0);
+  PUT_UINT32(ctx->state[1], digest, 4);
+  PUT_UINT32(ctx->state[2], digest, 8);
+  PUT_UINT32(ctx->state[3], digest, 12);
+  PUT_UINT32(ctx->state[4], digest, 16);
+  PUT_UINT32(ctx->state[5], digest, 20);
+  PUT_UINT32(ctx->state[6], digest, 24);
+  PUT_UINT32(ctx->state[7], digest, 28);
 }
 void CRYPT_SHA256Generate(const uint8_t* data,
                           uint32_t size,
                           uint8_t digest[32]) {
   sha256_context ctx;
   CRYPT_SHA256Start(&ctx);
   CRYPT_SHA256Update(&ctx, data, size);
   CRYPT_SHA256Finish(&ctx, digest);
 }
 typedef struct {
@@ skipping 94 matching lines @@
     "431d67c49c100d4c", "4cc5d4becb3e42b6", "597f299cfc657e2a",
     "5fcb6fab3ad6faec", "6c44198c4a475817",
 };
 #define GET_FX_64WORD(n, b, i)                                              \
   {                                                                         \
     (n) = ((uint64_t)(b)[(i)] << 56) | ((uint64_t)(b)[(i) + 1] << 48) |     \
           ((uint64_t)(b)[(i) + 2] << 40) | ((uint64_t)(b)[(i) + 3] << 32) | \
           ((uint64_t)(b)[(i) + 4] << 24) | ((uint64_t)(b)[(i) + 5] << 16) | \
           ((uint64_t)(b)[(i) + 6] << 8) | ((uint64_t)(b)[(i) + 7]);         \
   }
-#define PUT_FX_64DWORD(n, b, i)          \
+#define PUT_UINT64(n, b, i)              \
   {                                      \
     (b)[(i)] = (uint8_t)((n) >> 56);     \
     (b)[(i) + 1] = (uint8_t)((n) >> 48); \
     (b)[(i) + 2] = (uint8_t)((n) >> 40); \
     (b)[(i) + 3] = (uint8_t)((n) >> 32); \
     (b)[(i) + 4] = (uint8_t)((n) >> 24); \
     (b)[(i) + 5] = (uint8_t)((n) >> 16); \
     (b)[(i) + 6] = (uint8_t)((n) >> 8);  \
     (b)[(i) + 7] = (uint8_t)((n));       \
   }
@@ skipping 93 matching lines @@
   }
 }
 void CRYPT_SHA384Finish(void* context, uint8_t digest[48]) {
   sha384_context* ctx = (sha384_context*)context;
   uint32_t last, padn;
   uint8_t msglen[16];
   FXSYS_memset(msglen, 0, 16);
   uint64_t high, low;
   high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
   low = (ctx->total[0] << 3);
-  PUT_FX_64DWORD(high, msglen, 0);
-  PUT_FX_64DWORD(low, msglen, 8);
+  PUT_UINT64(high, msglen, 0);
+  PUT_UINT64(low, msglen, 8);
   last = (uint32_t)ctx->total[0] & 0x7F;
   padn = (last < 112) ? (112 - last) : (240 - last);
   CRYPT_SHA384Update(ctx, sha384_padding, padn);
   CRYPT_SHA384Update(ctx, msglen, 16);
-  PUT_FX_64DWORD(ctx->state[0], digest, 0);
-  PUT_FX_64DWORD(ctx->state[1], digest, 8);
-  PUT_FX_64DWORD(ctx->state[2], digest, 16);
-  PUT_FX_64DWORD(ctx->state[3], digest, 24);
-  PUT_FX_64DWORD(ctx->state[4], digest, 32);
-  PUT_FX_64DWORD(ctx->state[5], digest, 40);
+  PUT_UINT64(ctx->state[0], digest, 0);
+  PUT_UINT64(ctx->state[1], digest, 8);
+  PUT_UINT64(ctx->state[2], digest, 16);
+  PUT_UINT64(ctx->state[3], digest, 24);
+  PUT_UINT64(ctx->state[4], digest, 32);
+  PUT_UINT64(ctx->state[5], digest, 40);
 }
 void CRYPT_SHA384Generate(const uint8_t* data,
                           uint32_t size,
                           uint8_t digest[64]) {
   sha384_context context;
   CRYPT_SHA384Start(&context);
   CRYPT_SHA384Update(&context, data, size);
   CRYPT_SHA384Finish(&context, digest);
 }
 void CRYPT_SHA512Start(void* context) {
@@ skipping 15 matching lines @@
   CRYPT_SHA384Update(context, data, size);
 }
 void CRYPT_SHA512Finish(void* context, uint8_t digest[64]) {
   sha384_context* ctx = (sha384_context*)context;
   uint32_t last, padn;
   uint8_t msglen[16];
   FXSYS_memset(msglen, 0, 16);
   uint64_t high, low;
   high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
   low = (ctx->total[0] << 3);
-  PUT_FX_64DWORD(high, msglen, 0);
-  PUT_FX_64DWORD(low, msglen, 8);
+  PUT_UINT64(high, msglen, 0);
+  PUT_UINT64(low, msglen, 8);
   last = (uint32_t)ctx->total[0] & 0x7F;
   padn = (last < 112) ? (112 - last) : (240 - last);
   CRYPT_SHA512Update(ctx, sha384_padding, padn);
   CRYPT_SHA512Update(ctx, msglen, 16);
-  PUT_FX_64DWORD(ctx->state[0], digest, 0);
-  PUT_FX_64DWORD(ctx->state[1], digest, 8);
-  PUT_FX_64DWORD(ctx->state[2], digest, 16);
-  PUT_FX_64DWORD(ctx->state[3], digest, 24);
-  PUT_FX_64DWORD(ctx->state[4], digest, 32);
-  PUT_FX_64DWORD(ctx->state[5], digest, 40);
-  PUT_FX_64DWORD(ctx->state[6], digest, 48);
-  PUT_FX_64DWORD(ctx->state[7], digest, 56);
+  PUT_UINT64(ctx->state[0], digest, 0);
+  PUT_UINT64(ctx->state[1], digest, 8);
+  PUT_UINT64(ctx->state[2], digest, 16);
+  PUT_UINT64(ctx->state[3], digest, 24);
+  PUT_UINT64(ctx->state[4], digest, 32);
+  PUT_UINT64(ctx->state[5], digest, 40);
+  PUT_UINT64(ctx->state[6], digest, 48);
+  PUT_UINT64(ctx->state[7], digest, 56);
 }
 void CRYPT_SHA512Generate(const uint8_t* data,
                           uint32_t size,
                           uint8_t digest[64]) {
   sha384_context context;
   CRYPT_SHA512Start(&context);
   CRYPT_SHA512Update(&context, data, size);
   CRYPT_SHA512Finish(&context, digest);
 }
 #ifdef __cplusplus
 };
 #endif