vboot: use standard memcmp, memcpy, memset

Originally, we didn't trust the firmware to provide these functions from
a standard library.  Now, with coreboot, we do.

BUG=chromium:611535
BRANCH=none
TEST=make runtests; emerge-kevin coreboot depthcharge

Change-Id: I4e624c40085f2b665275a38624340b2f6aabcf11
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/399120
Reviewed-by: Daisuke Nojiri <dnojiri@chromium.org>

51 files changed, 341 insertions, 404 deletions

diff --git a/Makefile b/Makefile
index 490b9f79..0c5c2101 100644
--- a/Makefile
+++ b/Makefile
@@ -413,7 +413,6 @@ ifeq (${FIRMWARE_ARCH},)
 # TODO: split out other stub funcs too
 VBINIT_SRCS += \
 	firmware/stub/tpm_lite_stub.c \
-	firmware/stub/utility_stub.c \
 	firmware/stub/vboot_api_stub_init.c \
 	firmware/stub/vboot_api_stub_region.c
 
@@ -507,7 +506,6 @@ HOSTLIB_SRCS = \
 	firmware/lib/utility_string.c \
 	firmware/lib/vboot_nvstorage.c \
 	firmware/stub/tpm_lite_stub.c \
-	firmware/stub/utility_stub.c \
 	firmware/stub/vboot_api_stub.c \
 	firmware/stub/vboot_api_stub_disk.c \
 	firmware/stub/vboot_api_stub_init.c \
@@ -540,7 +538,6 @@ TINYHOSTLIB_SRCS = \
 	firmware/stub/vboot_api_stub.c \
 	firmware/stub/vboot_api_stub_disk.c \
 	firmware/stub/vboot_api_stub_sf.c \
-	firmware/stub/utility_stub.c \
 	futility/dump_kernel_config_lib.c \
 	host/lib/extract_vmlinuz.c
 
diff --git a/firmware/lib/cgptlib/cgptlib.c b/firmware/lib/cgptlib/cgptlib.c
index 11512a0e..954ca5fa 100644
--- a/firmware/lib/cgptlib/cgptlib.c
+++ b/firmware/lib/cgptlib/cgptlib.c
@@ -220,7 +220,7 @@ GptEntry *GptFindNthEntry(GptData *gpt, const Guid *guid, unsigned int n)
 	int i;
 
 	for (i = 0, e = entries; i < header->number_of_entries; i++, e++) {
-		if (!Memcmp(&e->type, guid, sizeof(*guid))) {
+		if (!memcmp(&e->type, guid, sizeof(*guid))) {
 			if (n == 0)
 				return e;
 			n--;
diff --git a/firmware/lib/cgptlib/cgptlib_internal.c b/firmware/lib/cgptlib/cgptlib_internal.c
index d09fa090..9f37def6 100644
--- a/firmware/lib/cgptlib/cgptlib_internal.c
+++ b/firmware/lib/cgptlib/cgptlib_internal.c
@@ -75,9 +75,9 @@ int CheckHeader(GptHeader *h, int is_secondary,
 	 * Make sure we're looking at a header of reasonable size before
 	 * attempting to calculate CRC.
 	 */
-	if (Memcmp(h->signature, GPT_HEADER_SIGNATURE,
+	if (memcmp(h->signature, GPT_HEADER_SIGNATURE,
 		   GPT_HEADER_SIGNATURE_SIZE) &&
-	    Memcmp(h->signature, GPT_HEADER_SIGNATURE2,
+	    memcmp(h->signature, GPT_HEADER_SIGNATURE2,
 		   GPT_HEADER_SIGNATURE_SIZE))
 		return 1;
 	if (h->revision != GPT_HEADER_REVISION)
@@ -154,7 +154,7 @@ int CheckHeader(GptHeader *h, int is_secondary,
 int IsKernelEntry(const GptEntry *e)
 {
 	static Guid chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL;
-	return !Memcmp(&e->type, &chromeos_kernel, sizeof(Guid));
+	return !memcmp(&e->type, &chromeos_kernel, sizeof(Guid));
 }
 
 int CheckEntries(GptEntry *entries, GptHeader *h)
@@ -199,7 +199,7 @@ int CheckEntries(GptEntry *entries, GptHeader *h)
 				return GPT_ERROR_END_LBA_OVERLAP;
 
 			/* UniqueGuid field must be unique. */
-			if (0 == Memcmp(&entry->unique, &e2->unique,
+			if (0 == memcmp(&entry->unique, &e2->unique,
 					sizeof(Guid)))
 				return GPT_ERROR_DUP_GUID;
 		}
@@ -211,7 +211,7 @@ int CheckEntries(GptEntry *entries, GptHeader *h)
 
 int HeaderFieldsSame(GptHeader *h1, GptHeader *h2)
 {
-	if (Memcmp(h1->signature, h2->signature, sizeof(h1->signature)))
+	if (memcmp(h1->signature, h2->signature, sizeof(h1->signature)))
 		return 1;
 	if (h1->revision != h2->revision)
 		return 1;
@@ -223,7 +223,7 @@ int HeaderFieldsSame(GptHeader *h1, GptHeader *h2)
 		return 1;
 	if (h1->last_usable_lba != h2->last_usable_lba)
 		return 1;
-	if (Memcmp(&h1->disk_uuid, &h2->disk_uuid, sizeof(Guid)))
+	if (memcmp(&h1->disk_uuid, &h2->disk_uuid, sizeof(Guid)))
 		return 1;
 	if (h1->number_of_entries != h2->number_of_entries)
 		return 1;
@@ -257,7 +257,7 @@ int GptSanityCheck(GptData *gpt)
 			     gpt->gpt_drive_sectors, gpt->flags)) {
 		gpt->valid_headers |= MASK_PRIMARY;
 		goodhdr = header1;
-	} else if (header1 && !Memcmp(header1->signature,
+	} else if (header1 && !memcmp(header1->signature,
 		   GPT_HEADER_SIGNATURE_IGNORED, GPT_HEADER_SIGNATURE_SIZE)) {
 		gpt->ignored |= MASK_PRIMARY;
 	}
@@ -266,7 +266,7 @@ int GptSanityCheck(GptData *gpt)
 		gpt->valid_headers |= MASK_SECONDARY;
 		if (!goodhdr)
 			goodhdr = header2;
-	} else if (header2 && !Memcmp(header2->signature,
+	} else if (header2 && !memcmp(header2->signature,
 		   GPT_HEADER_SIGNATURE_IGNORED, GPT_HEADER_SIGNATURE_SIZE)) {
 		gpt->ignored |= MASK_SECONDARY;
 	}
@@ -344,7 +344,7 @@ void GptRepair(GptData *gpt)
 	/* Repair headers if necessary */
 	if (MASK_PRIMARY == gpt->valid_headers) {
 		/* Primary is good, secondary is bad */
-		Memcpy(header2, header1, sizeof(GptHeader));
+		memcpy(header2, header1, sizeof(GptHeader));
 		header2->my_lba = gpt->gpt_drive_sectors - GPT_HEADER_SECTORS;
 		header2->alternate_lba = GPT_PMBR_SECTORS;  /* Second sector. */
 		header2->entries_lba = header2->my_lba - CalculateEntriesSectors(header1);
@@ -353,7 +353,7 @@ void GptRepair(GptData *gpt)
 	}
 	else if (MASK_SECONDARY == gpt->valid_headers) {
 		/* Secondary is good, primary is bad */
-		Memcpy(header1, header2, sizeof(GptHeader));
+		memcpy(header1, header2, sizeof(GptHeader));
 		header1->my_lba = GPT_PMBR_SECTORS;  /* Second sector. */
 		header1->alternate_lba =
 			gpt->streaming_drive_sectors - GPT_HEADER_SECTORS;
@@ -368,12 +368,12 @@ void GptRepair(GptData *gpt)
 	entries_size = header1->size_of_entry * header1->number_of_entries;
 	if (MASK_PRIMARY == gpt->valid_entries) {
 		/* Primary is good, secondary is bad */
-		Memcpy(entries2, entries1, entries_size);
+		memcpy(entries2, entries1, entries_size);
 		gpt->modified |= GPT_MODIFIED_ENTRIES2;
 	}
 	else if (MASK_SECONDARY == gpt->valid_entries) {
 		/* Secondary is good, primary is bad */
-		Memcpy(entries1, entries2, entries_size);
+		memcpy(entries1, entries2, entries_size);
 		gpt->modified |= GPT_MODIFIED_ENTRIES1;
 	}
 	gpt->valid_entries = MASK_BOTH;
@@ -440,7 +440,7 @@ void GetCurrentKernelUniqueGuid(GptData *gpt, void *dest)
 {
 	GptEntry *entries = (GptEntry *)gpt->primary_entries;
 	GptEntry *e = entries + gpt->current_kernel;
-	Memcpy(dest, &e->unique, sizeof(Guid));
+	memcpy(dest, &e->unique, sizeof(Guid));
 }
 
 void GptModified(GptData *gpt) {
diff --git a/firmware/lib/cryptolib/rsa.c b/firmware/lib/cryptolib/rsa.c
index 6d61a216..db60d2d2 100644
--- a/firmware/lib/cryptolib/rsa.c
+++ b/firmware/lib/cryptolib/rsa.c
@@ -158,7 +158,7 @@ int RSAVerify(const RSAPublicKey *key,
   buf = (uint8_t*) VbExMalloc(sig_len);
   if (!buf)
     return 0;
-  Memcpy(buf, sig, sig_len);
+  memcpy(buf, sig, sig_len);
 
   modpowF4(key, buf);
 
diff --git a/firmware/lib/gpt_misc.c b/firmware/lib/gpt_misc.c
index 3957cb89..d843b21e 100644
--- a/firmware/lib/gpt_misc.c
+++ b/firmware/lib/gpt_misc.c
@@ -47,7 +47,7 @@ int AllocAndReadGptData(VbExDiskHandle_t disk_handle, GptData *gptdata)
 	/* Read primary header from the drive, skipping the protective MBR */
 	if (0 != VbExDiskRead(disk_handle, 1, 1, gptdata->primary_header)) {
 		VBDEBUG(("Read error in primary GPT header\n"));
-		Memset(gptdata->primary_header, 0, gptdata->sector_bytes);
+		memset(gptdata->primary_header, 0, gptdata->sector_bytes);
 	}
 
 	/* Only read primary GPT if the primary header is valid */
@@ -71,7 +71,7 @@ int AllocAndReadGptData(VbExDiskHandle_t disk_handle, GptData *gptdata)
 		}
 	} else {
 		VBDEBUG(("Primary GPT header is %s\n",
-			 Memcmp(primary_header->signature,
+			 memcmp(primary_header->signature,
 				GPT_HEADER_SIGNATURE_IGNORED,
 				GPT_HEADER_SIGNATURE_SIZE)
 			 ? "invalid" : "being ignored"));
@@ -81,7 +81,7 @@ int AllocAndReadGptData(VbExDiskHandle_t disk_handle, GptData *gptdata)
 	if (0 != VbExDiskRead(disk_handle, gptdata->gpt_drive_sectors - 1, 1,
 			      gptdata->secondary_header)) {
 		VBDEBUG(("Read error in secondary GPT header\n"));
-		Memset(gptdata->secondary_header, 0, gptdata->sector_bytes);
+		memset(gptdata->secondary_header, 0, gptdata->sector_bytes);
 	}
 
 	/* Only read secondary GPT if the secondary header is valid */
@@ -105,7 +105,7 @@ int AllocAndReadGptData(VbExDiskHandle_t disk_handle, GptData *gptdata)
 		}
 	} else {
 		VBDEBUG(("Secondary GPT header is %s\n",
-			 Memcmp(secondary_header->signature,
+			 memcmp(secondary_header->signature,
 				GPT_HEADER_SIGNATURE_IGNORED,
 				GPT_HEADER_SIGNATURE_SIZE)
 			 ? "invalid" : "being ignored"));
@@ -151,7 +151,7 @@ int WriteAndFreeGptData(VbExDiskHandle_t disk_handle, GptData *gptdata)
 				 "marked to be ignored.\n"));
 			skip_primary = 1;
 		} else if (gptdata->modified & GPT_MODIFIED_HEADER1) {
-			if (!Memcmp(h->signature, GPT_HEADER_SIGNATURE2,
+			if (!memcmp(h->signature, GPT_HEADER_SIGNATURE2,
 				    GPT_HEADER_SIGNATURE_SIZE)) {
 				VBDEBUG(("Not updating primary GPT: "
 					 "legacy mode is enabled.\n"));
@@ -219,7 +219,7 @@ fail:
 int IsUnusedEntry(const GptEntry *e)
 {
 	static Guid zero = {{{0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0}}}};
-	return !Memcmp(&zero, (const uint8_t*)(&e->type), sizeof(zero));
+	return !memcmp(&zero, (const uint8_t*)(&e->type), sizeof(zero));
 }
 
 /*
diff --git a/firmware/lib/include/sysincludes.h b/firmware/lib/include/sysincludes.h
index 490b51cc..7a9139c0 100644
--- a/firmware/lib/include/sysincludes.h
+++ b/firmware/lib/include/sysincludes.h
@@ -19,6 +19,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 
 #if defined(HAVE_ENDIAN_H) && defined(HAVE_LITTLE_ENDIAN)
 #include <byteswap.h>
diff --git a/firmware/lib/include/utility.h b/firmware/lib/include/utility.h
index 66093781..aaddb8c8 100644
--- a/firmware/lib/include/utility.h
+++ b/firmware/lib/include/utility.h
@@ -47,36 +47,13 @@
 #define Min(a, b) (((a) < (b)) ? (a) : (b))
 
 /**
- * Compare [n] bytes in [src1] and [src2].
- *
- * Returns an integer less than, equal to, or greater than zero if the first
- * [n] bytes of [src1] is found, respectively, to be less than, to match, or be
- * greater than the first n bytes of [src2]. */
-int Memcmp(const void *src1, const void *src2, size_t n);
-
-/**
- * Copy [n] bytes from [src] to [dest].
- */
-void *Memcpy(void *dest, const void *src, uint64_t n);
-
-/*
- * Implementations of the functions below must be built as part of the firmware
- * and defined in lib/utility.c.
- */
-
-/**
- * Set [n] bytes starting at [s] to [c].  Returns dest.
- */
-void *Memset(void *dest, const uint8_t c, uint64_t n);
-
-/**
  * Compare [n] bytes starting at [s1] with [s2] and return 0 if they
  * match, 1 if they don't.  Returns 0 if n=0, since no bytes mismatched.
  *
  * Time taken to perform the comparison is only dependent on [n] and
  * not on the relationship of the match between [s1] and [s2].
  *
- * Note that unlike Memcmp(), this only indicates inequality, not
+ * Note that unlike memcmp(), this only indicates inequality, not
  * whether s1 is less than or greater than s2.
  */
 int SafeMemcmp(const void *s1, const void *s2, size_t n);
@@ -108,9 +85,6 @@ uint32_t StrnAppend(char *dest, const char *src, uint32_t destlen);
 #ifndef _STUB_IMPLEMENTATION_
 #define malloc _do_not_use_standard_malloc
 #define free _do_not_use_standard_free
-#define memcmp _do_not_use_standard_memcmp
-#define memcpy _do_not_use_standard_memcpy
-#define memset _do_not_use_standard_memset
 #endif
 
 #endif  /* VBOOT_REFERENCE_UTILITY_H_ */
diff --git a/firmware/lib/mocked_rollback_index.c b/firmware/lib/mocked_rollback_index.c
index e8c1fdbb..a4b0ceb0 100644
--- a/firmware/lib/mocked_rollback_index.c
+++ b/firmware/lib/mocked_rollback_index.c
@@ -42,6 +42,6 @@ uint32_t RollbackKernelLock(int recovery_mode)
 
 uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 {
-	Memset(fwmp, 0, sizeof(*fwmp));
+	memset(fwmp, 0, sizeof(*fwmp));
 	return TPM_SUCCESS;
 }
diff --git a/firmware/lib/region-init.c b/firmware/lib/region-init.c
index bec0450d..26602b54 100644
--- a/firmware/lib/region-init.c
+++ b/firmware/lib/region-init.c
@@ -25,7 +25,7 @@ VbError_t VbRegionReadData(VbCommonParams *cparams,
 	if (region == VB_REGION_GBB && cparams->gbb_data) {
 		if (offset + size > cparams->gbb_size)
 			return VBERROR_INVALID_GBB;
-		Memcpy(buf, cparams->gbb_data + offset, size);
+		memcpy(buf, cparams->gbb_data + offset, size);
 	} else
 #ifdef REGION_READ
 	{
diff --git a/firmware/lib/region-kernel.c b/firmware/lib/region-kernel.c
index e6303978..c87db427 100644
--- a/firmware/lib/region-kernel.c
+++ b/firmware/lib/region-kernel.c
@@ -45,7 +45,7 @@ VbError_t VbGbbReadBmpHeader(VbCommonParams *cparams, BmpBlockHeader *hdr_ret)
 		}
 
 		/* Sanity-check the bitmap block header */
-		if ((0 != Memcmp(hdr->signature, BMPBLOCK_SIGNATURE,
+		if ((0 != memcmp(hdr->signature, BMPBLOCK_SIGNATURE,
 				BMPBLOCK_SIGNATURE_SIZE)) ||
 		(hdr->major_version > BMPBLOCK_MAJOR_VERSION) ||
 		((hdr->major_version == BMPBLOCK_MAJOR_VERSION) &&
diff --git a/firmware/lib/rollback_index.c b/firmware/lib/rollback_index.c
index cf446d98..2ba44ec3 100644
--- a/firmware/lib/rollback_index.c
+++ b/firmware/lib/rollback_index.c
@@ -257,7 +257,7 @@ uint32_t RollbackKernelLock(int recovery_mode)
 
 uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 {
-	Memset(fwmp, 0, sizeof(*fwmp));
+	memset(fwmp, 0, sizeof(*fwmp));
 	return TPM_SUCCESS;
 }
 
@@ -285,13 +285,13 @@ uint32_t RollbackKernelRead(uint32_t* version)
 		uint32_t perms, uid;
 
 		RETURN_ON_FAILURE(TlclGetPermissions(KERNEL_NV_INDEX, &perms));
-		Memcpy(&uid, &rsk.uid, sizeof(uid));
+		memcpy(&uid, &rsk.uid, sizeof(uid));
 		if (TPM_NV_PER_PPWRITE != perms ||
 		    ROLLBACK_SPACE_KERNEL_UID != uid)
 			return TPM_E_CORRUPTED_STATE;
 	}
 #endif
-	Memcpy(version, &rsk.kernel_versions, sizeof(*version));
+	memcpy(version, &rsk.kernel_versions, sizeof(*version));
 	VBDEBUG(("TPM: RollbackKernelRead %x\n", (int)*version));
 	return TPM_SUCCESS;
 }
@@ -301,10 +301,10 @@ uint32_t RollbackKernelWrite(uint32_t version)
 	RollbackSpaceKernel rsk;
 	uint32_t old_version;
 	RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
-	Memcpy(&old_version, &rsk.kernel_versions, sizeof(old_version));
+	memcpy(&old_version, &rsk.kernel_versions, sizeof(old_version));
 	VBDEBUG(("TPM: RollbackKernelWrite %x --> %x\n",
 		 (int)old_version, (int)version));
-	Memcpy(&rsk.kernel_versions, &version, sizeof(version));
+	memcpy(&rsk.kernel_versions, &version, sizeof(version));
 	return WriteSpaceKernel(&rsk);
 }
 
@@ -337,7 +337,7 @@ uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 	int attempts = 3;
 
 	/* Clear destination in case error or FWMP not present */
-	Memset(fwmp, 0, sizeof(*fwmp));
+	memset(fwmp, 0, sizeof(*fwmp));
 
 	while (attempts--) {
 		/* Try to read entire 1.0 struct */
@@ -390,7 +390,7 @@ uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 		 * we would need to take care of initializing the extra fields
 		 * added in 1.1+.  But that's not an issue yet.
 		 */
-		Memcpy(fwmp, &u.bf, sizeof(*fwmp));
+		memcpy(fwmp, &u.bf, sizeof(*fwmp));
 		return TPM_SUCCESS;
 	}
 
diff --git a/firmware/lib/stateful_util.c b/firmware/lib/stateful_util.c
index fbbc48c9..f0718f6d 100644
--- a/firmware/lib/stateful_util.c
+++ b/firmware/lib/stateful_util.c
@@ -38,7 +38,7 @@ void *StatefulMemcpy(MemcpyState *state, void *dst, uint64_t len)
 		state->overrun = 1;
 		return NULL;
 	}
-	Memcpy(dst, state->remaining_buf, len);
+	memcpy(dst, state->remaining_buf, len);
 	state->remaining_buf += len;
 	state->remaining_len -= len;
 	return dst;
@@ -52,7 +52,7 @@ const void *StatefulMemcpy_r(MemcpyState *state, const void *src, uint64_t len)
 		state->overrun = 1;
 		return NULL;
 	}
-	Memcpy(state->remaining_buf, src, len);
+	memcpy(state->remaining_buf, src, len);
 	state->remaining_buf += len;
 	state->remaining_len -= len;
 	return src;
@@ -67,7 +67,7 @@ const void *StatefulMemset_r(MemcpyState *state, const uint8_t val,
 		state->overrun = 1;
 		return NULL;
 	}
-	Memset(state->remaining_buf, val, len);
+	memset(state->remaining_buf, val, len);
 	state->remaining_buf += len;
 	state->remaining_len -= len;
 	return state; /* Must return something non-NULL. */
diff --git a/firmware/lib/tpm2_lite/marshaling.c b/firmware/lib/tpm2_lite/marshaling.c
index 786bfc0b..a51c1f66 100644
--- a/firmware/lib/tpm2_lite/marshaling.c
+++ b/firmware/lib/tpm2_lite/marshaling.c
@@ -221,7 +221,7 @@ static void marshal_blob(void **buffer, void *blob,
 		return;
 	}
 
-	Memcpy(*buffer, blob, blob_size);
+	memcpy(*buffer, blob, blob_size);
 	buffer_space -= blob_size;
 	*buffer = (void *)((uintptr_t)(*buffer) + blob_size);
 }
@@ -307,7 +307,7 @@ static void marshal_TPM2B(void **buffer,
 		return;
 	}
 	marshal_u16(buffer, data->size, buffer_space);
-	Memcpy(*buffer, data->buffer, data->size);
+	memcpy(*buffer, data->buffer, data->size);
 	*buffer = ((uint8_t *)(*buffer)) + data->size;
 	*buffer_space -= data->size;
 }
@@ -320,7 +320,7 @@ static void marshal_nv_write(void **buffer,
 
 	marshal_TPM_HANDLE(buffer, TPM_RH_PLATFORM, buffer_space);
 	marshal_TPM_HANDLE(buffer, command_body->nvIndex, buffer_space);
-	Memset(&session_header, 0, sizeof(session_header));
+	memset(&session_header, 0, sizeof(session_header));
 	session_header.session_handle = TPM_RS_PW;
 	marshal_session_header(buffer, &session_header, buffer_space);
 	tpm_tag = TPM_ST_SESSIONS;
@@ -341,7 +341,7 @@ static void marshal_nv_read(void **buffer,
 	else
 		marshal_TPM_HANDLE(buffer, TPM_RH_PLATFORM, buffer_space);
 	marshal_TPM_HANDLE(buffer, command_body->nvIndex, buffer_space);
-	Memset(&session_header, 0, sizeof(session_header));
+	memset(&session_header, 0, sizeof(session_header));
 	session_header.session_handle = TPM_RS_PW;
 	marshal_session_header(buffer, &session_header, buffer_space);
 	tpm_tag = TPM_ST_SESSIONS;
@@ -358,7 +358,7 @@ static void marshal_nv_read_lock(void **buffer,
 	tpm_tag = TPM_ST_SESSIONS;
 	marshal_TPM_HANDLE(buffer, TPM_RH_PLATFORM, buffer_space);
 	marshal_TPM_HANDLE(buffer, command_body->nvIndex, buffer_space);
-	Memset(&session_header, 0, sizeof(session_header));
+	memset(&session_header, 0, sizeof(session_header));
 	session_header.session_handle = TPM_RS_PW;
 	marshal_session_header(buffer, &session_header, buffer_space);
 }
@@ -372,7 +372,7 @@ static void marshal_nv_write_lock(void **buffer,
 	tpm_tag = TPM_ST_SESSIONS;
 	marshal_TPM_HANDLE(buffer, TPM_RH_PLATFORM, buffer_space);
 	marshal_TPM_HANDLE(buffer, command_body->nvIndex, buffer_space);
-	Memset(&session_header, 0, sizeof(session_header));
+	memset(&session_header, 0, sizeof(session_header));
 	session_header.session_handle = TPM_RS_PW;
 	marshal_session_header(buffer, &session_header, buffer_space);
 }
@@ -386,7 +386,7 @@ static void marshal_hierarchy_control(void **buffer,
 
 	tpm_tag = TPM_ST_SESSIONS;
 	marshal_TPM_HANDLE(buffer, TPM_RH_PLATFORM, buffer_space);
-	Memset(&session_header, 0, sizeof(session_header));
+	memset(&session_header, 0, sizeof(session_header));
 	session_header.session_handle = TPM_RS_PW;
 	marshal_session_header(buffer, &session_header, buffer_space);
 
@@ -414,7 +414,7 @@ static void marshal_clear(void **buffer,
 
 	tpm_tag = TPM_ST_SESSIONS;
 	marshal_TPM_HANDLE(buffer, TPM_RH_PLATFORM, buffer_space);
-	Memset(&session_header, 0, sizeof(session_header));
+	memset(&session_header, 0, sizeof(session_header));
 	session_header.session_handle = TPM_RS_PW;
 	marshal_session_header(buffer, &session_header, buffer_space);
 }
diff --git a/firmware/lib/tpm2_lite/tlcl.c b/firmware/lib/tpm2_lite/tlcl.c
index 938fdd66..96900b07 100644
--- a/firmware/lib/tpm2_lite/tlcl.c
+++ b/firmware/lib/tpm2_lite/tlcl.c
@@ -381,7 +381,7 @@ uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 	struct tpm2_nv_read_cmd nv_readc;
 	struct tpm2_response *response;
 
-	Memset(&nv_readc, 0, sizeof(nv_readc));
+	memset(&nv_readc, 0, sizeof(nv_readc));
 
 	nv_readc.nvIndex = HR_NV_INDEX + index;
 	nv_readc.size = length;
@@ -409,7 +409,7 @@ uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 	if (length < response->nvr.buffer.t.size)
 		return TPM_E_READ_EMPTY;
 
-	Memcpy(data, response->nvr.buffer.t.buffer, length);
+	memcpy(data, response->nvr.buffer.t.buffer, length);
 
 	return TPM_SUCCESS;
 }
@@ -419,7 +419,7 @@ uint32_t TlclWrite(uint32_t index, const void *data, uint32_t length)
 	struct tpm2_nv_write_cmd nv_writec;
 	struct tpm2_response *response;
 
-	Memset(&nv_writec, 0, sizeof(nv_writec));
+	memset(&nv_writec, 0, sizeof(nv_writec));
 
 	nv_writec.nvIndex = HR_NV_INDEX + index;
 	nv_writec.data.t.size = length;
@@ -445,7 +445,7 @@ uint32_t TlclWriteLock(uint32_t index)
 	struct tpm2_nv_write_lock_cmd nv_writelockc;
 	struct tpm2_response *response;
 
-	Memset(&nv_writelockc, 0, sizeof(nv_writelockc));
+	memset(&nv_writelockc, 0, sizeof(nv_writelockc));
 
 	nv_writelockc.nvIndex = HR_NV_INDEX | index;
 
@@ -463,7 +463,7 @@ uint32_t TlclReadLock(uint32_t index)
 	struct tpm2_nv_read_lock_cmd nv_readlockc;
 	struct tpm2_response *response;
 
-	Memset(&nv_readlockc, 0, sizeof(nv_readlockc));
+	memset(&nv_readlockc, 0, sizeof(nv_readlockc));
 
 	nv_readlockc.nvIndex = HR_NV_INDEX | index;
 
diff --git a/firmware/lib/tpm_lite/mocked_tlcl.c b/firmware/lib/tpm_lite/mocked_tlcl.c
index 38d0deac..01762964 100644
--- a/firmware/lib/tpm_lite/mocked_tlcl.c
+++ b/firmware/lib/tpm_lite/mocked_tlcl.c
@@ -57,13 +57,13 @@ uint32_t TlclWrite(uint32_t index, const void* data, uint32_t length)
 
 uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 {
-	Memset(data, '\0', length);
+	memset(data, '\0', length);
 	return TPM_SUCCESS;
 }
 
 uint32_t TlclPCRRead(uint32_t index, void* data, uint32_t length)
 {
-	Memset(data, '\0', length);
+	memset(data, '\0', length);
 	return TPM_SUCCESS;
 }
 
@@ -134,13 +134,13 @@ uint32_t TlclSetDeactivated(uint8_t flag)
 
 uint32_t TlclGetPermanentFlags(TPM_PERMANENT_FLAGS* pflags)
 {
-	Memset(pflags, '\0', sizeof(*pflags));
+	memset(pflags, '\0', sizeof(*pflags));
 	return TPM_SUCCESS;
 }
 
 uint32_t TlclGetSTClearFlags(TPM_STCLEAR_FLAGS* vflags)
 {
-	Memset(vflags, '\0', sizeof(*vflags));
+	memset(vflags, '\0', sizeof(*vflags));
 	return TPM_SUCCESS;
 }
 
@@ -162,7 +162,7 @@ uint32_t TlclSetGlobalLock(void)
 uint32_t TlclExtend(int pcr_num, const uint8_t* in_digest,
                     uint8_t* out_digest)
 {
-	Memcpy(out_digest, in_digest, kPcrDigestLength);
+	memcpy(out_digest, in_digest, kPcrDigestLength);
 	return TPM_SUCCESS;
 }
 
@@ -182,7 +182,7 @@ uint32_t TlclGetRandom(uint8_t* data, uint32_t length, uint32_t *size)
 {
 	*size = length;
 	/* http://dilbert.com/strips/comic/2001-10-25/ */
-	Memset(data, '\x9', *size);
+	memset(data, '\x9', *size);
 	return TPM_SUCCESS;
 }
 
diff --git a/firmware/lib/tpm_lite/tlcl.c b/firmware/lib/tpm_lite/tlcl.c
index 7da5e14e..70fce2b9 100644
--- a/firmware/lib/tpm_lite/tlcl.c
+++ b/firmware/lib/tpm_lite/tlcl.c
@@ -200,7 +200,7 @@ uint32_t TlclDefineSpace(uint32_t index, uint32_t perm, uint32_t size)
 {
 	struct s_tpm_nv_definespace_cmd cmd;
 	VBDEBUG(("TPM: TlclDefineSpace(0x%x, 0x%x, %d)\n", index, perm, size));
-	Memcpy(&cmd, &tpm_nv_definespace_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_nv_definespace_cmd, sizeof(cmd));
 	ToTpmUint32(cmd.buffer + tpm_nv_definespace_cmd.index, index);
 	ToTpmUint32(cmd.buffer + tpm_nv_definespace_cmd.perm, perm);
 	ToTpmUint32(cmd.buffer + tpm_nv_definespace_cmd.size, size);
@@ -215,13 +215,13 @@ uint32_t TlclWrite(uint32_t index, const void* data, uint32_t length)
 			kTpmRequestHeaderLength + kWriteInfoLength + length;
 
 	VBDEBUG(("TPM: TlclWrite(0x%x, %d)\n", index, length));
-	Memcpy(&cmd, &tpm_nv_write_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_nv_write_cmd, sizeof(cmd));
 	VbAssert(total_length <= TPM_LARGE_ENOUGH_COMMAND_SIZE);
 	SetTpmCommandSize(cmd.buffer, total_length);
 
 	ToTpmUint32(cmd.buffer + tpm_nv_write_cmd.index, index);
 	ToTpmUint32(cmd.buffer + tpm_nv_write_cmd.length, length);
-	Memcpy(cmd.buffer + tpm_nv_write_cmd.data, data, length);
+	memcpy(cmd.buffer + tpm_nv_write_cmd.data, data, length);
 
 	return TlclSendReceive(cmd.buffer, response, sizeof(response));
 }
@@ -234,7 +234,7 @@ uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 	uint32_t result;
 
 	VBDEBUG(("TPM: TlclRead(0x%x, %d)\n", index, length));
-	Memcpy(&cmd, &tpm_nv_read_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_nv_read_cmd, sizeof(cmd));
 	ToTpmUint32(cmd.buffer + tpm_nv_read_cmd.index, index);
 	ToTpmUint32(cmd.buffer + tpm_nv_read_cmd.length, length);
 
@@ -245,7 +245,7 @@ uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 		if (result_length > length)
 			result_length = length;  /* Truncate to fit buffer */
 		nv_read_cursor += sizeof(uint32_t);
-		Memcpy(data, nv_read_cursor, result_length);
+		memcpy(data, nv_read_cursor, result_length);
 	}
 
 	return result;
@@ -261,13 +261,13 @@ uint32_t TlclPCRRead(uint32_t index, void* data, uint32_t length)
 	if (length < kPcrDigestLength) {
 		return TPM_E_IOERROR;
 	}
-	Memcpy(&cmd, &tpm_pcr_read_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_pcr_read_cmd, sizeof(cmd));
 	ToTpmUint32(cmd.buffer + tpm_pcr_read_cmd.pcrNum, index);
 
 	result = TlclSendReceive(cmd.buffer, response, sizeof(response));
 	if (result == TPM_SUCCESS) {
 		uint8_t* pcr_read_cursor = response + kTpmResponseHeaderLength;
-		Memcpy(data, pcr_read_cursor, kPcrDigestLength);
+		memcpy(data, pcr_read_cursor, kPcrDigestLength);
 	}
 
 	return result;
@@ -353,7 +353,7 @@ uint32_t TlclSetDeactivated(uint8_t flag)
 {
 	struct s_tpm_physicalsetdeactivated_cmd cmd;
 	VBDEBUG(("TPM: SetDeactivated(%d)\n", flag));
-	Memcpy(&cmd, &tpm_physicalsetdeactivated_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_physicalsetdeactivated_cmd, sizeof(cmd));
 	*(cmd.buffer + cmd.deactivated) = flag;
 	return Send(cmd.buffer);
 }
@@ -370,7 +370,7 @@ uint32_t TlclGetPermanentFlags(TPM_PERMANENT_FLAGS* pflags)
 	/* TODO(crbug.com/379255): This fails. Find out why.
 	 * VbAssert(size == sizeof(TPM_PERMANENT_FLAGS));
 	 */
-	Memcpy(pflags,
+	memcpy(pflags,
 	       response + kTpmResponseHeaderLength + sizeof(size),
 	       sizeof(TPM_PERMANENT_FLAGS));
 	return result;
@@ -389,7 +389,7 @@ uint32_t TlclGetSTClearFlags(TPM_STCLEAR_FLAGS* vflags)
 	/* TODO(crbug.com/379255): This fails. Find out why.
 	 * VbAssert(size == 7 && sizeof(TPM_STCLEAR_FLAGS) - 1 == 7);
 	 */
-	Memcpy(vflags,
+	memcpy(vflags,
 	       response + kTpmResponseHeaderLength + sizeof(size),
 	       sizeof(TPM_STCLEAR_FLAGS));
 	return result;
@@ -429,15 +429,15 @@ uint32_t TlclExtend(int pcr_num, const uint8_t* in_digest,
 	uint8_t response[kTpmResponseHeaderLength + kPcrDigestLength];
 	uint32_t result;
 
-	Memcpy(&cmd, &tpm_extend_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_extend_cmd, sizeof(cmd));
 	ToTpmUint32(cmd.buffer + tpm_extend_cmd.pcrNum, pcr_num);
-	Memcpy(cmd.buffer + cmd.inDigest, in_digest, kPcrDigestLength);
+	memcpy(cmd.buffer + cmd.inDigest, in_digest, kPcrDigestLength);
 
 	result = TlclSendReceive(cmd.buffer, response, sizeof(response));
 	if (result != TPM_SUCCESS)
 		return result;
 
-	Memcpy(out_digest, response + kTpmResponseHeaderLength,
+	memcpy(out_digest, response + kTpmResponseHeaderLength,
 	       kPcrDigestLength);
 	return result;
 }
@@ -450,7 +450,7 @@ uint32_t TlclGetPermissions(uint32_t index, uint32_t* permissions)
 	uint32_t result;
 	uint32_t size;
 
-	Memcpy(&cmd, &tpm_getpermissions_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_getpermissions_cmd, sizeof(cmd));
 	ToTpmUint32(cmd.buffer + tpm_getpermissions_cmd.index, index);
 	result = TlclSendReceive(cmd.buffer, response, sizeof(response));
 	if (result != TPM_SUCCESS)
@@ -473,7 +473,7 @@ uint32_t TlclGetOwnership(uint8_t* owned)
 	/* TODO(crbug.com/379255): This fails. Find out why.
 	 * VbAssert(size == sizeof(*owned));
 	 */
-	Memcpy(owned,
+	memcpy(owned,
 	       response + kTpmResponseHeaderLength + sizeof(size),
 	       sizeof(*owned));
 	return result;
@@ -486,7 +486,7 @@ uint32_t TlclGetRandom(uint8_t* data, uint32_t length, uint32_t *size)
 	uint32_t result;
 
 	VBDEBUG(("TPM: TlclGetRandom(%d)\n", length));
-	Memcpy(&cmd, &tpm_get_random_cmd, sizeof(cmd));
+	memcpy(&cmd, &tpm_get_random_cmd, sizeof(cmd));
 	ToTpmUint32(cmd.buffer + tpm_get_random_cmd.bytesRequested, length);
 	/* There must be room in the response buffer for the bytes. */
 	if (length > TPM_LARGE_ENOUGH_COMMAND_SIZE - kTpmResponseHeaderLength
@@ -505,7 +505,7 @@ uint32_t TlclGetRandom(uint8_t* data, uint32_t length, uint32_t *size)
 		}
 		get_random_cursor = response + kTpmResponseHeaderLength
 				+ sizeof(uint32_t);
-		Memcpy(data, get_random_cursor, *size);
+		memcpy(data, get_random_cursor, *size);
 	}
 
 	return result;
diff --git a/firmware/lib/utility_string.c b/firmware/lib/utility_string.c
index 361d1809..63e43c68 100644
--- a/firmware/lib/utility_string.c
+++ b/firmware/lib/utility_string.c
@@ -47,7 +47,7 @@ uint32_t Uint64ToString(char *buf, uint32_t bufsize, uint64_t value,
 	}
 
 	/* Now copy the string back to the input buffer. */
-	Memcpy(buf, s, usedsize);
+	memcpy(buf, s, usedsize);
 
 	/* Don't count the terminating null in the bytes used */
 	return usedsize - 1;
diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c
index 4aa2fbdc..6a2aba32 100644
--- a/firmware/lib/vboot_api_kernel.c
+++ b/firmware/lib/vboot_api_kernel.c
@@ -1082,7 +1082,7 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 	VbNvSetup(&vnc);
 
 	/* Fill in params for calls to LoadKernel() */
-	Memset(&p, 0, sizeof(p));
+	memset(&p, 0, sizeof(p));
 	p.shared_data_blob = cparams->shared_data_blob;
 	p.shared_data_size = cparams->shared_data_size;
 	p.gbb_data = cparams->gbb_data;
@@ -1103,7 +1103,7 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 	kparams->bootloader_address = 0;
 	kparams->bootloader_size = 0;
 	kparams->flags = 0;
-	Memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
+	memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
 
 	cparams->bmp = NULL;
 	cparams->gbb = VbExMalloc(sizeof(*cparams->gbb));
@@ -1171,7 +1171,7 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 
 	/* Read FWMP.  Ignore errors in recovery mode. */
 	if (cparams->gbb->flags & GBB_FLAG_DISABLE_FWMP) {
-		Memset(&fwmp, 0, sizeof(fwmp));
+		memset(&fwmp, 0, sizeof(fwmp));
 		tpm_status = 0;
 	} else {
 		tpm_status = RollbackFwmpRead(&fwmp);
@@ -1290,7 +1290,7 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 	kparams->bootloader_address = p.bootloader_address;
 	kparams->bootloader_size = (uint32_t)p.bootloader_size;
 	kparams->flags = p.flags;
-	Memcpy(kparams->partition_guid, p.partition_guid,
+	memcpy(kparams->partition_guid, p.partition_guid,
 	       sizeof(kparams->partition_guid));
 
 	/* Lock the kernel versions.  Ignore errors in recovery mode. */
@@ -1349,7 +1349,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
 	kparams->bootloader_address = 0;
 	kparams->bootloader_size = 0;
 	kparams->flags = 0;
-	Memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
+	memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
 
 	kbuf = boot_image;
 
diff --git a/firmware/lib/vboot_audio.c b/firmware/lib/vboot_audio.c
index 6071b0db..bc974953 100644
--- a/firmware/lib/vboot_audio.c
+++ b/firmware/lib/vboot_audio.c
@@ -88,7 +88,7 @@ static void VbGetDevMusicNotes(VbAudioContext *audio, int use_short)
 	if (!hdr || maxsize < sizeof(VbDevMusic))
 		goto nope;
 
-	if (0 != Memcmp(hdr->sig, "$SND", sizeof(hdr->sig))) {
+	if (0 != memcmp(hdr->sig, "$SND", sizeof(hdr->sig))) {
 		VBDEBUG(("VbGetDevMusicNotes: bad sig\n"));
 		goto nope;
 	}
@@ -171,7 +171,7 @@ static void VbGetDevMusicNotes(VbAudioContext *audio, int use_short)
 
 	/* Looks good. Allocate the space (plus one) and copy it over. */
 	notebuf = VbExMalloc((hdr->count + 1) * sizeof(VbDevMusicNote));
-	Memcpy(notebuf, hdr->notes, hdr->count * sizeof(VbDevMusicNote));
+	memcpy(notebuf, hdr->notes, hdr->count * sizeof(VbDevMusicNote));
 	count = hdr->count;
 
 	/* We also require at least 30 seconds of delay. */
@@ -224,7 +224,7 @@ VbAudioContext *VbAudioOpen(VbCommonParams *cparams)
 		ticks_per_msec));
 
 	/* Initialize */
-	Memset(audio, 0, sizeof(*audio));
+	memset(audio, 0, sizeof(*audio));
 	audio->background_beep = 1;
 	audio->play_until = b;                /* "zero" starts now */
 
diff --git a/firmware/lib/vboot_common.c b/firmware/lib/vboot_common.c
index 49929151..b691fc36 100644
--- a/firmware/lib/vboot_common.c
+++ b/firmware/lib/vboot_common.c
@@ -119,7 +119,7 @@ int PublicKeyCopy(VbPublicKey *dest, const VbPublicKey *src)
 	dest->key_size = src->key_size;
 	dest->algorithm = src->algorithm;
 	dest->key_version = src->key_version;
-	Memcpy(GetPublicKeyData(dest), GetPublicKeyDataC(src), src->key_size);
+	memcpy(GetPublicKeyData(dest), GetPublicKeyDataC(src), src->key_size);
 	return 0;
 }
 
diff --git a/firmware/lib/vboot_common_init.c b/firmware/lib/vboot_common_init.c
index 2f3cf385..90edae68 100644
--- a/firmware/lib/vboot_common_init.c
+++ b/firmware/lib/vboot_common_init.c
@@ -30,7 +30,7 @@ int VbSharedDataInit(VbSharedDataHeader *header, uint64_t size)
 		return VBOOT_SHARED_DATA_INVALID;
 
 	/* Zero the header */
-	Memset(header, 0, sizeof(VbSharedDataHeader));
+	memset(header, 0, sizeof(VbSharedDataHeader));
 
 	/* Initialize fields */
 	header->magic = VB_SHARED_DATA_MAGIC;
diff --git a/firmware/lib/vboot_display.c b/firmware/lib/vboot_display.c
index 2ef87034..2f3a15e1 100644
--- a/firmware/lib/vboot_display.c
+++ b/firmware/lib/vboot_display.c
@@ -726,7 +726,7 @@ VbError_t VbCheckDisplayKey(VbCommonParams *cparams, uint32_t key,
 		return VbDisplayScreen(cparams, disp_current_screen, 1, vncptr);
 	}
 
-	if (0 == Memcmp(MagicBuffer, MAGIC_WORD, MAGIC_WORD_LEN)) {
+	if (0 == memcmp(MagicBuffer, MAGIC_WORD, MAGIC_WORD_LEN)) {
 		if (VBEASTEREGG)
 			(void)VbDisplayScreen(cparams, disp_current_screen,
 					      1, vncptr);
diff --git a/firmware/lib/vboot_kernel.c b/firmware/lib/vboot_kernel.c
index 4a7154ed..1e7b7d0d 100644
--- a/firmware/lib/vboot_kernel.c
+++ b/firmware/lib/vboot_kernel.c
@@ -94,7 +94,7 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
 	 */
 	shcall = shared->lk_calls + (shared->lk_call_count
 			& (VBSD_MAX_KERNEL_CALLS - 1));
-	Memset(shcall, 0, sizeof(VbSharedDataKernelCall));
+	memset(shcall, 0, sizeof(VbSharedDataKernelCall));
 	shcall->boot_flags = (uint32_t)params->boot_flags;
 	shcall->boot_mode = boot_mode;
 	shcall->sector_size = (uint32_t)params->bytes_per_lba;
@@ -168,7 +168,7 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
 		 */
 		shpart = shcall->parts + (shcall->kernel_parts_found
 				& (VBSD_MAX_KERNEL_PARTS - 1));
-		Memset(shpart, 0, sizeof(VbSharedDataKernelPart));
+		memset(shpart, 0, sizeof(VbSharedDataKernelPart));
 		shpart->sector_start = part_start;
 		shpart->sector_count = part_size;
 		/*
@@ -422,7 +422,7 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
 			if (body_copied > body_toread)
 				body_copied = body_toread;
 
-			Memcpy(body_readptr, kbuf + body_offset, body_copied);
+			memcpy(body_readptr, kbuf + body_offset, body_copied);
 			body_toread -= body_copied;
 			body_readptr += body_copied;
 		}
diff --git a/firmware/lib/vboot_nvstorage.c b/firmware/lib/vboot_nvstorage.c
index c131f088..69feef29 100644
--- a/firmware/lib/vboot_nvstorage.c
+++ b/firmware/lib/vboot_nvstorage.c
@@ -81,7 +81,7 @@ int VbNvSetup(VbNvContext *context)
 	if ((HEADER_SIGNATURE != (raw[HEADER_OFFSET] & HEADER_MASK))
 	    || (Crc8(raw, CRC_OFFSET) != raw[CRC_OFFSET])) {
 		/* Data is inconsistent (bad CRC or header); reset defaults */
-		Memset(raw, 0, VBNV_BLOCK_SIZE);
+		memset(raw, 0, VBNV_BLOCK_SIZE);
 		raw[HEADER_OFFSET] = (HEADER_SIGNATURE |
 				      HEADER_FIRMWARE_SETTINGS_RESET |
 				      HEADER_KERNEL_SETTINGS_RESET);
diff --git a/firmware/stub/tpm_lite_stub.c b/firmware/stub/tpm_lite_stub.c
index 109b8c11..4d88d169 100644
--- a/firmware/stub/tpm_lite_stub.c
+++ b/firmware/stub/tpm_lite_stub.c
@@ -111,7 +111,7 @@ static VbError_t TpmExecute(const uint8_t *in, const uint32_t in_len,
 					       "output buffer\n");
 			} else {
 				*pout_len = n;
-				Memcpy(out, response, n);
+				memcpy(out, response, n);
 			}
 		}
 	}
diff --git a/firmware/stub/utility_stub.c b/firmware/stub/utility_stub.c
deleted file mode 100644
index a1daed08..00000000
--- a/firmware/stub/utility_stub.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Stub implementations of utility functions which call their linux-specific
- * equivalents.
- */
-
-#include <stdint.h>
-
-#define _STUB_IMPLEMENTATION_
-#include "utility.h"
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-
-int Memcmp(const void *src1, const void *src2, size_t n)
-{
-	return memcmp(src1, src2, n);
-}
-
-void *Memcpy(void *dest, const void *src, uint64_t n)
-{
-	return memcpy(dest, src, (size_t)n);
-}
-
-void *Memset(void *d, const uint8_t c, uint64_t n)
-{
-	return memset(d, c, n);
-}
-
-
diff --git a/futility/cmd_sign.c b/futility/cmd_sign.c
index cd46c8ba..661eb3da 100644
--- a/futility/cmd_sign.c
+++ b/futility/cmd_sign.c
@@ -241,7 +241,7 @@ int ft_sign_kern_preamble(const char *name, uint8_t *buf, uint32_t len,
 		/* If we're modifying an existing file, it's mmap'ed so that
 		 * all our modifications to the buffer will get flushed to
 		 * disk when we close it. */
-		Memcpy(kpart_data, vblock_data, vblock_size);
+		memcpy(kpart_data, vblock_data, vblock_size);
 	}
 
 	free(vblock_data);
diff --git a/futility/vb1_helper.c b/futility/vb1_helper.c
index 8e3cb2e5..fdd3ece0 100644
--- a/futility/vb1_helper.c
+++ b/futility/vb1_helper.c
@@ -188,7 +188,7 @@ static int PickApartVmlinuz(uint8_t *kernel_buf,
 		/* Copy the original zeropage data from kernel_buf into
 		 * g_param_data, then tweak a few fields for our purposes */
 		params = (struct linux_kernel_params *)(g_param_data);
-		Memcpy(&(params->setup_sects), &(lh->setup_sects),
+		memcpy(&(params->setup_sects), &(lh->setup_sects),
 		       offsetof(struct linux_kernel_params, e820_entries)
 		       - offsetof(struct linux_kernel_params, setup_sects));
 		params->boot_flag = 0;
@@ -220,7 +220,7 @@ static int PickApartVmlinuz(uint8_t *kernel_buf,
 	/* Keep just the 32-bit kernel. */
 	if (kernel32_size) {
 		g_kernel_size = kernel32_size;
-		Memcpy(g_kernel_data, kernel_buf + kernel32_start,
+		memcpy(g_kernel_data, kernel_buf + kernel32_start,
 		       g_kernel_size);
 	}
 
@@ -296,8 +296,8 @@ int UpdateKernelBlobConfig(uint8_t *kblob_data, uint32_t kblob_size,
 		return -1;
 	}
 
-	Memset(g_config_data, 0, g_config_size);
-	Memcpy(g_config_data, config_data, config_size);
+	memset(g_config_data, 0, g_config_size);
+	memcpy(g_config_data, config_data, config_size);
 
 	return 0;
 }
@@ -670,7 +670,7 @@ uint8_t *CreateKernelBlob(uint8_t *vmlinuz_buf, uint32_t vmlinuz_size,
 
 	/* Allocate space for the blob. */
 	g_kernel_blob_data = malloc(g_kernel_blob_size);
-	Memset(g_kernel_blob_data, 0, g_kernel_blob_size);
+	memset(g_kernel_blob_data, 0, g_kernel_blob_size);
 
 	/* Assign the sub-pointers */
 	g_kernel_data = g_kernel_blob_data + now;
@@ -718,10 +718,10 @@ uint8_t *CreateKernelBlob(uint8_t *vmlinuz_buf, uint32_t vmlinuz_size,
 	}
 
 	/* Copy the other bits too */
-	Memcpy(g_config_data, config_data, config_size);
-	Memcpy(g_bootloader_data, bootloader_data, bootloader_size);
+	memcpy(g_config_data, config_data, config_size);
+	memcpy(g_bootloader_data, bootloader_data, bootloader_size);
 	if (g_vmlinuz_header_size) {
-		Memcpy(g_vmlinuz_header_data,
+		memcpy(g_vmlinuz_header_data,
 		       vmlinuz_buf,
 		       g_vmlinuz_header_size);
 	}
diff --git a/host/arch/arm/lib/crossystem_arch.c b/host/arch/arm/lib/crossystem_arch.c
index 2f2a5437..27741783 100644
--- a/host/arch/arm/lib/crossystem_arch.c
+++ b/host/arch/arm/lib/crossystem_arch.c
@@ -279,7 +279,7 @@ static int VbReadNvStorage_disk(VbNvContext* vnc)
 			__FUNCTION__, nvctx_path);
 		goto out;
 	}
-	Memcpy(vnc->raw, sector+offset, size);
+	memcpy(vnc->raw, sector+offset, size);
 	rv = 0;
 
 out:
@@ -323,7 +323,7 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc)
 				__FUNCTION__, nvctx_path);
 			break;
 		}
-		Memcpy(sector+offset, vnc->raw, size);
+		memcpy(sector+offset, vnc->raw, size);
 		lseek(nvctx_fd, lba * SECTOR_SIZE, SEEK_SET);
 		rv = write(nvctx_fd, sector, SECTOR_SIZE);
 		if (rv <= 0) {
diff --git a/host/lib/signature_digest.c b/host/lib/signature_digest.c
index ca560c94..e90a56ed 100644
--- a/host/lib/signature_digest.c
+++ b/host/lib/signature_digest.c
@@ -23,8 +23,8 @@ uint8_t* PrependDigestInfo(unsigned int algorithm, uint8_t* digest)
 	const int digestinfo_size = digestinfo_size_map[algorithm];
 	const uint8_t* digestinfo = hash_digestinfo_map[algorithm];
 	uint8_t* p = malloc(digestinfo_size + digest_size);
-	Memcpy(p, digestinfo, digestinfo_size);
-	Memcpy(p + digestinfo_size, digest, digest_size);
+	memcpy(p, digestinfo, digestinfo_size);
+	memcpy(p + digestinfo_size, digest, digest_size);
 	return p;
 }
 
diff --git a/tests/cgptlib_test.c b/tests/cgptlib_test.c
index 65022a20..f1a91cdc 100644
--- a/tests/cgptlib_test.c
+++ b/tests/cgptlib_test.c
@@ -73,7 +73,7 @@ static void SetGuid(void *dest, uint32_t num)
 {
 	Guid g = {{{num,0xd450,0x44bc,0xa6,0x93,
 		    {0xb8,0xac,0x75,0x5f,0xcd,0x48}}}};
-	Memcpy(dest, &g, sizeof(Guid));
+	memcpy(dest, &g, sizeof(Guid));
 }
 
 /*
@@ -105,14 +105,14 @@ static void RefreshCrc32(GptData *gpt)
 
 static void ZeroHeaders(GptData *gpt)
 {
-	Memset(gpt->primary_header, 0, MAX_SECTOR_SIZE);
-	Memset(gpt->secondary_header, 0, MAX_SECTOR_SIZE);
+	memset(gpt->primary_header, 0, MAX_SECTOR_SIZE);
+	memset(gpt->secondary_header, 0, MAX_SECTOR_SIZE);
 }
 
 static void ZeroEntries(GptData *gpt)
 {
-	Memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
-	Memset(gpt->secondary_entries, 0, PARTITION_ENTRIES_SIZE);
+	memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
+	memset(gpt->secondary_entries, 0, PARTITION_ENTRIES_SIZE);
 }
 
 static void ZeroHeadersEntries(GptData *gpt)
@@ -134,7 +134,7 @@ static GptData *GetEmptyGptData(void)
 	static uint8_t secondary_header[MAX_SECTOR_SIZE];
 	static uint8_t secondary_entries[PARTITION_ENTRIES_SIZE];
 
-	Memset(&gpt, 0, sizeof(gpt));
+	memset(&gpt, 0, sizeof(gpt));
 	gpt.primary_header = primary_header;
 	gpt.primary_entries = primary_entries;
 	gpt.secondary_header = secondary_header;
@@ -172,7 +172,7 @@ static void BuildTestGptData(GptData *gpt)
 	/* Build primary */
 	header = (GptHeader *)gpt->primary_header;
 	entries = (GptEntry *)gpt->primary_entries;
-	Memcpy(header->signature, GPT_HEADER_SIGNATURE,
+	memcpy(header->signature, GPT_HEADER_SIGNATURE,
 	       GPT_HEADER_SIGNATURE_SIZE);
 	header->revision = GPT_HEADER_REVISION;
 	header->size = sizeof(GptHeader);
@@ -185,19 +185,19 @@ static void BuildTestGptData(GptData *gpt)
 	  /* 512B / 128B * 32sectors = 128 entries */
 	header->number_of_entries = 128;
 	header->size_of_entry = 128;  /* bytes */
-	Memcpy(&entries[0].type, &chromeos_kernel, sizeof(chromeos_kernel));
+	memcpy(&entries[0].type, &chromeos_kernel, sizeof(chromeos_kernel));
 	SetGuid(&entries[0].unique, 0);
 	entries[0].starting_lba = 34;
 	entries[0].ending_lba = 133;
-	Memcpy(&entries[1].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
+	memcpy(&entries[1].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
 	SetGuid(&entries[1].unique, 1);
 	entries[1].starting_lba = 134;
 	entries[1].ending_lba = 232;
-	Memcpy(&entries[2].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
+	memcpy(&entries[2].type, &chromeos_rootfs, sizeof(chromeos_rootfs));
 	SetGuid(&entries[2].unique, 2);
 	entries[2].starting_lba = 234;
 	entries[2].ending_lba = 331;
-	Memcpy(&entries[3].type, &chromeos_kernel, sizeof(chromeos_kernel));
+	memcpy(&entries[3].type, &chromeos_kernel, sizeof(chromeos_kernel));
 	SetGuid(&entries[3].unique, 3);
 	entries[3].starting_lba = 334;
 	entries[3].ending_lba = 430;
@@ -205,8 +205,8 @@ static void BuildTestGptData(GptData *gpt)
 	/* Build secondary */
 	header2 = (GptHeader *)gpt->secondary_header;
 	entries2 = (GptEntry *)gpt->secondary_entries;
-	Memcpy(header2, header, sizeof(GptHeader));
-	Memcpy(entries2, entries, PARTITION_ENTRIES_SIZE);
+	memcpy(header2, header, sizeof(GptHeader));
+	memcpy(entries2, entries, PARTITION_ENTRIES_SIZE);
 	header2->my_lba = DEFAULT_DRIVE_SECTORS - 1;  /* 466 */
 	header2->alternate_lba = 1;
 	header2->entries_lba = DEFAULT_DRIVE_SECTORS - 1 - 32;  /* 434 */
@@ -314,43 +314,43 @@ static int HeaderSameTest(void)
 
 	EXPECT(0 == HeaderFieldsSame(h1, h2));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.signature[0] ^= 0xba;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.revision++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.size++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.reserved_zero++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.first_usable_lba++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.last_usable_lba++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.disk_uuid.u.raw[0] ^= 0xba;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.number_of_entries++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.size_of_entry++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
-	Memcpy(&h3, h2, sizeof(h3));
+	memcpy(&h3, h2, sizeof(h3));
 	h3.entries_crc32++;
 	EXPECT(1 == HeaderFieldsSame(h1, &h3));
 
@@ -738,7 +738,7 @@ static int ValidEntryTest(void)
 
 	/* case: non active entry should be ignored. */
 	BuildTestGptData(gpt);
-	Memset(&e1[1].type, 0, sizeof(e1[1].type));
+	memset(&e1[1].type, 0, sizeof(e1[1].type));
 	e1[1].starting_lba = e1[1].ending_lba + 1;
 	RefreshCrc32(gpt);
 	EXPECT(0 == CheckEntries(e1, h1));
@@ -809,7 +809,7 @@ static int OverlappedPartitionTest(void) {
 				break;
 
 			if (cases[i].entries[j].active) {
-				Memcpy(&e[j].type, &guid_kernel, sizeof(Guid));
+				memcpy(&e[j].type, &guid_kernel, sizeof(Guid));
 			}
 			SetGuid(&e[j].unique, j);
 			e[j].starting_lba = cases[i].entries[j].starting_lba;
@@ -1075,9 +1075,9 @@ static int SanityCheckTest(void)
 
 	/* Test correct recognition of IGNOREME in primary GPT. */
 	BuildTestGptData(gpt);
-	Memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
-	Memset(gpt->primary_header, 0, sizeof(GptHeader));
-	Memcpy(h1->signature, GPT_HEADER_SIGNATURE_IGNORED,
+	memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
+	memset(gpt->primary_header, 0, sizeof(GptHeader));
+	memcpy(h1->signature, GPT_HEADER_SIGNATURE_IGNORED,
 	       GPT_HEADER_SIGNATURE_SIZE);
 	EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
 	EXPECT(MASK_BOTH == gpt->valid_headers);
@@ -1087,9 +1087,9 @@ static int SanityCheckTest(void)
 
 	/* Test correct recognition of IGNOREME in secondary GPT. */
 	BuildTestGptData(gpt);
-	Memset(gpt->secondary_entries, 0, PARTITION_ENTRIES_SIZE);
-	Memset(gpt->secondary_header, 0, sizeof(GptHeader));
-	Memcpy(h2->signature, GPT_HEADER_SIGNATURE_IGNORED,
+	memset(gpt->secondary_entries, 0, PARTITION_ENTRIES_SIZE);
+	memset(gpt->secondary_header, 0, sizeof(GptHeader));
+	memcpy(h2->signature, GPT_HEADER_SIGNATURE_IGNORED,
 	       GPT_HEADER_SIGNATURE_SIZE);
 	EXPECT(GPT_SUCCESS == GptSanityCheck(gpt));
 	EXPECT(MASK_BOTH == gpt->valid_headers);
@@ -1099,9 +1099,9 @@ static int SanityCheckTest(void)
 
 	/* Test that two IGNOREME GPTs are invalid. */
 	ZeroHeadersEntries(gpt);
-	Memcpy(h1->signature, GPT_HEADER_SIGNATURE_IGNORED,
+	memcpy(h1->signature, GPT_HEADER_SIGNATURE_IGNORED,
 	       GPT_HEADER_SIGNATURE_SIZE);
-	Memcpy(h2->signature, GPT_HEADER_SIGNATURE_IGNORED,
+	memcpy(h2->signature, GPT_HEADER_SIGNATURE_IGNORED,
 	       GPT_HEADER_SIGNATURE_SIZE);
 	EXPECT(GPT_ERROR_INVALID_HEADERS == GptSanityCheck(gpt));
 	EXPECT(0 == gpt->valid_headers);
@@ -1111,9 +1111,9 @@ static int SanityCheckTest(void)
 
 	/* Test that one IGNOREME GPT and one corrupted one are invalid. */
 	BuildTestGptData(gpt);
-	Memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
-	Memset(gpt->primary_header, 0, sizeof(GptHeader));
-	Memcpy(h1->signature, GPT_HEADER_SIGNATURE_IGNORED,
+	memset(gpt->primary_entries, 0, PARTITION_ENTRIES_SIZE);
+	memset(gpt->primary_header, 0, sizeof(GptHeader));
+	memcpy(h1->signature, GPT_HEADER_SIGNATURE_IGNORED,
 	       GPT_HEADER_SIGNATURE_SIZE);
 	gpt->secondary_entries[0]++;
 	EXPECT(GPT_ERROR_INVALID_ENTRIES == GptSanityCheck(gpt));
@@ -1222,15 +1222,15 @@ static int EntryTypeTest(void)
 	GptData *gpt = GetEmptyGptData();
 	GptEntry *e = (GptEntry *)(gpt->primary_entries);
 
-	Memcpy(&e->type, &guid_zero, sizeof(Guid));
+	memcpy(&e->type, &guid_zero, sizeof(Guid));
 	EXPECT(1 == IsUnusedEntry(e));
 	EXPECT(0 == IsKernelEntry(e));
 
-	Memcpy(&e->type, &guid_kernel, sizeof(Guid));
+	memcpy(&e->type, &guid_kernel, sizeof(Guid));
 	EXPECT(0 == IsUnusedEntry(e));
 	EXPECT(1 == IsKernelEntry(e));
 
-	Memcpy(&e->type, &guid_rootfs, sizeof(Guid));
+	memcpy(&e->type, &guid_rootfs, sizeof(Guid));
 	EXPECT(0 == IsUnusedEntry(e));
 	EXPECT(0 == IsKernelEntry(e));
 
@@ -1240,14 +1240,14 @@ static int EntryTypeTest(void)
 /* Make an entry unused by clearing its type. */
 static void FreeEntry(GptEntry *e)
 {
-	Memset(&e->type, 0, sizeof(Guid));
+	memset(&e->type, 0, sizeof(Guid));
 }
 
 /* Set up an entry. */
 static void FillEntry(GptEntry *e, int is_kernel,
                       int priority, int successful, int tries)
 {
-	Memcpy(&e->type, (is_kernel ? &guid_kernel : &guid_zero), sizeof(Guid));
+	memcpy(&e->type, (is_kernel ? &guid_kernel : &guid_zero), sizeof(Guid));
 	SetEntryPriority(e, priority);
 	SetEntrySuccessful(e, successful);
 	SetEntryTries(e, tries);
@@ -1436,7 +1436,7 @@ static int GptUpdateTest(void)
 	EXPECT(0 == GetEntryTries(e + KERNEL_X));
 
 	/* Can't update if entry isn't a kernel, or there isn't an entry */
-	Memcpy(&e[KERNEL_X].type, &guid_rootfs, sizeof(guid_rootfs));
+	memcpy(&e[KERNEL_X].type, &guid_rootfs, sizeof(guid_rootfs));
 	EXPECT(GPT_ERROR_INVALID_UPDATE_TYPE ==
 	       GptUpdateKernelEntry(gpt, GPT_UPDATE_ENTRY_BAD));
 	gpt->current_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND;
@@ -1566,10 +1566,10 @@ static int GetKernelGuidTest(void)
 	BuildTestGptData(gpt);
 	gpt->current_kernel = 0;
 	GetCurrentKernelUniqueGuid(gpt, &g);
-	EXPECT(!Memcmp(&g, &e[0].unique, sizeof(Guid)));
+	EXPECT(!memcmp(&g, &e[0].unique, sizeof(Guid)));
 	gpt->current_kernel = 1;
 	GetCurrentKernelUniqueGuid(gpt, &g);
-	EXPECT(!Memcmp(&g, &e[1].unique, sizeof(Guid)));
+	EXPECT(!memcmp(&g, &e[1].unique, sizeof(Guid)));
 
 	return TEST_OK;
 }
diff --git a/tests/rollback_index2_tests.c b/tests/rollback_index2_tests.c
index b170a969..ec36d24d 100644
--- a/tests/rollback_index2_tests.c
+++ b/tests/rollback_index2_tests.c
@@ -77,14 +77,14 @@ static void ResetMocks(int fail_on_call, uint32_t fail_with_err)
 	fail_at_count = fail_on_call;
 	fail_with_error = fail_with_err;
 	noise_count = 0;
-	Memset(&noise_on, 0, sizeof(noise_on));
+	memset(&noise_on, 0, sizeof(noise_on));
 
-	Memset(&mock_pflags, 0, sizeof(mock_pflags));
-	Memset(&mock_rsf, 0, sizeof(mock_rsf));
-	Memset(&mock_rsk, 0, sizeof(mock_rsk));
+	memset(&mock_pflags, 0, sizeof(mock_pflags));
+	memset(&mock_rsf, 0, sizeof(mock_rsf));
+	memset(&mock_rsk, 0, sizeof(mock_rsk));
 	mock_permissions = 0;
 
-	Memset(mock_fwmp.buf, 0, sizeof(mock_fwmp.buf));
+	memset(mock_fwmp.buf, 0, sizeof(mock_fwmp.buf));
 	mock_fwmp.fwmp.struct_size = sizeof(mock_fwmp.fwmp);
 	mock_fwmp.fwmp.struct_version = ROLLBACK_SPACE_FWMP_VERSION;
 	mock_fwmp.fwmp.flags = 0x1234;
@@ -151,20 +151,20 @@ uint32_t TlclRead(uint32_t index, void* data, uint32_t length)
 
 	if (FIRMWARE_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsf), "TlclRead rsf size");
-		Memcpy(data, &mock_rsf, length);
+		memcpy(data, &mock_rsf, length);
 		MaybeInjectNoise(data, length);
 	} else if (KERNEL_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsk), "TlclRead rsk size");
-		Memcpy(data, &mock_rsk, length);
+		memcpy(data, &mock_rsk, length);
 		MaybeInjectNoise(data, length);
 	} else if (FWMP_NV_INDEX == index) {
-		Memset(data, 0, length);
+		memset(data, 0, length);
 		if (length > sizeof(mock_fwmp))
 			length = sizeof(mock_fwmp);
-		Memcpy(data, &mock_fwmp, length);
+		memcpy(data, &mock_fwmp, length);
 		MaybeInjectNoise(data, length);
 	} else {
-		Memset(data, 0, length);
+		memset(data, 0, length);
 	}
 
 	return (++mock_count == fail_at_count) ? fail_with_error : TPM_SUCCESS;
@@ -177,11 +177,11 @@ uint32_t TlclWrite(uint32_t index, const void *data, uint32_t length)
 
 	if (FIRMWARE_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsf), "TlclWrite rsf size");
-		Memcpy(&mock_rsf, data, length);
+		memcpy(&mock_rsf, data, length);
 		MaybeInjectNoise(&mock_rsf, length);
 	} else if (KERNEL_NV_INDEX == index) {
 		TEST_EQ(length, sizeof(mock_rsk), "TlclWrite rsk size");
-		Memcpy(&mock_rsk, data, length);
+		memcpy(&mock_rsk, data, length);
 		MaybeInjectNoise(&mock_rsk, length);
 	}
 
@@ -210,7 +210,7 @@ uint32_t TlclContinueSelfTest(void)
 uint32_t TlclGetPermanentFlags(TPM_PERMANENT_FLAGS *pflags)
 {
 	mock_cnext += sprintf(mock_cnext, "TlclGetPermanentFlags()\n");
-	Memcpy(pflags, &mock_pflags, sizeof(mock_pflags));
+	memcpy(pflags, &mock_pflags, sizeof(mock_pflags));
 	return (++mock_count == fail_at_count) ? fail_with_error : TPM_SUCCESS;
 }
 
@@ -307,7 +307,7 @@ static void CrcTestFirmware(void)
 
 	/* A write with version < 2 should convert to v2 and create the CRC */
 	ResetMocks(0, 0);
-	Memset(&rsf, 0, sizeof(rsf));
+	memset(&rsf, 0, sizeof(rsf));
 	TEST_EQ(WriteSpaceFirmware(&rsf), 0, "WriteSpaceFirmware(), v0");
 	TEST_EQ(mock_rsf.struct_version, 2, "WriteSpaceFirmware(), check v2");
 	TEST_STR_EQ(mock_calls,
@@ -317,7 +317,7 @@ static void CrcTestFirmware(void)
 
 	/* Same as above, but with some noise during the readback */
 	ResetMocks(0, 0);
-	Memset(&rsf, 0, sizeof(rsf));
+	memset(&rsf, 0, sizeof(rsf));
 	noise_on[1] = 1;
 	noise_on[2] = 1;
 	TEST_EQ(WriteSpaceFirmware(&rsf), 0,
@@ -331,7 +331,7 @@ static void CrcTestFirmware(void)
 
 	/* With noise during the write, we'll try the write again */
 	ResetMocks(0, 0);
-	Memset(&rsf, 0, sizeof(rsf));
+	memset(&rsf, 0, sizeof(rsf));
 	noise_on[0] = 1;
 	TEST_EQ(WriteSpaceFirmware(&rsf), 0,
 		"WriteSpaceFirmware(), write noise");
@@ -347,8 +347,8 @@ static void CrcTestFirmware(void)
 
 	/* Only if it just keeps on failing forever do we eventually give up */
 	ResetMocks(0, 0);
-	Memset(&rsf, 0, sizeof(rsf));
-	Memset(noise_on, 1, sizeof(noise_on));
+	memset(&rsf, 0, sizeof(rsf));
+	memset(noise_on, 1, sizeof(noise_on));
 	TEST_EQ(WriteSpaceFirmware(&rsf), TPM_E_CORRUPTED_STATE,
 		"WriteSpaceFirmware(), always noise");
 	TEST_STR_EQ(mock_calls,
@@ -409,7 +409,7 @@ static void CrcTestKernel(void)
 
 	/* A write with version < 2 should convert to v2 and create the CRC */
 	ResetMocks(0, 0);
-	Memset(&rsk, 0, sizeof(rsk));
+	memset(&rsk, 0, sizeof(rsk));
 	TEST_EQ(WriteSpaceKernel(&rsk), 0, "WriteSpaceKernel(), v0");
 	TEST_EQ(mock_rsk.struct_version, 2, "WriteSpaceKernel(), check v2");
 	TEST_STR_EQ(mock_calls,
@@ -419,7 +419,7 @@ static void CrcTestKernel(void)
 
 	/* Same as above, but with some noise during the readback */
 	ResetMocks(0, 0);
-	Memset(&rsk, 0, sizeof(rsk));
+	memset(&rsk, 0, sizeof(rsk));
 	noise_on[1] = 1;
 	noise_on[2] = 1;
 	TEST_EQ(WriteSpaceKernel(&rsk), 0, "WriteSpaceKernel(), read noise");
@@ -432,7 +432,7 @@ static void CrcTestKernel(void)
 
 	/* With noise during the write, we'll try the write again */
 	ResetMocks(0, 0);
-	Memset(&rsk, 0, sizeof(rsk));
+	memset(&rsk, 0, sizeof(rsk));
 	noise_on[0] = 1;
 	TEST_EQ(WriteSpaceKernel(&rsk), 0, "WriteSpaceKernel(), write noise");
 	TEST_EQ(mock_rsk.struct_version, 2, "WriteSpaceKernel(), check v2");
@@ -447,8 +447,8 @@ static void CrcTestKernel(void)
 
 	/* Only if it just keeps on failing forever do we eventually give up */
 	ResetMocks(0, 0);
-	Memset(&rsk, 0, sizeof(rsk));
-	Memset(noise_on, 1, sizeof(noise_on));
+	memset(&rsk, 0, sizeof(rsk));
+	memset(noise_on, 1, sizeof(noise_on));
 	TEST_EQ(WriteSpaceKernel(&rsk), TPM_E_CORRUPTED_STATE,
 		"WriteSpaceKernel(), always noise");
 	TEST_STR_EQ(mock_calls,
@@ -591,7 +591,7 @@ static void RollbackFwmpTest(void)
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x100a, 40)\n",
 		    "  tlcl calls");
-	TEST_EQ(0, Memcmp(&fwmp, &mock_fwmp, sizeof(fwmp)), "  data");
+	TEST_EQ(0, memcmp(&fwmp, &mock_fwmp, sizeof(fwmp)), "  data");
 
 	/* Read error */
 	ResetMocks(1, TPM_E_IOERROR);
@@ -600,7 +600,7 @@ static void RollbackFwmpTest(void)
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x100a, 40)\n",
 		    "  tlcl calls");
-	TEST_EQ(0, Memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data clear");
+	TEST_EQ(0, memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data clear");
 
 	/* Not present isn't an error; just returns empty data */
 	ResetMocks(1, TPM_E_BADINDEX);
@@ -608,7 +608,7 @@ static void RollbackFwmpTest(void)
 	TEST_STR_EQ(mock_calls,
 		    "TlclRead(0x100a, 40)\n",
 		    "  tlcl calls");
-	TEST_EQ(0, Memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data clear");
+	TEST_EQ(0, memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data clear");
 
 	/* Struct size too small */
 	ResetMocks(0, 0);
@@ -625,7 +625,7 @@ static void RollbackFwmpTest(void)
 		    "TlclRead(0x100a, 40)\n"
 		    "TlclRead(0x100a, 44)\n",
 		    "  tlcl calls");
-	TEST_EQ(0, Memcmp(&fwmp, &mock_fwmp, sizeof(fwmp)), "  data");
+	TEST_EQ(0, memcmp(&fwmp, &mock_fwmp, sizeof(fwmp)), "  data");
 
 	/* Bad CRC causes retry, then eventual failure */
 	ResetMocks(0, 0);
@@ -653,14 +653,14 @@ static void RollbackFwmpTest(void)
 		    "TlclRead(0x100a, 40)\n"
 		    "TlclRead(0x100a, 44)\n",
 		    "  tlcl calls");
-	TEST_EQ(0, Memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data");
+	TEST_EQ(0, memcmp(&fwmp, &fwmp_zero, sizeof(fwmp)), "  data");
 
 	/* Minor version difference ok */
 	ResetMocks(0, 0);
 	mock_fwmp.fwmp.struct_version++;
 	RecalcFwmpCrc();
 	TEST_EQ(RollbackFwmpRead(&fwmp), 0, "RollbackFwmpRead() minor version");
-	TEST_EQ(0, Memcmp(&fwmp, &mock_fwmp, sizeof(fwmp)), "  data");
+	TEST_EQ(0, memcmp(&fwmp, &mock_fwmp, sizeof(fwmp)), "  data");
 
 	/* Major version difference not ok */
 	ResetMocks(0, 0);
diff --git a/tests/rsa_padding_test.c b/tests/rsa_padding_test.c
index 2f2423b9..c97acee0 100644
--- a/tests/rsa_padding_test.c
+++ b/tests/rsa_padding_test.c
@@ -50,12 +50,12 @@ static void TestRSAVerify(RSAPublicKey* key) {
                     test_message_sha1_hash), 0, "RSAVerify() wrong alg");
 
   /* Corrupt the signature near start and end */
-  Memcpy(sig, signatures[0], RSA1024NUMBYTES);
+  memcpy(sig, signatures[0], RSA1024NUMBYTES);
   sig[3] ^= 0x42;
   TEST_EQ(RSAVerify(key, sig, RSA1024NUMBYTES, 0, test_message_sha1_hash), 0,
           "RSAVerify() bad sig");
 
-  Memcpy(sig, signatures[0], RSA1024NUMBYTES);
+  memcpy(sig, signatures[0], RSA1024NUMBYTES);
   sig[RSA1024NUMBYTES - 3] ^= 0x56;
   TEST_EQ(RSAVerify(key, sig, RSA1024NUMBYTES, 0, test_message_sha1_hash), 0,
           "RSAVerify() bad sig end");
diff --git a/tests/rsa_utility_tests.c b/tests/rsa_utility_tests.c
index 0ac3f5e7..df1480ad 100644
--- a/tests/rsa_utility_tests.c
+++ b/tests/rsa_utility_tests.c
@@ -79,7 +79,7 @@ static void TestKeyFromBuffer(void) {
 
   for (i = 0; i < 4; i++) {
     uint32_t key_len = RSA1024NUMBYTES << i;
-    Memset(buf, 0xAB, 8 + 2 * RSA8192NUMBYTES);
+    memset(buf, 0xAB, 8 + 2 * RSA8192NUMBYTES);
     *buf_key_len = key_len / sizeof(uint32_t);
     *(buf_key_len + 1) = 0xF00D2345;  /* n0inv */
     buf[8] = 100;
diff --git a/tests/vb20_common3_tests.c b/tests/vb20_common3_tests.c
index 24029293..b4e5bf5e 100644
--- a/tests/vb20_common3_tests.c
+++ b/tests/vb20_common3_tests.c
@@ -47,67 +47,67 @@ static void test_check_keyblock(const struct vb2_public_key *public_key,
 	h = (struct vb2_keyblock *)malloc(hsize + 2048);
 	sig = &h->keyblock_signature;
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_check_keyblock(h, hsize, sig),
 		  "vb2_check_keyblock() ok");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_EQ(vb2_check_keyblock(h, hsize - 1, sig),
 		VB2_ERROR_KEYBLOCK_SIZE, "vb2_check_keyblock() size--");
 
 	/* Buffer is allowed to be bigger than keyblock */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_check_keyblock(h, hsize + 1, sig),
 		  "vb2_check_keyblock() size++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->magic[0] &= 0x12;
 	TEST_EQ(vb2_check_keyblock(h, hsize, sig),
 		VB2_ERROR_KEYBLOCK_MAGIC, "vb2_check_keyblock() magic");
 
 	/* Care about major version but not minor */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major++;
 	resign_keyblock(h, private_key);
 	TEST_EQ(vb2_check_keyblock(h, hsize, sig),
 		VB2_ERROR_KEYBLOCK_HEADER_VERSION,
 		"vb2_check_keyblock() major++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major--;
 	resign_keyblock(h, private_key);
 	TEST_EQ(vb2_check_keyblock(h, hsize, sig),
 		VB2_ERROR_KEYBLOCK_HEADER_VERSION,
 		"vb2_check_keyblock() major--");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor++;
 	resign_keyblock(h, private_key);
 	TEST_SUCC(vb2_check_keyblock(h, hsize, sig),
 		  "vb2_check_keyblock() minor++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor--;
 	resign_keyblock(h, private_key);
 	TEST_SUCC(vb2_check_keyblock(h, hsize, sig),
 		  "vb2_check_keyblock() minor--");
 
 	/* Check signature */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->keyblock_signature.sig_offset = hsize;
 	resign_keyblock(h, private_key);
 	TEST_EQ(vb2_check_keyblock(h, hsize, sig),
 		VB2_ERROR_KEYBLOCK_SIG_OUTSIDE,
 		"vb2_check_keyblock() sig off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->keyblock_signature.data_size = h->keyblock_size + 1;
 	TEST_EQ(vb2_check_keyblock(h, hsize, sig),
 		VB2_ERROR_KEYBLOCK_SIGNED_TOO_MUCH,
 		"vb2_check_keyblock() sig data past end of block");
 
 	/* Check that we signed header and data key */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->keyblock_signature.data_size = 4;
 	h->data_key.key_offset = 0;
 	h->data_key.key_size = 0;
@@ -116,7 +116,7 @@ static void test_check_keyblock(const struct vb2_public_key *public_key,
 		VB2_ERROR_KEYBLOCK_SIGNED_TOO_LITTLE,
 		"vb2_check_keyblock() didn't sign header");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->data_key.key_offset = hsize;
 	resign_keyblock(h, private_key);
 	TEST_EQ(vb2_check_keyblock(h, hsize, sig),
@@ -157,24 +157,24 @@ static void test_verify_keyblock(const struct vb2_public_key *public_key,
 	hsize = hdr->keyblock_size;
 	h = (struct vb2_keyblock *)malloc(hsize + 2048);
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_verify_keyblock(h, hsize, public_key, &wb),
 		  "vb2_verify_keyblock() ok using key");
 
 	/* Failures in keyblock check also cause verify to fail */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_EQ(vb2_verify_keyblock(h, hsize - 1, public_key, &wb),
 		VB2_ERROR_KEYBLOCK_SIZE, "vb2_verify_keyblock() check");
 
 	/* Check signature */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->keyblock_signature.sig_size--;
 	resign_keyblock(h, private_key);
 	TEST_EQ(vb2_verify_keyblock(h, hsize, public_key, &wb),
 		VB2_ERROR_KEYBLOCK_SIG_INVALID,
 		"vb2_verify_keyblock() sig too small");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	((uint8_t *)vb2_packed_key_data(&h->data_key))[0] ^= 0x34;
 	TEST_EQ(vb2_verify_keyblock(h, hsize, public_key, &wb),
 		VB2_ERROR_KEYBLOCK_SIG_INVALID,
@@ -232,47 +232,47 @@ static void test_verify_fw_preamble(struct vb2_packed_key *public_key,
 	hsize = (uint32_t) hdr->preamble_size;
 	h = (struct vb2_fw_preamble *)malloc(hsize + 16384);
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		  "vb2_verify_fw_preamble() ok using key");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_EQ(vb2_verify_fw_preamble(h, 4, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_TOO_SMALL_FOR_HEADER,
 		"vb2_verify_fw_preamble() size tiny");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize - 1, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIZE,
 		"vb2_verify_fw_preamble() size--");
 
 	/* Buffer is allowed to be bigger than preamble */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_verify_fw_preamble(h, hsize + 1, &rsa, &wb),
 		  "vb2_verify_fw_preamble() size++");
 
 	/* Care about major version but not minor */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major++;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_HEADER_VERSION
 		, "vb2_verify_fw_preamble() major++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major--;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_HEADER_VERSION,
 		"vb2_verify_fw_preamble() major--");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor++;
 	resign_fw_preamble(h, private_key);
 	TEST_SUCC(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		  "vb2_verify_fw_preamble() minor++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor--;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
@@ -280,28 +280,28 @@ static void test_verify_fw_preamble(struct vb2_packed_key *public_key,
 		"vb2_verify_fw_preamble() 2.0 not supported");
 
 	/* Check signature */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.sig_offset = hsize;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIG_OUTSIDE,
 		"vb2_verify_fw_preamble() sig off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.sig_size--;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"vb2_verify_fw_preamble() sig too small");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	((uint8_t *)vb2_packed_key_data(&h->kernel_subkey))[0] ^= 0x34;
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"vb2_verify_fw_preamble() sig mismatch");
 
 	/* Check that we signed header, kernel subkey, and body sig */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.data_size = 4;
 	h->kernel_subkey.key_offset = 0;
 	h->kernel_subkey.key_size = 0;
@@ -312,14 +312,14 @@ static void test_verify_fw_preamble(struct vb2_packed_key *public_key,
 		VB2_ERROR_PREAMBLE_SIGNED_TOO_LITTLE,
 		"vb2_verify_fw_preamble() didn't sign header");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->kernel_subkey.key_offset = hsize;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_KERNEL_SUBKEY_OUTSIDE,
 		"vb2_verify_fw_preamble() kernel subkey off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->body_signature.sig_offset = hsize;
 	resign_fw_preamble(h, private_key);
 	TEST_EQ(vb2_verify_fw_preamble(h, hsize, &rsa, &wb),
@@ -378,69 +378,69 @@ static void test_verify_kernel_preamble(
 	struct vb2_kernel_preamble *h =
 		(struct vb2_kernel_preamble *)malloc(hsize + 16384);
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		  "vb2_verify_kernel_preamble() ok using key");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_EQ(vb2_verify_kernel_preamble(h, 4, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_TOO_SMALL_FOR_HEADER,
 		"vb2_verify_kernel_preamble() size tiny");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize - 1, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIZE,
 		"vb2_verify_kernel_preamble() size--");
 
 	/* Buffer is allowed to be bigger than preamble */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	TEST_SUCC(vb2_verify_kernel_preamble(h, hsize + 1, &rsa, &wb),
 		  "vb2_verify_kernel_preamble() size++");
 
 	/* Care about major version but not minor */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major++;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_HEADER_VERSION
 		, "vb2_verify_kernel_preamble() major++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major--;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_HEADER_VERSION,
 		"vb2_verify_kernel_preamble() major--");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor++;
 	resign_kernel_preamble(h, private_key);
 	TEST_SUCC(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		  "vb2_verify_kernel_preamble() minor++");
 
 	/* Check signature */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.sig_offset = hsize;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIG_OUTSIDE,
 		"vb2_verify_kernel_preamble() sig off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.sig_size--;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"vb2_verify_kernel_preamble() sig too small");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->flags++;
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"vb2_verify_kernel_preamble() sig mismatch");
 
 	/* Check that we signed header and body sig */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.data_size = 4;
 	h->body_signature.sig_offset = 0;
 	h->body_signature.sig_size = 0;
@@ -449,7 +449,7 @@ static void test_verify_kernel_preamble(
 		VB2_ERROR_PREAMBLE_SIGNED_TOO_LITTLE,
 		"vb2_verify_kernel_preamble() didn't sign header");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->body_signature.sig_offset = hsize;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
@@ -457,14 +457,14 @@ static void test_verify_kernel_preamble(
 		"vb2_verify_kernel_preamble() body sig off end");
 
 	/* Check bootloader inside signed body */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->bootloader_address = h->body_load_address - 1;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_BOOTLOADER_OUTSIDE,
 		"vb2_verify_kernel_preamble() bootloader before body");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->bootloader_address = h->body_load_address +
 		h->body_signature.data_size + 1;
 	resign_kernel_preamble(h, private_key);
@@ -472,7 +472,7 @@ static void test_verify_kernel_preamble(
 		VB2_ERROR_PREAMBLE_BOOTLOADER_OUTSIDE,
 		"vb2_verify_kernel_preamble() bootloader off end of body");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->bootloader_address = h->body_load_address +
 		h->body_signature.data_size + 1;
 	h->bootloader_size = 0;
@@ -481,14 +481,14 @@ static void test_verify_kernel_preamble(
 		  "vb2_verify_kernel_preamble() no bootloader");
 
 	/* Check vmlinuz inside signed body */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->vmlinuz_header_address = h->body_load_address - 1;
 	resign_kernel_preamble(h, private_key);
 	TEST_EQ(vb2_verify_kernel_preamble(h, hsize, &rsa, &wb),
 		VB2_ERROR_PREAMBLE_VMLINUZ_HEADER_OUTSIDE,
 		"vb2_verify_kernel_preamble() vmlinuz_header before body");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->vmlinuz_header_address = h->body_load_address +
 		h->body_signature.data_size + 1;
 	resign_kernel_preamble(h, private_key);
@@ -496,7 +496,7 @@ static void test_verify_kernel_preamble(
 		VB2_ERROR_PREAMBLE_VMLINUZ_HEADER_OUTSIDE,
 		"vb2_verify_kernel_preamble() vmlinuz_header off end of body");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->vmlinuz_header_address = h->body_load_address +
 		h->body_signature.data_size + 1;
 	h->vmlinuz_header_size = 0;
diff --git a/tests/vb20_rsa_padding_tests.c b/tests/vb20_rsa_padding_tests.c
index 3bbebcf6..6fe2e970 100644
--- a/tests/vb20_rsa_padding_tests.c
+++ b/tests/vb20_rsa_padding_tests.c
@@ -52,14 +52,14 @@ static void test_signatures(const struct vb2_public_key *key)
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
 
 	/* The first test signature is valid. */
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	TEST_SUCC(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		  "RSA Padding Test valid sig");
 
 	/* All other signatures should fail verification. */
 	unexpected_success = 0;
 	for (i = 1; i < sizeof(signatures) / sizeof(signatures[0]); i++) {
-		Memcpy(sig, signatures[i], sizeof(sig));
+		memcpy(sig, signatures[i], sizeof(sig));
 		if (!vb2_rsa_verify_digest(key, sig,
 					   test_message_sha1_hash, &wb)) {
 			fprintf(stderr,
@@ -83,11 +83,11 @@ static void test_verify_digest(struct vb2_public_key *key) {
 
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
 
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	TEST_SUCC(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		  "vb2_rsa_verify_digest() good");
 
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	vb2_workbuf_init(&wb, workbuf, sizeof(sig) * 3 - 1);
 	TEST_EQ(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		VB2_ERROR_RSA_VERIFY_WORKBUF,
@@ -95,26 +95,26 @@ static void test_verify_digest(struct vb2_public_key *key) {
 	vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
 
 	key->sig_alg = VB2_SIG_INVALID;
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	TEST_EQ(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		VB2_ERROR_RSA_VERIFY_ALGORITHM,
 		"vb2_rsa_verify_digest() bad key alg");
 	key->sig_alg = orig_key_alg;
 
 	key->arrsize *= 2;
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	TEST_EQ(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		VB2_ERROR_RSA_VERIFY_SIG_LEN,
 		"vb2_rsa_verify_digest() bad sig len");
 	key->arrsize /= 2;
 
 	/* Corrupt the signature near start and end */
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	sig[3] ^= 0x42;
 	TEST_EQ(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		VB2_ERROR_RSA_PADDING, "vb2_rsa_verify_digest() bad sig");
 
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	sig[RSA1024NUMBYTES - 3] ^= 0x56;
 	TEST_EQ(vb2_rsa_verify_digest(key, sig, test_message_sha1_hash, &wb),
 		VB2_ERROR_RSA_PADDING, "vb2_rsa_verify_digest() bad sig end");
diff --git a/tests/vb2_rsa_utility_tests.c b/tests/vb2_rsa_utility_tests.c
index 1293d50f..99282bf7 100644
--- a/tests/vb2_rsa_utility_tests.c
+++ b/tests/vb2_rsa_utility_tests.c
@@ -87,7 +87,7 @@ static void test_utils(void)
 		"Packed key size no signing algorithm");
 
 	/* Test padding check with bad algorithm */
-	Memcpy(sig, signatures[0], sizeof(sig));
+	memcpy(sig, signatures[0], sizeof(sig));
 	TEST_EQ(vb2_check_padding(sig, &kbad),
 		VB2_ERROR_RSA_PADDING_SIZE,
 		"vb2_check_padding() bad padding algorithm/size");
diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c
index cd927a88..be8cdf94 100644
--- a/tests/vboot_api_devmode_tests.c
+++ b/tests/vboot_api_devmode_tests.c
@@ -149,23 +149,23 @@ static note_event_t *expected_event;
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void) {
 
-  Memset(&cparams, 0, sizeof(cparams));
+  memset(&cparams, 0, sizeof(cparams));
   cparams.shared_data_size = sizeof(shared_data);
   cparams.shared_data_blob = shared_data;
   cparams.gbb_data = &gbb;
   cparams.gbb = &gbb;
 
-  Memset(&lkparams, 0, sizeof(lkparams));
+  memset(&lkparams, 0, sizeof(lkparams));
 
-  Memset(&vnc, 0, sizeof(vnc));
+  memset(&vnc, 0, sizeof(vnc));
   VbNvSetup(&vnc);
   VbNvTeardown(&vnc);  /* So CRC gets generated */
 
-  Memset(&shared_data, 0, sizeof(shared_data));
+  memset(&shared_data, 0, sizeof(shared_data));
   VbSharedDataInit(shared, sizeof(shared_data));
   shared->fw_keyblock_flags = 0xABCDE0;
 
-  Memset(&gbb, 0, sizeof(gbb));
+  memset(&gbb, 0, sizeof(gbb));
   gbb.major_version = GBB_MAJOR_VER;
   gbb.minor_version = GBB_MINOR_VER;
   gbb.flags = 0;
@@ -187,12 +187,12 @@ static void ResetMocks(void) {
 /* Mocked verification functions */
 
 VbError_t VbExNvStorageRead(uint8_t* buf) {
-  Memcpy(buf, vnc.raw, sizeof(vnc.raw));
+  memcpy(buf, vnc.raw, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
 VbError_t VbExNvStorageWrite(const uint8_t* buf) {
-  Memcpy(vnc.raw, buf, sizeof(vnc.raw));
+  memcpy(vnc.raw, buf, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index c0965a65..c0f31b46 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -51,13 +51,13 @@ extern struct RollbackSpaceFwmp *VbApiKernelGetFwmp(void);
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void)
 {
-	Memset(&cparams, 0, sizeof(cparams));
+	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
 	cparams.gbb = &gbb;
 
-	Memset(&gbb, 0, sizeof(gbb));
+	memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = GBB_MAJOR_VER;
 	gbb.minor_version = GBB_MINOR_VER;
 	gbb.flags = 0;
@@ -66,16 +66,16 @@ static void ResetMocks(void)
 	 * Only the outermost vboot_api_kernel call sets vboot_api_kernel's
 	 * vnc.  So clear it here too.
 	 */
-	Memset(VbApiKernelGetVnc(), 0, sizeof(VbNvContext));
+	memset(VbApiKernelGetVnc(), 0, sizeof(VbNvContext));
 	VbNvSetup(VbApiKernelGetVnc());
 	VbNvTeardown(VbApiKernelGetVnc()); /* So CRC gets generated */
 
-	Memset(VbApiKernelGetFwmp(), 0, sizeof(struct RollbackSpaceFwmp));
+	memset(VbApiKernelGetFwmp(), 0, sizeof(struct RollbackSpaceFwmp));
 
-	Memset(&shared_data, 0, sizeof(shared_data));
+	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 
-	Memset(&lkp, 0, sizeof(lkp));
+	memset(&lkp, 0, sizeof(lkp));
 
 	shutdown_request_calls_left = -1;
 	audio_looping_calls_left = 30;
@@ -85,18 +85,18 @@ static void ResetMocks(void)
 	virtdev_set = 0;
 	virtdev_retval = 0;
 
-	Memset(screens_displayed, 0, sizeof(screens_displayed));
+	memset(screens_displayed, 0, sizeof(screens_displayed));
 	screens_count = 0;
 
-	Memset(mock_keypress, 0, sizeof(mock_keypress));
-	Memset(mock_keyflags, 0, sizeof(mock_keyflags));
+	memset(mock_keypress, 0, sizeof(mock_keypress));
+	memset(mock_keyflags, 0, sizeof(mock_keyflags));
 	mock_keypress_count = 0;
 
-	Memset(mock_switches, 0, sizeof(mock_switches));
+	memset(mock_switches, 0, sizeof(mock_switches));
 	mock_switches_count = 0;
 	mock_switches_are_stuck = 0;
 
-	Memset(mock_num_disks, 0, sizeof(mock_num_disks));
+	memset(mock_num_disks, 0, sizeof(mock_num_disks));
 	mock_num_disks_count = 0;
 }
 
diff --git a/tests/vboot_api_kernel3_tests.c b/tests/vboot_api_kernel3_tests.c
index 6ca58f21..0a47fa8b 100644
--- a/tests/vboot_api_kernel3_tests.c
+++ b/tests/vboot_api_kernel3_tests.c
@@ -54,12 +54,12 @@ static uint32_t screens_count = 0;
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void)
 {
-	Memset(&cparams, 0, sizeof(cparams));
+	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
 
-	Memset(&gbb, 0, sizeof(gbb));
+	memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = GBB_MAJOR_VER;
 	gbb.minor_version = GBB_MINOR_VER;
 	gbb.flags = 0;
@@ -68,11 +68,11 @@ static void ResetMocks(void)
 	 * Only the outermost vboot_api_kernel call sets vboot_api_kernel's
 	 * vnc.  So clear it here too.
 	 */
-	Memset(VbApiKernelGetVnc(), 0, sizeof(VbNvContext));
+	memset(VbApiKernelGetVnc(), 0, sizeof(VbNvContext));
 	VbNvSetup(VbApiKernelGetVnc());
 	VbNvTeardown(VbApiKernelGetVnc()); /* So CRC gets generated */
 
-	Memset(&shared_data, 0, sizeof(shared_data));
+	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 
 	trust_ec = 0;
@@ -89,15 +89,15 @@ static void ResetMocks(void)
 	get_expected_retval = VBERROR_SUCCESS;
 	shutdown_request_calls_left = -1;
 
-	Memset(mock_ec_ro_hash, 0, sizeof(mock_ec_ro_hash));
+	memset(mock_ec_ro_hash, 0, sizeof(mock_ec_ro_hash));
 	mock_ec_ro_hash[0] = 42;
 	mock_ec_ro_hash_size = sizeof(mock_ec_ro_hash);
 
-	Memset(mock_ec_rw_hash, 0, sizeof(mock_ec_rw_hash));
+	memset(mock_ec_rw_hash, 0, sizeof(mock_ec_rw_hash));
 	mock_ec_rw_hash[0] = 42;
 	mock_ec_rw_hash_size = sizeof(mock_ec_rw_hash);
 
-	Memset(want_ec_hash, 0, sizeof(want_ec_hash));
+	memset(want_ec_hash, 0, sizeof(want_ec_hash));
 	want_ec_hash[0] = 42;
 	want_ec_hash_size = sizeof(want_ec_hash);
 
@@ -105,7 +105,7 @@ static void ResetMocks(void)
 
 	// TODO: ensure these are actually needed
 
-	Memset(screens_displayed, 0, sizeof(screens_displayed));
+	memset(screens_displayed, 0, sizeof(screens_displayed));
 	screens_count = 0;
 }
 
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index c1ba3d9d..26f92726 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -38,27 +38,27 @@ static VbError_t vbboot_retval;
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void)
 {
-	Memset(&cparams, 0, sizeof(cparams));
+	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
 	cparams.gbb_size = sizeof(gbb);
 
-	Memset(&kparams, 0, sizeof(kparams));
+	memset(&kparams, 0, sizeof(kparams));
 
-	Memset(&gbb, 0, sizeof(gbb));
+	memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = GBB_MAJOR_VER;
 	gbb.minor_version = GBB_MINOR_VER;
 	gbb.flags = 0;
 
-	Memset(&vnc, 0, sizeof(vnc));
+	memset(&vnc, 0, sizeof(vnc));
 	VbNvSetup(&vnc);
 	VbNvTeardown(&vnc);                   /* So CRC gets generated */
 
-	Memset(&shared_data, 0, sizeof(shared_data));
+	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 
-	Memset(&rfr_fwmp, 0, sizeof(rfr_fwmp));
+	memset(&rfr_fwmp, 0, sizeof(rfr_fwmp));
 	rfr_retval = TPM_SUCCESS;
 
 	ecsync_retval = VBERROR_SUCCESS;
@@ -71,13 +71,13 @@ static void ResetMocks(void)
 
 VbError_t VbExNvStorageRead(uint8_t *buf)
 {
-	Memcpy(buf, vnc.raw, sizeof(vnc.raw));
+	memcpy(buf, vnc.raw, sizeof(vnc.raw));
 	return VBERROR_SUCCESS;
 }
 
 VbError_t VbExNvStorageWrite(const uint8_t *buf)
 {
-	Memcpy(vnc.raw, buf, sizeof(vnc.raw));
+	memcpy(vnc.raw, buf, sizeof(vnc.raw));
 	return VBERROR_SUCCESS;
 }
 
@@ -106,7 +106,7 @@ uint32_t RollbackKernelLock(int recovery_mode)
 
 uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 {
-	Memcpy(fwmp, &rfr_fwmp, sizeof(*fwmp));
+	memcpy(fwmp, &rfr_fwmp, sizeof(*fwmp));
 	return rfr_retval;
 }
 
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index a372e178..04ee7669 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -45,15 +45,15 @@ static int hash_only_check;
  */
 static void ResetMocks(void)
 {
-	Memset(&cparams, 0, sizeof(cparams));
+	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
 	cparams.gbb_size = sizeof(gbb);
 
-	Memset(&kparams, 0, sizeof(kparams));
+	memset(&kparams, 0, sizeof(kparams));
 
-	Memset(&gbb, 0, sizeof(gbb));
+	memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = GBB_MAJOR_VER;
 	gbb.minor_version = GBB_MINOR_VER;
 	gbb.flags = 0;
@@ -147,7 +147,7 @@ int VerifyData(const uint8_t *data, uint64_t size, const VbSignature *sig,
 
 VbError_t VbExNvStorageRead(uint8_t *buf)
 {
-	Memcpy(buf, vnc.raw, sizeof(vnc.raw));
+	memcpy(buf, vnc.raw, sizeof(vnc.raw));
 	return VBERROR_SUCCESS;
 }
 
diff --git a/tests/vboot_api_kernel_tests.c b/tests/vboot_api_kernel_tests.c
index 05662f52..78cc6cf6 100644
--- a/tests/vboot_api_kernel_tests.c
+++ b/tests/vboot_api_kernel_tests.c
@@ -193,8 +193,8 @@ static uint32_t got_external_mismatch;
  */
 static void ResetMocks(int i)
 {
-	Memset(&lkparams, 0, sizeof(lkparams));
-	Memset(&mock_disks, 0, sizeof(mock_disks));
+	memset(&lkparams, 0, sizeof(lkparams));
+	memset(&mock_disks, 0, sizeof(mock_disks));
 	load_kernel_calls = 0;
 
 	got_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED;
diff --git a/tests/vboot_audio_tests.c b/tests/vboot_audio_tests.c
index bc6a3efc..4cc6ab28 100644
--- a/tests/vboot_audio_tests.c
+++ b/tests/vboot_audio_tests.c
@@ -60,17 +60,17 @@ void FixChecksum(VbDevMusic *hdr) {
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void) {
   VBDEBUG(("ResetMocks()\n"));
-  Memset(&cparams, 0, sizeof(cparams));
+  memset(&cparams, 0, sizeof(cparams));
   cparams.gbb_data = &gbb;
   cparams.gbb = &gbb;
-  Memset(&gbb, 0, sizeof(gbb));
+  memset(&gbb, 0, sizeof(gbb));
   gbb.major_version = GBB_MAJOR_VER;
   gbb.minor_version = GBB_MINOR_VER;
   gbb.flags = 0;
   use_hdr = (VbDevMusic *)notebuf;
   use_notes = use_hdr->notes;
-  Memcpy(use_hdr, &good_header, sizeof(good_header));
-  Memcpy(use_notes, good_notes, sizeof(good_notes));
+  memcpy(use_hdr, &good_header, sizeof(good_header));
+  memcpy(use_notes, good_notes, sizeof(good_notes));
   FixChecksum(use_hdr);
   use_size = sizeof(notebuf);
 }
diff --git a/tests/vboot_common2_tests.c b/tests/vboot_common2_tests.c
index b5b4b5bf..386f487f 100644
--- a/tests/vboot_common2_tests.c
+++ b/tests/vboot_common2_tests.c
@@ -161,50 +161,50 @@ static void VerifyKernelPreambleTest(const VbPublicKey *public_key,
 		"VerifyKernelPreamble() size++");
 
 	/* Care about major version but not minor */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major++;
 	ReSignKernelPreamble(h, private_key);
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		 "VerifyKernelPreamble() major++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major--;
 	ReSignKernelPreamble(h, private_key);
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		 "VerifyKernelPreamble() major--");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor++;
 	ReSignKernelPreamble(h, private_key);
 	TEST_EQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		"VerifyKernelPreamble() minor++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor--;
 	ReSignKernelPreamble(h, private_key);
 	TEST_EQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		"VerifyKernelPreamble() minor--");
 
 	/* Check signature */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.sig_offset = hsize;
 	ReSignKernelPreamble(h, private_key);
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		 "VerifyKernelPreamble() sig off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.sig_size--;
 	ReSignKernelPreamble(h, private_key);
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		 "VerifyKernelPreamble() sig too small");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	GetSignatureData(&h->body_signature)[0] ^= 0x34;
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		 "VerifyKernelPreamble() sig mismatch");
 
 	/* Check that we signed header and body sig */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->preamble_signature.data_size = 4;
 	h->body_signature.sig_offset = 0;
 	h->body_signature.sig_size = 0;
@@ -212,7 +212,7 @@ static void VerifyKernelPreambleTest(const VbPublicKey *public_key,
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
 		 "VerifyKernelPreamble() didn't sign header");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->body_signature.sig_offset = hsize;
 	ReSignKernelPreamble(h, private_key);
 	TEST_NEQ(VerifyKernelPreamble(h, hsize, rsa), 0,
diff --git a/tests/vboot_common3_tests.c b/tests/vboot_common3_tests.c
index d146e9e7..390b7f30 100644
--- a/tests/vboot_common3_tests.c
+++ b/tests/vboot_common3_tests.c
@@ -59,79 +59,79 @@ static void KeyBlockVerifyTest(const VbPublicKey *public_key,
 	TEST_EQ(KeyBlockVerify(hdr, hsize + 1, NULL, 1), 0,
 		"KeyBlockVerify() size++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->magic[0] &= 0x12;
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() magic");
 
 	/* Care about major version but not minor */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major++;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() major++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_major--;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() major--");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor++;
 	ReChecksumKeyBlock(h);
 	TEST_EQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		"KeyBlockVerify() minor++");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->header_version_minor--;
 	ReChecksumKeyBlock(h);
 	TEST_EQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		"KeyBlockVerify() minor--");
 
 	/* Check hash */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->key_block_checksum.sig_offset = hsize;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() checksum off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->key_block_checksum.sig_size /= 2;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() checksum too small");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	GetPublicKeyData(&h->data_key)[0] ^= 0x34;
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() checksum mismatch");
 
 	/* Check signature */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->key_block_signature.sig_offset = hsize;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, public_key, 0), 0,
 		 "KeyBlockVerify() sig off end");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->key_block_signature.sig_size--;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, public_key, 0), 0,
 		 "KeyBlockVerify() sig too small");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	GetPublicKeyData(&h->data_key)[0] ^= 0x34;
 	TEST_NEQ(KeyBlockVerify(h, hsize, public_key, 0), 0,
 		 "KeyBlockVerify() sig mismatch");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->key_block_checksum.data_size = h->key_block_size + 1;
 	TEST_NEQ(KeyBlockVerify(h, hsize, public_key, 1), 0,
 		 "KeyBlockVerify() checksum data past end of block");
 
 	/* Check that we signed header and data key */
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->key_block_checksum.data_size = 4;
 	h->data_key.key_offset = 0;
 	h->data_key.key_size = 0;
@@ -139,7 +139,7 @@ static void KeyBlockVerifyTest(const VbPublicKey *public_key,
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
 		 "KeyBlockVerify() didn't sign header");
 
-	Memcpy(h, hdr, hsize);
+	memcpy(h, hdr, hsize);
 	h->data_key.key_offset = hsize;
 	ReChecksumKeyBlock(h);
 	TEST_NEQ(KeyBlockVerify(h, hsize, NULL, 1), 0,
diff --git a/tests/vboot_common_tests.c b/tests/vboot_common_tests.c
index 875180b5..d5494d42 100644
--- a/tests/vboot_common_tests.c
+++ b/tests/vboot_common_tests.c
@@ -146,8 +146,8 @@ static void PublicKeyTest(void)
 	VbPublicKey j[5];
 
 	/* Fill some bits of the public key data */
-	Memset(j, 0, sizeof(j));
-	Memset(k, 0x42, sizeof(k));
+	memset(j, 0, sizeof(j));
+	memset(k, 0x42, sizeof(k));
 	k[1].key_size = 12345;
 	k[2].key_version = 67;
 
@@ -178,7 +178,7 @@ static void PublicKeyTest(void)
 	TEST_EQ(k->key_version, j->key_version, "PublicKeyCopy key_version");
 	/* Data should have been copied */
 	TEST_EQ(0,
-		Memcmp(GetPublicKeyData(k), GetPublicKeyData(j), k->key_size),
+		memcmp(GetPublicKeyData(k), GetPublicKeyData(j), k->key_size),
 		"PublicKeyCopy data");
 }
 
@@ -198,7 +198,7 @@ static void VbSharedDataTest(void)
 		 VbSharedDataInit(NULL, VB_SHARED_DATA_MIN_SIZE),
 		 "VbSharedDataInit null");
 
-	Memset(buf, 0x68, sizeof(buf));
+	memset(buf, 0x68, sizeof(buf));
 	TEST_EQ(VBOOT_SUCCESS, VbSharedDataInit(d, VB_SHARED_DATA_MIN_SIZE),
 		"VbSharedDataInit");
 
diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c
index 6e36f647..99d14f21 100644
--- a/tests/vboot_display_tests.c
+++ b/tests/vboot_display_tests.c
@@ -35,7 +35,7 @@ static void ResetMocks(void)
 {
 	int gbb_used;
 
-	Memset(gbb_data, 0, sizeof(gbb_data));
+	memset(gbb_data, 0, sizeof(gbb_data));
 	gbb->major_version = GBB_MAJOR_VER;
 	gbb->minor_version = GBB_MINOR_VER;
 	gbb->flags = 0;
@@ -55,7 +55,7 @@ static void ResetMocks(void)
 	bhdr->minor_version = BMPBLOCK_MINOR_VERSION;
 	bhdr->number_of_localizations = 3;
 
-	Memset(&cparams, 0, sizeof(cparams));
+	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = gbb;
@@ -75,11 +75,11 @@ static void ResetMocks(void)
 	gbb_used += 64;
 	memcpy(cparams.gbb, gbb, sizeof(*gbb));
 
-	Memset(&vnc, 0, sizeof(vnc));
+	memset(&vnc, 0, sizeof(vnc));
 	VbNvSetup(&vnc);
 	VbNvTeardown(&vnc);                   /* So CRC gets generated */
 
-	Memset(&shared_data, 0, sizeof(shared_data));
+	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 
 	*debug_info = 0;
@@ -235,9 +235,9 @@ static void FontTest(void)
 
 	/* Create font data */
 	h.num_entries = ARRAY_SIZE(eh);
-	Memcpy(buf, &h, sizeof(h));
+	memcpy(buf, &h, sizeof(h));
 	eptr = (FontArrayEntryHeader *)(buf + sizeof(h));
-	Memcpy(eptr, eh, sizeof(eh));
+	memcpy(eptr, eh, sizeof(eh));
 
 	fptr = VbInternalizeFontData((FontArrayHeader *)buf);
 	TEST_PTR_EQ(fptr, buf, "Internalize");
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index 5818db26..e3695ab1 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -81,7 +81,7 @@ static uint8_t mock_digest[VB2_SHA256_DIGEST_SIZE] = {12, 34, 56, 78};
  */
 static void SetupGptHeader(GptHeader *h, int is_secondary)
 {
-	Memset(h, '\0', MOCK_SECTOR_SIZE);
+	memset(h, '\0', MOCK_SECTOR_SIZE);
 
 	/* "EFI PART" */
 	memcpy(h->signature, GPT_HEADER_SIGNATURE, GPT_HEADER_SIGNATURE_SIZE);
@@ -302,7 +302,7 @@ int vb2_digest_buffer(const uint8_t *buf,
 		      uint8_t *digest,
 		      uint32_t digest_size)
 {
-	Memcpy(digest, mock_digest, sizeof(mock_digest));
+	memcpy(digest, mock_digest, sizeof(mock_digest));
 	return VB2_SUCCESS;
 }
 
@@ -329,7 +329,7 @@ static void ReadWriteGptTest(void)
 	 * Valgrind complains about access to uninitialized memory here, so
 	 * zero the primary header before each test.
 	 */
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_EQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree");
 	TEST_CALLS("");
 
@@ -338,7 +338,7 @@ static void ReadWriteGptTest(void)
 	 * check that AllocAndReadGptData still succeeds
 	 */
 	ResetMocks();
-	Memset(mock_gpt_primary, '\0', sizeof(*mock_gpt_primary));
+	memset(mock_gpt_primary, '\0', sizeof(*mock_gpt_primary));
 	TEST_EQ(AllocAndReadGptData(handle, &g), 0,
 		"AllocAndRead primary invalid");
 	TEST_EQ(CheckHeader(mock_gpt_primary, 0, g.streaming_drive_sectors,
@@ -357,7 +357,7 @@ static void ReadWriteGptTest(void)
 	 * check that AllocAndReadGptData still succeeds
 	 */
 	ResetMocks();
-	Memset(mock_gpt_secondary, '\0', sizeof(*mock_gpt_secondary));
+	memset(mock_gpt_secondary, '\0', sizeof(*mock_gpt_secondary));
 	TEST_EQ(AllocAndReadGptData(handle, &g), 0,
 		"AllocAndRead secondary invalid");
 	TEST_EQ(CheckHeader(mock_gpt_primary, 0, g.streaming_drive_sectors,
@@ -376,8 +376,8 @@ static void ReadWriteGptTest(void)
 	 * check that AllocAndReadGptData fails.
 	 */
 	ResetMocks();
-	Memset(mock_gpt_primary, '\0', sizeof(*mock_gpt_primary));
-	Memset(mock_gpt_secondary, '\0', sizeof(*mock_gpt_secondary));
+	memset(mock_gpt_primary, '\0', sizeof(*mock_gpt_primary));
+	memset(mock_gpt_secondary, '\0', sizeof(*mock_gpt_secondary));
 	TEST_EQ(AllocAndReadGptData(handle, &g), 1,
 		"AllocAndRead primary and secondary invalid");
 	TEST_EQ(CheckHeader(mock_gpt_primary, 0, g.streaming_drive_sectors,
@@ -398,7 +398,7 @@ static void ReadWriteGptTest(void)
 	 * but this callback is mocked in these tests.
 	 */
 	ResetMocks();
-	Memset(mock_gpt_primary, '\0', sizeof(*mock_gpt_primary));
+	memset(mock_gpt_primary, '\0', sizeof(*mock_gpt_primary));
 	TEST_EQ(AllocAndReadGptData(handle, &g), 0,
 		"Fix Primary GPT: AllocAndRead");
 	/* Call GptRepair() with input indicating secondary GPT is valid */
@@ -423,7 +423,7 @@ static void ReadWriteGptTest(void)
 	 * but this callback is mocked in these tests.
 	 */
 	ResetMocks();
-	Memset(mock_gpt_secondary, '\0', sizeof(*mock_gpt_secondary));
+	memset(mock_gpt_secondary, '\0', sizeof(*mock_gpt_secondary));
 	TEST_EQ(AllocAndReadGptData(handle, &g), 0,
 		"Fix Secondary GPT: AllocAndRead");
 	/* Call GptRepair() with input indicating primary GPT is valid */
@@ -445,7 +445,7 @@ static void ReadWriteGptTest(void)
 	AllocAndReadGptData(handle, &g);
 	g.modified |= GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1;
 	ResetCallLog();
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	h = (GptHeader*)g.primary_header;
 	h->entries_lba = 2;
 	h->number_of_entries = MAX_NUMBER_OF_ENTRIES;
@@ -459,7 +459,7 @@ static void ReadWriteGptTest(void)
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
 	ResetCallLog();
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	h = (GptHeader*)g.primary_header;
 	h->entries_lba = 2;
 	h->number_of_entries = MAX_NUMBER_OF_ENTRIES;
@@ -529,14 +529,14 @@ static void ReadWriteGptTest(void)
 	disk_write_to_fail = 1;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 	ResetMocks();
 	disk_write_to_fail = 2;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	h = (GptHeader*)g.primary_header;
 	h->entries_lba = 2;
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
@@ -545,14 +545,14 @@ static void ReadWriteGptTest(void)
 	disk_write_to_fail = 991;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 	ResetMocks();
 	disk_write_to_fail = 1023;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
+	memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 }
diff --git a/tests/vboot_region_tests.c b/tests/vboot_region_tests.c
index 6dd6b624..d087f0ad 100644
--- a/tests/vboot_region_tests.c
+++ b/tests/vboot_region_tests.c
@@ -45,17 +45,17 @@ static void ResetMocks(void) {
 	ScreenLayout *layout;
 	int gbb_used;
 
-	Memset(&vnc, 0, sizeof(vnc));
+	memset(&vnc, 0, sizeof(vnc));
 	VbNvSetup(&vnc);
 	VbNvTeardown(&vnc);                   /* So CRC gets generated */
 
-	Memset(&cparams, 0, sizeof(cparams));
+	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 
-	Memset(&fparams, 0, sizeof(fparams));
+	memset(&fparams, 0, sizeof(fparams));
 
-	Memset(gbb_data, 0, sizeof(gbb_data));
+	memset(gbb_data, 0, sizeof(gbb_data));
 	gbb = (GoogleBinaryBlockHeader *)gbb_data;
 	gbb->major_version = GBB_MAJOR_VER;
 	gbb->minor_version = GBB_MINOR_VER;
@@ -102,7 +102,7 @@ static void ResetMocks(void) {
 	image_info->compression = COMPRESS_LZMA1;
 	gbb_used += sizeof(*image_info) + COMPRESSED_SIZE;
 
-	Memset(&shared_data, 0, sizeof(shared_data));
+	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
 	shared->fw_keyblock_flags = 0xABCDE0;
 
@@ -116,12 +116,12 @@ static void ResetMocks(void) {
 /* Mocked verification functions */
 
 VbError_t VbExNvStorageRead(uint8_t* buf) {
-  Memcpy(buf, vnc.raw, sizeof(vnc.raw));
+  memcpy(buf, vnc.raw, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
 VbError_t VbExNvStorageWrite(const uint8_t* buf) {
-  Memcpy(vnc.raw, buf, sizeof(vnc.raw));
+  memcpy(vnc.raw, buf, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
diff --git a/utility/load_kernel_test.c b/utility/load_kernel_test.c
index ee385bf1..bf2c068b 100644
--- a/utility/load_kernel_test.c
+++ b/utility/load_kernel_test.c
@@ -88,13 +88,13 @@ int main(int argc, char* argv[]) {
   int errorcnt = 0;
   char *e = 0;
 
-  Memset(&lkp, 0, sizeof(LoadKernelParams));
+  memset(&lkp, 0, sizeof(LoadKernelParams));
   lkp.bytes_per_lba = LBA_BYTES;
   lkp.boot_flags = BOOT_FLAG_RECOVERY;
-  Memset(&vnc, 0, sizeof(VbNvContext));
+  memset(&vnc, 0, sizeof(VbNvContext));
   VbNvSetup(&vnc);
   lkp.nv_context = &vnc;
-  Memset(&cparams, 0, sizeof(VbCommonParams));
+  memset(&cparams, 0, sizeof(VbCommonParams));
 
   /* Parse options */
   opterr = 0;
@@ -164,8 +164,8 @@ int main(int argc, char* argv[]) {
   lkp.gbb_data = (void*)malloc(lkp.gbb_size);
   gbb = (GoogleBinaryBlockHeader*)lkp.gbb_data;
   cparams.gbb = gbb;
-  Memset(gbb, 0, lkp.gbb_size);
-  Memcpy(gbb->signature, GBB_SIGNATURE, GBB_SIGNATURE_SIZE);
+  memset(gbb, 0, lkp.gbb_size);
+  memcpy(gbb->signature, GBB_SIGNATURE, GBB_SIGNATURE_SIZE);
   gbb->major_version = GBB_MAJOR_VER;
   gbb->minor_version = GBB_MINOR_VER;
   gbb->header_size = sizeof(GoogleBinaryBlockHeader);
@@ -173,7 +173,7 @@ int main(int argc, char* argv[]) {
   if (key_blob) {
     gbb->rootkey_offset = gbb->header_size;
     gbb->rootkey_size = key_size;
-    Memcpy((uint8_t*)gbb + gbb->rootkey_offset, key_blob, key_size);
+    memcpy((uint8_t*)gbb + gbb->rootkey_offset, key_blob, key_size);
 
     gbb->recovery_key_offset = gbb->rootkey_offset;
     gbb->recovery_key_size = key_size;