combined patch for:

src/platform/vboot_reference/crypto/sha2.c

 /* SHA-256 and SHA-512 implementation based on code by Oliver Gay
  * <olivier.gay@a3.epfl.ch> under a BSD-style license. See below.
  */
 
 /*
  * FIPS 180-2 SHA-224/256/384/512 implementation
  * Last update: 02/02/2007
  * Issue date:  04/30/2005
  *
  * Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch>
@@ skipping 17 matching lines @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
-#include "sha.h"
-#include <string.h>
+#include "cryptolib.h"
+#include "utility.h"
 
 #define SHFR(x, n)    (x >> n)
 #define ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
 #define ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
 #define CH(x, y, z)  ((x & y) ^ (~x & z))
 #define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
 
 #define SHA256_F1(x) (ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
 #define SHA256_F2(x) (ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
 #define SHA256_F3(x) (ROTR(x,  7) ^ ROTR(x, 18) ^ SHFR(x,  3))
@@ skipping 283 matching lines @@
 
 
 void SHA256_update(SHA256_CTX* ctx, const uint8_t* data, uint64_t len) {
     unsigned int block_nb;
     unsigned int new_len, rem_len, tmp_len;
     const uint8_t *shifted_data;
 
     tmp_len = SHA256_BLOCK_SIZE - ctx->len;
     rem_len = len < tmp_len ? len : tmp_len;
 
-    memcpy(&ctx->block[ctx->len], data, rem_len);
+    Memcpy(&ctx->block[ctx->len], data, rem_len);
 
     if (ctx->len + len < SHA256_BLOCK_SIZE) {
         ctx->len += len;
         return;
     }
 
     new_len = len - rem_len;
     block_nb = new_len / SHA256_BLOCK_SIZE;
 
     shifted_data = data + rem_len;
 
     SHA256_transform(ctx, ctx->block, 1);
     SHA256_transform(ctx, shifted_data, block_nb);
 
     rem_len = new_len % SHA256_BLOCK_SIZE;
 
-    memcpy(ctx->block, &shifted_data[block_nb << 6],
+    Memcpy(ctx->block, &shifted_data[block_nb << 6],
            rem_len);
 
     ctx->len = rem_len;
     ctx->tot_len += (block_nb + 1) << 6;
 }
 
 uint8_t* SHA256_final(SHA256_CTX* ctx) {
     unsigned int block_nb;
     unsigned int pm_len;
     unsigned int len_b;
@@ skipping 150 matching lines @@
 
 void SHA512_update(SHA512_CTX* ctx, const uint8_t* data,
                    uint64_t len) {
     unsigned int block_nb;
     unsigned int new_len, rem_len, tmp_len;
     const uint8_t* shifted_data;
 
     tmp_len = SHA512_BLOCK_SIZE - ctx->len;
     rem_len = len < tmp_len ? len : tmp_len;
 
-    memcpy(&ctx->block[ctx->len], data, rem_len);
+    Memcpy(&ctx->block[ctx->len], data, rem_len);
 
     if (ctx->len + len < SHA512_BLOCK_SIZE) {
         ctx->len += len;
         return;
     }
 
     new_len = len - rem_len;
     block_nb = new_len / SHA512_BLOCK_SIZE;
 
     shifted_data = data + rem_len;
 
     SHA512_transform(ctx, ctx->block, 1);
     SHA512_transform(ctx, shifted_data, block_nb);
 
     rem_len = new_len % SHA512_BLOCK_SIZE;
 
-    memcpy(ctx->block, &shifted_data[block_nb << 7],
+    Memcpy(ctx->block, &shifted_data[block_nb << 7],
            rem_len);
 
     ctx->len = rem_len;
     ctx->tot_len += (block_nb + 1) << 7;
 }
 
 uint8_t* SHA512_final(SHA512_CTX* ctx)
 {
     unsigned int block_nb;
     unsigned int pm_len;
@@ skipping 55 matching lines @@
   int i;
   SHA512_CTX ctx;
   SHA512_init(&ctx);
   SHA512_update(&ctx, data, len);
   p = SHA512_final(&ctx);
   for (i = 0; i < SHA512_DIGEST_SIZE; ++i) {
     digest[i] = *p++;
   }
   return digest;
 }