base: In SHA-1 implementation use base::ByteSwap for endian conversion

base/sha1.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.
 
 #include "base/sha1.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
+#include "base/sys_byteorder.h"
 
 namespace base {
 
 // Implementation of SHA-1. Only handles data in byte-sized blocks,
 // which simplifies the code a fair bit.
 
 // Identifier names follow notation in FIPS PUB 180-3, where you'll
 // also find a description of the algorithm:
 // http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf
 
@@ skipping 64 matching lines @@
     return 0x5a827999;
   } else if (t < 40) {
     return 0x6ed9eba1;
   } else if (t < 60) {
     return 0x8f1bbcdc;
   } else {
     return 0xca62c1d6;
   }
 }
 
-static inline void swapends(uint32_t* t) {
-  *t = (*t >> 24) | ((*t >> 8) & 0xff00) | ((*t & 0xff00) << 8) | (*t << 24);
-}
-
 const int SecureHashAlgorithm::kDigestSizeBytes = 20;
 
 void SecureHashAlgorithm::Init() {
   A = 0;
   B = 0;
   C = 0;
   D = 0;
   E = 0;
   cursor = 0;
   l = 0;
   H[0] = 0x67452301;
   H[1] = 0xefcdab89;
   H[2] = 0x98badcfe;
   H[3] = 0x10325476;
   H[4] = 0xc3d2e1f0;
 }
 
 void SecureHashAlgorithm::Final() {
   Pad();
   Process();
 
   for (int t = 0; t < 5; ++t)
-    swapends(&H[t]);
+    H[t] = ByteSwap(H[t]);
 }
 
 void SecureHashAlgorithm::Update(const void* data, size_t nbytes) {
   const uint8_t* d = reinterpret_cast<const uint8_t*>(data);
   while (nbytes--) {
     M[cursor++] = *d++;
     if (cursor >= 64)
       Process();
     l += 8;
   }
@@ skipping 26 matching lines @@
 void SecureHashAlgorithm::Process() {
   uint32_t t;
 
   // Each a...e corresponds to a section in the FIPS 180-3 algorithm.
 
   // a.
   //
   // W and M are in a union, so no need to memcpy.
   // memcpy(W, M, sizeof(M));
   for (t = 0; t < 16; ++t)
-    swapends(&W[t]);
+    W[t] = ByteSwap(W[t]);
 
   // b.
   for (t = 16; t < 80; ++t)
     W[t] = S(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
 
   // c.
   A = H[0];
   B = H[1];
   C = H[2];
   D = H[3];
@@ skipping 29 matching lines @@
 void SHA1HashBytes(const unsigned char* data, size_t len,
                    unsigned char* hash) {
   SecureHashAlgorithm sha;
   sha.Update(data, len);
   sha.Final();
 
   memcpy(hash, sha.Digest(), SecureHashAlgorithm::kDigestSizeBytes);
 }
 
 }  // namespace base