Add unit test for fdrm's MD5

core/fdrm/crypto/fx_crypt.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/fx_crypt.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ skipping 39 matching lines @@
   s->y = y;
 }
 void CRYPT_ArcFourCryptBlock(uint8_t* pData,
                              uint32_t size,
                              const uint8_t* key,
                              uint32_t keylen) {
   rc4_state s;
   CRYPT_ArcFourSetup(&s, key, keylen);
   CRYPT_ArcFourCrypt(&s, pData, size);
 }
-struct md5_context {
-  uint32_t total[2];
-  uint32_t state[4];
-  uint8_t buffer[64];
-};
 #define GET_UINT32(n, b, i)                            \
   {                                                    \
     (n) = (uint32_t)((uint8_t*)b)[(i)] |               \
           (((uint32_t)((uint8_t*)b)[(i) + 1]) << 8) |  \
           (((uint32_t)((uint8_t*)b)[(i) + 2]) << 16) | \
           (((uint32_t)((uint8_t*)b)[(i) + 3]) << 24);  \
   }
 #define PUT_UINT32(n, b, i)                                   \
   {                                                           \
     (((uint8_t*)b)[(i)]) = (uint8_t)(((n)) & 0xFF);           \
     (((uint8_t*)b)[(i) + 1]) = (uint8_t)(((n) >> 8) & 0xFF);  \
     (((uint8_t*)b)[(i) + 2]) = (uint8_t)(((n) >> 16) & 0xFF); \
     (((uint8_t*)b)[(i) + 3]) = (uint8_t)(((n) >> 24) & 0xFF); \
   }
-void md5_process(struct md5_context* ctx, const uint8_t data[64]) {
+void md5_process(struct CRYPT_md5_context* ctx, const uint8_t data[64]) {
   uint32_t A, B, C, D, X[16];
   GET_UINT32(X[0], data, 0);
   GET_UINT32(X[1], data, 4);
   GET_UINT32(X[2], data, 8);
   GET_UINT32(X[3], data, 12);
   GET_UINT32(X[4], data, 16);
   GET_UINT32(X[5], data, 20);
   GET_UINT32(X[6], data, 24);
   GET_UINT32(X[7], data, 28);
   GET_UINT32(X[8], data, 32);
@@ skipping 85 matching lines @@
   P(D, A, B, C, 11, 10, 0xBD3AF235);
   P(C, D, A, B, 2, 15, 0x2AD7D2BB);
   P(B, C, D, A, 9, 21, 0xEB86D391);
 #undef F
   ctx->state[0] += A;
   ctx->state[1] += B;
   ctx->state[2] += C;
   ctx->state[3] += D;
 }
 void CRYPT_MD5Start(void* context) {
-  struct md5_context* ctx = (struct md5_context*)context;
+  struct CRYPT_md5_context* ctx = (struct CRYPT_md5_context*)context;
   ctx->total[0] = 0;
   ctx->total[1] = 0;
   ctx->state[0] = 0x67452301;
   ctx->state[1] = 0xEFCDAB89;
   ctx->state[2] = 0x98BADCFE;
   ctx->state[3] = 0x10325476;
 }
 void CRYPT_MD5Update(void* pctx, const uint8_t* input, uint32_t length) {
-  struct md5_context* ctx = (struct md5_context*)pctx;
+  struct CRYPT_md5_context* ctx = (struct CRYPT_md5_context*)pctx;
   uint32_t left, fill;
   if (!length) {
     return;
   }
   left = (ctx->total[0] >> 3) & 0x3F;
   fill = 64 - left;
   ctx->total[0] += length << 3;
   ctx->total[1] += length >> 29;
   ctx->total[0] &= 0xFFFFFFFF;
   ctx->total[1] += ctx->total[0] < length << 3;
@@ skipping 11 matching lines @@
   }
   if (length) {
     FXSYS_memcpy((void*)(ctx->buffer + left), (void*)input, length);
   }
 }
 const uint8_t md5_padding[64] = {
     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_MD5Finish(void* pctx, uint8_t digest[16]) {
-  struct md5_context* ctx = (struct md5_context*)pctx;
+  struct CRYPT_md5_context* ctx = (struct CRYPT_md5_context*)pctx;
   uint32_t last, padn;
   uint8_t msglen[8];
   PUT_UINT32(ctx->total[0], msglen, 0);
   PUT_UINT32(ctx->total[1], msglen, 4);
   last = (ctx->total[0] >> 3) & 0x3F;
   padn = (last < 56) ? (56 - last) : (120 - last);
   CRYPT_MD5Update(ctx, md5_padding, padn);
   CRYPT_MD5Update(ctx, msglen, 8);
   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);
 }
 void CRYPT_MD5Generate(const uint8_t* input,
                        uint32_t length,
                        uint8_t digest[16]) {
-  md5_context ctx;
+  CRYPT_md5_context ctx;
   CRYPT_MD5Start(&ctx);
   CRYPT_MD5Update(&ctx, input, length);
   CRYPT_MD5Finish(&ctx, digest);
 }
 static bool (*g_PubKeyDecryptor)(const uint8_t* pData,
                                  uint32_t size,
                                  uint8_t* data_buf,
                                  uint32_t& data_len) = nullptr;
 void CRYPT_SetPubKeyDecryptor(bool (*func)(const uint8_t* pData,
                                            uint32_t size,
                                            uint8_t* data_buf,
                                            uint32_t& data_len)) {
   g_PubKeyDecryptor = func;
 }
 #ifdef __cplusplus
 };
 #endif