Fix declaration/definition parameter name mismatches.

Fix mismatches in core/fdrm.

PiperOrigin-RevId: 253078486
Change-Id: Ib5299f435abd9e264561c3df41060f6fa7770c62
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/56250
Reviewed-by: Lei Zhang <thestig@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>

core/fdrm/fx_crypt.cpp

diff --git a/core/fdrm/fx_crypt.cpp b/core/fdrm/fx_crypt.cpp
index e31bde9..2c3d379 100644
--- a/core/fdrm/fx_crypt.cpp
+++ b/core/fdrm/fx_crypt.cpp
@@ -138,27 +138,30 @@
 
 }  // namespace
 
-void CRYPT_ArcFourSetup(CRYPT_rc4_context* s,
+void CRYPT_ArcFourSetup(CRYPT_rc4_context* context,
                         const uint8_t* key,
-                        uint32_t length) {
-  s->x = 0;
-  s->y = 0;
+                        uint32_t size) {
+  context->x = 0;
+  context->y = 0;
   for (int i = 0; i < kRC4ContextPermutationLength; ++i)
-    s->m[i] = i;
+    context->m[i] = i;
 
   int j = 0;
   for (int i = 0; i < kRC4ContextPermutationLength; ++i) {
-    j = (j + s->m[i] + (length ? key[i % length] : 0)) & 0xFF;
-    std::swap(s->m[i], s->m[j]);
+    j = (j + context->m[i] + (size ? key[i % size] : 0)) & 0xFF;
+    std::swap(context->m[i], context->m[j]);
   }
 }
 
-void CRYPT_ArcFourCrypt(CRYPT_rc4_context* s, uint8_t* data, uint32_t length) {
-  for (uint32_t i = 0; i < length; ++i) {
-    s->x = (s->x + 1) & 0xFF;
-    s->y = (s->y + s->m[s->x]) & 0xFF;
-    std::swap(s->m[s->x], s->m[s->y]);
-    data[i] ^= s->m[(s->m[s->x] + s->m[s->y]) & 0xFF];
+void CRYPT_ArcFourCrypt(CRYPT_rc4_context* context,
+                        uint8_t* data,
+                        uint32_t size) {
+  for (uint32_t i = 0; i < size; ++i) {
+    context->x = (context->x + 1) & 0xFF;
+    context->y = (context->y + context->m[context->x]) & 0xFF;
+    std::swap(context->m[context->x], context->m[context->y]);
+    data[i] ^=
+        context->m[(context->m[context->x] + context->m[context->y]) & 0xFF];
   }
 }
 
@@ -171,65 +174,65 @@
   CRYPT_ArcFourCrypt(&s, pData, size);
 }
 
-void CRYPT_MD5Start(CRYPT_md5_context* ctx) {
-  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_MD5Start(CRYPT_md5_context* context) {
+  context->total[0] = 0;
+  context->total[1] = 0;
+  context->state[0] = 0x67452301;
+  context->state[1] = 0xEFCDAB89;
+  context->state[2] = 0x98BADCFE;
+  context->state[3] = 0x10325476;
 }
 
-void CRYPT_MD5Update(CRYPT_md5_context* ctx,
-                     const uint8_t* input,
-                     uint32_t length) {
+void CRYPT_MD5Update(CRYPT_md5_context* context,
+                     const uint8_t* data,
+                     uint32_t size) {
   uint32_t left, fill;
-  if (!length) {
+  if (!size) {
     return;
   }
-  left = (ctx->total[0] >> 3) & 0x3F;
+  left = (context->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;
-  if (left && length >= fill) {
-    memcpy(ctx->buffer + left, input, fill);
-    md5_process(ctx, ctx->buffer);
-    length -= fill;
-    input += fill;
+  context->total[0] += size << 3;
+  context->total[1] += size >> 29;
+  context->total[0] &= 0xFFFFFFFF;
+  context->total[1] += context->total[0] < size << 3;
+  if (left && size >= fill) {
+    memcpy(context->buffer + left, data, fill);
+    md5_process(context, context->buffer);
+    size -= fill;
+    data += fill;
     left = 0;
   }
-  while (length >= 64) {
-    md5_process(ctx, input);
-    length -= 64;
-    input += 64;
+  while (size >= 64) {
+    md5_process(context, data);
+    size -= 64;
+    data += 64;
   }
-  if (length) {
-    memcpy(ctx->buffer + left, input, length);
+  if (size) {
+    memcpy(context->buffer + left, data, size);
   }
 }
 
-void CRYPT_MD5Finish(CRYPT_md5_context* ctx, uint8_t digest[16]) {
+void CRYPT_MD5Finish(CRYPT_md5_context* context, uint8_t digest[16]) {
   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;
+  PUT_UINT32(context->total[0], msglen, 0);
+  PUT_UINT32(context->total[1], msglen, 4);
+  last = (context->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);
+  CRYPT_MD5Update(context, md5_padding, padn);
+  CRYPT_MD5Update(context, msglen, 8);
+  PUT_UINT32(context->state[0], digest, 0);
+  PUT_UINT32(context->state[1], digest, 4);
+  PUT_UINT32(context->state[2], digest, 8);
+  PUT_UINT32(context->state[3], digest, 12);
 }
 
-void CRYPT_MD5Generate(const uint8_t* input,
-                       uint32_t length,
+void CRYPT_MD5Generate(const uint8_t* data,
+                       uint32_t size,
                        uint8_t digest[16]) {
   CRYPT_md5_context ctx;
   CRYPT_MD5Start(&ctx);
-  CRYPT_MD5Update(&ctx, input, length);
+  CRYPT_MD5Update(&ctx, data, size);
   CRYPT_MD5Finish(&ctx, digest);
 }

core/fdrm/fx_crypt.h

diff --git a/core/fdrm/fx_crypt.h b/core/fdrm/fx_crypt.h
index 4e8a713..aab80df 100644
--- a/core/fdrm/fx_crypt.h
+++ b/core/fdrm/fx_crypt.h
@@ -54,7 +54,7 @@
                              uint32_t keylen);
 void CRYPT_ArcFourSetup(CRYPT_rc4_context* context,
                         const uint8_t* key,
-                        uint32_t length);
+                        uint32_t size);
 void CRYPT_ArcFourCrypt(CRYPT_rc4_context* context,
                         uint8_t* data,
                         uint32_t size);

core/fdrm/fx_crypt_sha.cpp

diff --git a/core/fdrm/fx_crypt_sha.cpp b/core/fdrm/fx_crypt_sha.cpp
index 573edb8..072b30d 100644
--- a/core/fdrm/fx_crypt_sha.cpp
+++ b/core/fdrm/fx_crypt_sha.cpp
@@ -361,13 +361,13 @@
 
 }  // namespace
 
-void CRYPT_SHA1Start(CRYPT_sha1_context* s) {
-  SHA_Core_Init(s->h);
-  s->blkused = 0;
-  s->lenhi = s->lenlo = 0;
+void CRYPT_SHA1Start(CRYPT_sha1_context* context) {
+  SHA_Core_Init(context->h);
+  context->blkused = 0;
+  context->lenhi = context->lenlo = 0;
 }
 
-void CRYPT_SHA1Update(CRYPT_sha1_context* s,
+void CRYPT_SHA1Update(CRYPT_sha1_context* context,
                       const uint8_t* data,
                       uint32_t size) {
   unsigned char* q = (unsigned char*)data;
@@ -375,45 +375,45 @@
   int len = size;
   unsigned int lenw = len;
   int i;
-  s->lenlo += lenw;
-  s->lenhi += (s->lenlo < lenw);
-  if (s->blkused && s->blkused + len < 64) {
-    memcpy(s->block + s->blkused, q, len);
-    s->blkused += len;
+  context->lenlo += lenw;
+  context->lenhi += (context->lenlo < lenw);
+  if (context->blkused && context->blkused + len < 64) {
+    memcpy(context->block + context->blkused, q, len);
+    context->blkused += len;
   } else {
-    while (s->blkused + len >= 64) {
-      memcpy(s->block + s->blkused, q, 64 - s->blkused);
-      q += 64 - s->blkused;
-      len -= 64 - s->blkused;
+    while (context->blkused + len >= 64) {
+      memcpy(context->block + context->blkused, q, 64 - context->blkused);
+      q += 64 - context->blkused;
+      len -= 64 - context->blkused;
       for (i = 0; i < 16; i++) {
-        wordblock[i] = (((unsigned int)s->block[i * 4 + 0]) << 24) |
-                       (((unsigned int)s->block[i * 4 + 1]) << 16) |
-                       (((unsigned int)s->block[i * 4 + 2]) << 8) |
-                       (((unsigned int)s->block[i * 4 + 3]) << 0);
+        wordblock[i] = (((unsigned int)context->block[i * 4 + 0]) << 24) |
+                       (((unsigned int)context->block[i * 4 + 1]) << 16) |
+                       (((unsigned int)context->block[i * 4 + 2]) << 8) |
+                       (((unsigned int)context->block[i * 4 + 3]) << 0);
       }
-      SHATransform(s->h, wordblock);
-      s->blkused = 0;
+      SHATransform(context->h, wordblock);
+      context->blkused = 0;
     }
-    memcpy(s->block, q, len);
-    s->blkused = len;
+    memcpy(context->block, q, len);
+    context->blkused = len;
   }
 }
 
-void CRYPT_SHA1Finish(CRYPT_sha1_context* s, uint8_t digest[20]) {
+void CRYPT_SHA1Finish(CRYPT_sha1_context* context, uint8_t digest[20]) {
   int i;
   int pad;
   unsigned char c[64];
   unsigned int lenhi, lenlo;
-  if (s->blkused >= 56) {
-    pad = 56 + 64 - s->blkused;
+  if (context->blkused >= 56) {
+    pad = 56 + 64 - context->blkused;
   } else {
-    pad = 56 - s->blkused;
+    pad = 56 - context->blkused;
   }
-  lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3));
-  lenlo = (s->lenlo << 3);
+  lenhi = (context->lenhi << 3) | (context->lenlo >> (32 - 3));
+  lenlo = (context->lenlo << 3);
   memset(c, 0, pad);
   c[0] = 0x80;
-  CRYPT_SHA1Update(s, c, pad);
+  CRYPT_SHA1Update(context, c, pad);
   c[0] = (lenhi >> 24) & 0xFF;
   c[1] = (lenhi >> 16) & 0xFF;
   c[2] = (lenhi >> 8) & 0xFF;
@@ -422,12 +422,12 @@
   c[5] = (lenlo >> 16) & 0xFF;
   c[6] = (lenlo >> 8) & 0xFF;
   c[7] = (lenlo >> 0) & 0xFF;
-  CRYPT_SHA1Update(s, c, 8);
+  CRYPT_SHA1Update(context, c, 8);
   for (i = 0; i < 5; i++) {
-    digest[i * 4] = (s->h[i] >> 24) & 0xFF;
-    digest[i * 4 + 1] = (s->h[i] >> 16) & 0xFF;
-    digest[i * 4 + 2] = (s->h[i] >> 8) & 0xFF;
-    digest[i * 4 + 3] = (s->h[i]) & 0xFF;
+    digest[i * 4] = (context->h[i] >> 24) & 0xFF;
+    digest[i * 4 + 1] = (context->h[i] >> 16) & 0xFF;
+    digest[i * 4 + 2] = (context->h[i] >> 8) & 0xFF;
+    digest[i * 4 + 3] = (context->h[i]) & 0xFF;
   }
 }
 void CRYPT_SHA1Generate(const uint8_t* data,
@@ -438,66 +438,66 @@
   CRYPT_SHA1Update(&s, data, size);
   CRYPT_SHA1Finish(&s, digest);
 }
-void CRYPT_SHA256Start(CRYPT_sha2_context* ctx) {
-  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;
+void CRYPT_SHA256Start(CRYPT_sha2_context* context) {
+  context->total[0] = 0;
+  context->total[1] = 0;
+  context->state[0] = 0x6A09E667;
+  context->state[1] = 0xBB67AE85;
+  context->state[2] = 0x3C6EF372;
+  context->state[3] = 0xA54FF53A;
+  context->state[4] = 0x510E527F;
+  context->state[5] = 0x9B05688C;
+  context->state[6] = 0x1F83D9AB;
+  context->state[7] = 0x5BE0CD19;
 }
 
-void CRYPT_SHA256Update(CRYPT_sha2_context* ctx,
-                        const uint8_t* input,
-                        uint32_t length) {
-  if (!length)
+void CRYPT_SHA256Update(CRYPT_sha2_context* context,
+                        const uint8_t* data,
+                        uint32_t size) {
+  if (!size)
     return;
 
-  uint32_t left = ctx->total[0] & 0x3F;
+  uint32_t left = context->total[0] & 0x3F;
   uint32_t fill = 64 - left;
-  ctx->total[0] += length;
-  ctx->total[0] &= 0xFFFFFFFF;
-  if (ctx->total[0] < length)
-    ctx->total[1]++;
+  context->total[0] += size;
+  context->total[0] &= 0xFFFFFFFF;
+  if (context->total[0] < size)
+    context->total[1]++;
 
-  if (left && length >= fill) {
-    memcpy(ctx->buffer + left, input, fill);
-    sha256_process(ctx, ctx->buffer);
-    length -= fill;
-    input += fill;
+  if (left && size >= fill) {
+    memcpy(context->buffer + left, data, fill);
+    sha256_process(context, context->buffer);
+    size -= fill;
+    data += fill;
     left = 0;
   }
-  while (length >= 64) {
-    sha256_process(ctx, input);
-    length -= 64;
-    input += 64;
+  while (size >= 64) {
+    sha256_process(context, data);
+    size -= 64;
+    data += 64;
   }
-  if (length)
-    memcpy(ctx->buffer + left, input, length);
+  if (size)
+    memcpy(context->buffer + left, data, size);
 }
 
-void CRYPT_SHA256Finish(CRYPT_sha2_context* ctx, uint8_t digest[32]) {
+void CRYPT_SHA256Finish(CRYPT_sha2_context* context, uint8_t digest[32]) {
   uint8_t msglen[8];
-  uint32_t high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
-  uint32_t low = (ctx->total[0] << 3);
+  uint32_t high = (context->total[0] >> 29) | (context->total[1] << 3);
+  uint32_t low = (context->total[0] << 3);
   SHA_PUT_UINT32(high, msglen, 0);
   SHA_PUT_UINT32(low, msglen, 4);
-  uint32_t last = ctx->total[0] & 0x3F;
+  uint32_t last = context->total[0] & 0x3F;
   uint32_t padn = (last < 56) ? (56 - last) : (120 - last);
-  CRYPT_SHA256Update(ctx, sha256_padding, padn);
-  CRYPT_SHA256Update(ctx, msglen, 8);
-  SHA_PUT_UINT32(ctx->state[0], digest, 0);
-  SHA_PUT_UINT32(ctx->state[1], digest, 4);
-  SHA_PUT_UINT32(ctx->state[2], digest, 8);
-  SHA_PUT_UINT32(ctx->state[3], digest, 12);
-  SHA_PUT_UINT32(ctx->state[4], digest, 16);
-  SHA_PUT_UINT32(ctx->state[5], digest, 20);
-  SHA_PUT_UINT32(ctx->state[6], digest, 24);
-  SHA_PUT_UINT32(ctx->state[7], digest, 28);
+  CRYPT_SHA256Update(context, sha256_padding, padn);
+  CRYPT_SHA256Update(context, msglen, 8);
+  SHA_PUT_UINT32(context->state[0], digest, 0);
+  SHA_PUT_UINT32(context->state[1], digest, 4);
+  SHA_PUT_UINT32(context->state[2], digest, 8);
+  SHA_PUT_UINT32(context->state[3], digest, 12);
+  SHA_PUT_UINT32(context->state[4], digest, 16);
+  SHA_PUT_UINT32(context->state[5], digest, 20);
+  SHA_PUT_UINT32(context->state[6], digest, 24);
+  SHA_PUT_UINT32(context->state[7], digest, 28);
 }
 
 void CRYPT_SHA256Generate(const uint8_t* data,
@@ -509,65 +509,65 @@
   CRYPT_SHA256Finish(&ctx, digest);
 }
 
-void CRYPT_SHA384Start(CRYPT_sha2_context* ctx) {
-  memset(ctx, 0, sizeof(CRYPT_sha2_context));
-  ctx->state[0] = 0xcbbb9d5dc1059ed8ULL;
-  ctx->state[1] = 0x629a292a367cd507ULL;
-  ctx->state[2] = 0x9159015a3070dd17ULL;
-  ctx->state[3] = 0x152fecd8f70e5939ULL;
-  ctx->state[4] = 0x67332667ffc00b31ULL;
-  ctx->state[5] = 0x8eb44a8768581511ULL;
-  ctx->state[6] = 0xdb0c2e0d64f98fa7ULL;
-  ctx->state[7] = 0x47b5481dbefa4fa4ULL;
+void CRYPT_SHA384Start(CRYPT_sha2_context* context) {
+  memset(context, 0, sizeof(CRYPT_sha2_context));
+  context->state[0] = 0xcbbb9d5dc1059ed8ULL;
+  context->state[1] = 0x629a292a367cd507ULL;
+  context->state[2] = 0x9159015a3070dd17ULL;
+  context->state[3] = 0x152fecd8f70e5939ULL;
+  context->state[4] = 0x67332667ffc00b31ULL;
+  context->state[5] = 0x8eb44a8768581511ULL;
+  context->state[6] = 0xdb0c2e0d64f98fa7ULL;
+  context->state[7] = 0x47b5481dbefa4fa4ULL;
 }
 
-void CRYPT_SHA384Update(CRYPT_sha2_context* ctx,
-                        const uint8_t* input,
-                        uint32_t length) {
-  if (!length)
+void CRYPT_SHA384Update(CRYPT_sha2_context* context,
+                        const uint8_t* data,
+                        uint32_t size) {
+  if (!size)
     return;
 
-  uint32_t left = static_cast<uint32_t>(ctx->total[0]) & 0x7F;
+  uint32_t left = static_cast<uint32_t>(context->total[0]) & 0x7F;
   uint32_t fill = 128 - left;
-  ctx->total[0] += length;
-  if (ctx->total[0] < length)
-    ctx->total[1]++;
+  context->total[0] += size;
+  if (context->total[0] < size)
+    context->total[1]++;
 
-  if (left && length >= fill) {
-    memcpy(ctx->buffer + left, input, fill);
-    sha384_process(ctx, ctx->buffer);
-    length -= fill;
-    input += fill;
+  if (left && size >= fill) {
+    memcpy(context->buffer + left, data, fill);
+    sha384_process(context, context->buffer);
+    size -= fill;
+    data += fill;
     left = 0;
   }
-  while (length >= 128) {
-    sha384_process(ctx, input);
-    length -= 128;
-    input += 128;
+  while (size >= 128) {
+    sha384_process(context, data);
+    size -= 128;
+    data += 128;
   }
-  if (length)
-    memcpy(ctx->buffer + left, input, length);
+  if (size)
+    memcpy(context->buffer + left, data, size);
 }
 
-void CRYPT_SHA384Finish(CRYPT_sha2_context* ctx, uint8_t digest[48]) {
+void CRYPT_SHA384Finish(CRYPT_sha2_context* context, uint8_t digest[48]) {
   uint32_t last, padn;
   uint8_t msglen[16];
   memset(msglen, 0, 16);
   uint64_t high, low;
-  high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
-  low = (ctx->total[0] << 3);
+  high = (context->total[0] >> 29) | (context->total[1] << 3);
+  low = (context->total[0] << 3);
   PUT_UINT64(high, msglen, 0);
   PUT_UINT64(low, msglen, 8);
-  last = (uint32_t)ctx->total[0] & 0x7F;
+  last = (uint32_t)context->total[0] & 0x7F;
   padn = (last < 112) ? (112 - last) : (240 - last);
-  CRYPT_SHA384Update(ctx, sha384_padding, padn);
-  CRYPT_SHA384Update(ctx, msglen, 16);
-  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);
+  CRYPT_SHA384Update(context, sha384_padding, padn);
+  CRYPT_SHA384Update(context, msglen, 16);
+  PUT_UINT64(context->state[0], digest, 0);
+  PUT_UINT64(context->state[1], digest, 8);
+  PUT_UINT64(context->state[2], digest, 16);
+  PUT_UINT64(context->state[3], digest, 24);
+  PUT_UINT64(context->state[4], digest, 32);
+  PUT_UINT64(context->state[5], digest, 40);
 }
 
 void CRYPT_SHA384Generate(const uint8_t* data,
@@ -579,45 +579,45 @@
   CRYPT_SHA384Finish(&context, digest);
 }
 
-void CRYPT_SHA512Start(CRYPT_sha2_context* ctx) {
-  memset(ctx, 0, sizeof(CRYPT_sha2_context));
-  ctx->state[0] = 0x6a09e667f3bcc908ULL;
-  ctx->state[1] = 0xbb67ae8584caa73bULL;
-  ctx->state[2] = 0x3c6ef372fe94f82bULL;
-  ctx->state[3] = 0xa54ff53a5f1d36f1ULL;
-  ctx->state[4] = 0x510e527fade682d1ULL;
-  ctx->state[5] = 0x9b05688c2b3e6c1fULL;
-  ctx->state[6] = 0x1f83d9abfb41bd6bULL;
-  ctx->state[7] = 0x5be0cd19137e2179ULL;
+void CRYPT_SHA512Start(CRYPT_sha2_context* context) {
+  memset(context, 0, sizeof(CRYPT_sha2_context));
+  context->state[0] = 0x6a09e667f3bcc908ULL;
+  context->state[1] = 0xbb67ae8584caa73bULL;
+  context->state[2] = 0x3c6ef372fe94f82bULL;
+  context->state[3] = 0xa54ff53a5f1d36f1ULL;
+  context->state[4] = 0x510e527fade682d1ULL;
+  context->state[5] = 0x9b05688c2b3e6c1fULL;
+  context->state[6] = 0x1f83d9abfb41bd6bULL;
+  context->state[7] = 0x5be0cd19137e2179ULL;
 }
 
-void CRYPT_SHA512Update(CRYPT_sha2_context* ctx,
+void CRYPT_SHA512Update(CRYPT_sha2_context* context,
                         const uint8_t* data,
                         uint32_t size) {
-  CRYPT_SHA384Update(ctx, data, size);
+  CRYPT_SHA384Update(context, data, size);
 }
 
-void CRYPT_SHA512Finish(CRYPT_sha2_context* ctx, uint8_t digest[64]) {
+void CRYPT_SHA512Finish(CRYPT_sha2_context* context, uint8_t digest[64]) {
   uint32_t last, padn;
   uint8_t msglen[16];
   memset(msglen, 0, 16);
   uint64_t high, low;
-  high = (ctx->total[0] >> 29) | (ctx->total[1] << 3);
-  low = (ctx->total[0] << 3);
+  high = (context->total[0] >> 29) | (context->total[1] << 3);
+  low = (context->total[0] << 3);
   PUT_UINT64(high, msglen, 0);
   PUT_UINT64(low, msglen, 8);
-  last = (uint32_t)ctx->total[0] & 0x7F;
+  last = (uint32_t)context->total[0] & 0x7F;
   padn = (last < 112) ? (112 - last) : (240 - last);
-  CRYPT_SHA512Update(ctx, sha384_padding, padn);
-  CRYPT_SHA512Update(ctx, msglen, 16);
-  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);
+  CRYPT_SHA512Update(context, sha384_padding, padn);
+  CRYPT_SHA512Update(context, msglen, 16);
+  PUT_UINT64(context->state[0], digest, 0);
+  PUT_UINT64(context->state[1], digest, 8);
+  PUT_UINT64(context->state[2], digest, 16);
+  PUT_UINT64(context->state[3], digest, 24);
+  PUT_UINT64(context->state[4], digest, 32);
+  PUT_UINT64(context->state[5], digest, 40);
+  PUT_UINT64(context->state[6], digest, 48);
+  PUT_UINT64(context->state[7], digest, 56);
 }
 
 void CRYPT_SHA512Generate(const uint8_t* data,