MD5: Use C-cast style in MD5Update() function.

base/md5.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The original file was copied from sqlite, and was in the public domain.
 
 /*
  * This code implements the MD5 message-digest algorithm.
  * The algorithm is due to Ron Rivest.  This code was
  * written by Colin Plumb in 1993, no copyright is claimed.
@@ skipping 21 matching lines @@
   uint32_t bits[2];
   uint8_t in[64];
 };
 
 /*
  * Note: this code is harmless on little-endian machines.
  */
 void byteReverse(uint8_t* buf, unsigned longs) {
   uint32_t t;
   do {
-    t = (uint32_t)((unsigned)buf[3] << 8 | buf[2]) << 16 |
-        ((unsigned)buf[1] << 8 | buf[0]);
-    *(uint32_t*)buf = t;
+    t = static_cast<uint32_t>(static_cast<unsigned>(buf[3]) << 8 | buf[2])

[Lei Zhang, 2015/04/23 03:06:01]

This is a bit hairy. How about indenting it like this?

uint32_t temp = static_cast<uint32_t>(
    static_cast<unsigned>(buf[3]) << 8 |
    buf[2]) << 16 |
    (static_cast<unsigned>(buf[1]) << 8 | buf[0]));

|t| is also not a great variable name...

[tfarina, 2015/04/23 13:09:43]

Done.

+            << 16 |
+        (static_cast<unsigned>(buf[1]) << 8 | buf[0]);
+    *reinterpret_cast<uint32_t*>(buf) = t;
     buf += 4;
   } while (--longs);
 }
 
 /* The four core functions - F1 is optimized somewhat */
 
 /* #define F1(x, y, z) (x & y | ~x & z) */
 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 #define F2(x, y, z) F1(z, x, y)
 #define F3(x, y, z) (x ^ y ^ z)
@@ skipping 92 matching lines @@
 
 }  // namespace
 
 namespace base {
 
 /*
  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  * initialization constants.
  */
 void MD5Init(MD5Context* context) {
-  struct Context* ctx = (struct Context*)context;
+  struct Context* ctx = reinterpret_cast<struct Context*>(context);
   ctx->buf[0] = 0x67452301;
   ctx->buf[1] = 0xefcdab89;
   ctx->buf[2] = 0x98badcfe;
   ctx->buf[3] = 0x10325476;
   ctx->bits[0] = 0;
   ctx->bits[1] = 0;
 }
 
 /*
  * Update context to reflect the concatenation of another buffer full
  * of bytes.
  */
 void MD5Update(MD5Context* context, const StringPiece& data) {
-  struct Context* ctx = (struct Context*)context;
-  const uint8_t* buf = (const uint8_t*)data.data();
+  struct Context* ctx = reinterpret_cast<struct Context*>(context);
+  const uint8_t* buf = reinterpret_cast<const uint8_t*>(data.data());
   size_t len = data.size();
 
   /* Update bitcount */
 
   uint32_t t = ctx->bits[0];
-  if ((ctx->bits[0] = t + ((uint32_t)len << 3)) < t)
+  if ((ctx->bits[0] = t + (static_cast<uint32_t>(len) << 3)) < t)
     ctx->bits[1]++; /* Carry from low to high */
   ctx->bits[1] += static_cast<uint32_t>(len >> 29);
 
   t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
 
   /* Handle any leading odd-sized chunks */
 
   if (t) {
-    uint8_t* p = (uint8_t*)ctx->in + t;
+    uint8_t* p = static_cast<uint8_t*>(ctx->in + t);
 
     t = 64 - t;
     if (len < t) {
       memcpy(p, buf, len);
       return;
     }
     memcpy(p, buf, t);
     byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32_t*)ctx->in);
+    MD5Transform(ctx->buf, reinterpret_cast<uint32_t*>(ctx->in));
     buf += t;
     len -= t;
   }
 
   /* Process data in 64-byte chunks */
 
   while (len >= 64) {
     memcpy(ctx->in, buf, 64);
     byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32_t*)ctx->in);
+    MD5Transform(ctx->buf, reinterpret_cast<uint32_t*>(ctx->in));
     buf += 64;
     len -= 64;
   }
 
   /* Handle any remaining bytes of data. */
 
   memcpy(ctx->in, buf, len);
 }
 
 /*
  * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 void MD5Final(MD5Digest* digest, MD5Context* context) {
-  struct Context* ctx = (struct Context*)context;
+  struct Context* ctx = reinterpret_cast<struct Context*>(context);
   unsigned count;
   uint8_t* p;
 
   /* Compute number of bytes mod 64 */
   count = (ctx->bits[0] >> 3) & 0x3F;
 
   /* Set the first char of padding to 0x80.  This is safe since there is
      always at least one byte free */
   p = ctx->in + count;
   *p++ = 0x80;
 
   /* Bytes of padding needed to make 64 bytes */
   count = 64 - 1 - count;
 
   /* Pad out to 56 mod 64 */
   if (count < 8) {
     /* Two lots of padding:  Pad the first block to 64 bytes */
     memset(p, 0, count);
     byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32_t*)ctx->in);
+    MD5Transform(ctx->buf, reinterpret_cast<uint32_t*>(ctx->in));
 
     /* Now fill the next block with 56 bytes */
     memset(ctx->in, 0, 56);
   } else {
     /* Pad block to 56 bytes */
     memset(p, 0, count - 8);
   }
   byteReverse(ctx->in, 14);
 
   /* Append length in bits and transform */
   memcpy(&ctx->in[14 * sizeof(ctx->bits[0])], &ctx->bits[0],
          sizeof(ctx->bits[0]));
   memcpy(&ctx->in[15 * sizeof(ctx->bits[1])], &ctx->bits[1],
          sizeof(ctx->bits[1]));
 
-  MD5Transform(ctx->buf, (uint32_t*)ctx->in);
-  byteReverse((uint8_t*)ctx->buf, 4);
+  MD5Transform(ctx->buf, reinterpret_cast<uint32_t*>(ctx->in));
+  byteReverse(reinterpret_cast<uint8_t*>(ctx->buf), 4);
   memcpy(digest->a, ctx->buf, 16);
   memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
 }
 
 void MD5IntermediateFinal(MD5Digest* digest, const MD5Context* context) {
   /* MD5Final mutates the MD5Context*. Make a copy for generating the
      intermediate value. */
   MD5Context context_copy;
   memcpy(&context_copy, context, sizeof(context_copy));
   MD5Final(digest, &context_copy);
@@ skipping 20 matching lines @@
   MD5Final(digest, &ctx);
 }
 
 std::string MD5String(const StringPiece& str) {
   MD5Digest digest;
   MD5Sum(str.data(), str.length(), &digest);
   return MD5DigestToBase16(digest);
 }
 
 }  // namespace base