Avoid misaligned read/write on little endian platforms

third_party/modp_b64/modp_b64.cc

 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 /* vi: set expandtab shiftwidth=4 tabstop=4: */
 /**
  * \file
  * <PRE>
  * MODP_B64 - High performance base64 encoder/decoder
  * Version 1.3 -- 17-Mar-2006
  * http://modp.com/release/base64
  *
  * Copyright &copy; 2005, 2006  Nick Galbreath -- nickg [at] modp [dot] com
@@ skipping 193 matching lines @@
         }
     }
 #endif
 
     size_t i;
     int leftover = len % 4;
     size_t chunks = (leftover == 0) ? len / 4 - 1 : len /4;
 
     uint8_t* p = (uint8_t*)dest;
     uint32_t x = 0;
-    uint32_t* destInt = (uint32_t*) p;
-    uint32_t* srcInt = (uint32_t*) src;
-    uint32_t y = *srcInt++;
+    const uint8_t* y = (uint8_t*)src;
+    src += 4;

[Alex Vakulenko (Google), 2015/09/17 21:15:17]

Why do we even care about src from this point on? Just increment |y| and don't
touch |src| at all. So, remove this line, and in the loop below do "y += 4;" and
you should be all good.

[Vitaly Buka (NO REVIEWS), 2015/09/17 21:19:42]

Done.

     for (i = 0; i < chunks; ++i) {
-        x = d0[y & 0xff] |
-            d1[(y >> 8) & 0xff] |
-            d2[(y >> 16) & 0xff] |
-            d3[(y >> 24) & 0xff];
+        x = d0[y[0]] | d1[y[1]] | d2[y[2]] | d3[y[3]];
 
         if (x >= BADCHAR) return MODP_B64_ERROR;
-        *destInt = x ;
-        p += 3;
-        destInt = (uint32_t*)p;
-        y = *srcInt++;}
+        *p++ =  ((uint8_t*)(&x))[0];
+        *p++ =  ((uint8_t*)(&x))[1];
+        *p++ =  ((uint8_t*)(&x))[2];
+        y = (uint8_t*)src;
+        src += 4;}
 
 
     switch (leftover) {
     case 0:
-        x = d0[y & 0xff] |
-            d1[(y >> 8) & 0xff] |
-            d2[(y >> 16) & 0xff] |
-            d3[(y >> 24) & 0xff];
+        x = d0[y[0]] | d1[y[1]] | d2[y[2]] | d3[y[3]];
 
         if (x >= BADCHAR) return MODP_B64_ERROR;
         *p++ =  ((uint8_t*)(&x))[0];
         *p++ =  ((uint8_t*)(&x))[1];
         *p =    ((uint8_t*)(&x))[2];
         return (chunks+1)*3;
         break;
     case 1:  /* with padding this is an impossible case */
-        x = d0[y & 0xff];
+        x = d0[y[0]];
         *p = *((uint8_t*)(&x)); // i.e. first char/byte in int
         break;
     case 2: // * case 2, 1  output byte */
-        x = d0[y & 0xff] | d1[y >> 8 & 0xff];
+        x = d0[y[0]] | d1[y[1]];
         *p = *((uint8_t*)(&x)); // i.e. first char
         break;
     default: /* case 3, 2 output bytes */
-        x = d0[y & 0xff] |
-            d1[y >> 8 & 0xff ] |
-            d2[y >> 16 & 0xff];  /* 0x3c */
+        x = d0[y[0]] | d1[y[1]] | d2[y[2]];  /* 0x3c */
         *p++ =  ((uint8_t*)(&x))[0];
         *p =  ((uint8_t*)(&x))[1];
         break;
     }
 
     if (x >= BADCHAR) return MODP_B64_ERROR;
 
     return 3*chunks + (6*leftover)/8;
 }
 
 #endif  /* if bigendian / else / endif */