diff --git a/sections/cper-section-arm.c b/sections/cper-section-arm.c
index eba2c8f..b0b14d1 100644
--- a/sections/cper-section-arm.c
+++ b/sections/cper-section-arm.c
@@ -7,7 +7,7 @@
 
 #include <stdio.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-arm.h"
@@ -121,21 +121,19 @@
 		json_object *vendor_specific = json_object_new_object();
 		size_t input_size =
 			(uint8_t *)section + record->SectionLength - cur_pos;
-		char *encoded = malloc(2 * input_size);
-		size_t encoded_len = 0;
-		if (!encoded) {
-			printf("Failed to allocate encode output buffer. \n");
-		} else {
-			base64_encode((const char *)cur_pos, input_size,
-				      encoded, &encoded_len, 0);
-			json_object_object_add(vendor_specific, "data",
-					       json_object_new_string_len(
-						       encoded, encoded_len));
-			free(encoded);
-
-			json_object_object_add(section_ir, "vendorSpecificInfo",
-					       vendor_specific);
+		int32_t encoded_len = 0;
+		char *encoded =
+			base64_encode(cur_pos, input_size, &encoded_len);
+		if (encoded == NULL) {
+			return NULL;
 		}
+		json_object_object_add(vendor_specific, "data",
+				       json_object_new_string_len(encoded,
+								  encoded_len));
+		free(encoded);
+
+		json_object_object_add(section_ir, "vendorSpecificInfo",
+				       vendor_specific);
 	}
 
 	return section_ir;
@@ -441,19 +439,19 @@
 	default:
 		//Unknown register array type, add as base64 data instead.
 		register_array = json_object_new_object();
-		char *encoded = malloc(2 * header->RegisterArraySize);
-		size_t encoded_len = 0;
-		if (!encoded) {
+		int32_t encoded_len = 0;
+		char *encoded = base64_encode((UINT8 *)cur_pos,
+					      header->RegisterArraySize,
+					      &encoded_len);
+		if (encoded == NULL) {
 			printf("Failed to allocate encode output buffer. \n");
-		} else {
-			base64_encode((const char *)cur_pos,
-				      header->RegisterArraySize, encoded,
-				      &encoded_len, 0);
-			json_object_object_add(register_array, "data",
-					       json_object_new_string_len(
-						       encoded, encoded_len));
-			free(encoded);
+			return NULL;
 		}
+		json_object_object_add(register_array, "data",
+				       json_object_new_string_len(encoded,
+								  encoded_len));
+		free(encoded);
+
 		break;
 	}
 	json_object_object_add(context_ir, "registerArray", register_array);
@@ -549,20 +547,17 @@
 			json_object_object_get(vendor_specific_info, "data");
 		int vendor_specific_len =
 			json_object_get_string_len(vendor_info_string);
-		char *decoded = malloc(vendor_specific_len);
-		size_t decoded_len = 0;
-		if (!decoded) {
-			printf("Failed to allocate decode output buffer. \n");
-		} else {
-			base64_decode(
-				json_object_get_string(vendor_info_string),
-				vendor_specific_len, decoded, &decoded_len, 0);
 
-			//Write out to file.
-			fwrite(decoded, decoded_len, 1, out);
-			fflush(out);
-			free(decoded);
-		}
+		int32_t decoded_len = 0;
+
+		UINT8 *decoded = base64_decode(
+			json_object_get_string(vendor_info_string),
+			vendor_specific_len, &decoded_len);
+
+		//Write out to file.
+		fwrite(decoded, decoded_len, 1, out);
+		fflush(out);
+		free(decoded);
 	}
 
 	//Free remaining resources.
@@ -903,15 +898,16 @@
 {
 	//Get base64 represented data.
 	json_object *encoded = json_object_object_get(registers, "data");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+
+	int32_t decoded_len = 0;
+
+	UINT8 *decoded = base64_decode(json_object_get_string(encoded),
+				       json_object_get_string_len(encoded),
+				       &decoded_len);
+
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
-
 		//Flush out to stream.
 		fwrite(&decoded, decoded_len, 1, out);
 		fflush(out);
diff --git a/sections/cper-section-ccix-per.c b/sections/cper-section-ccix-per.c
index 8e43c6d..f6ffd39 100644
--- a/sections/cper-section-ccix-per.c
+++ b/sections/cper-section-ccix-per.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-ccix-per.h"
@@ -39,13 +39,13 @@
 	int remaining_length =
 		ccix_error->Length - sizeof(EFI_CCIX_PER_LOG_DATA);
 	if (remaining_length > 0) {
-		char *encoded = malloc(2 * remaining_length);
-		size_t encoded_len = 0;
-		if (!encoded) {
+		int32_t encoded_len = 0;
+
+		char *encoded = base64_encode((UINT8 *)cur_pos,
+					      remaining_length, &encoded_len);
+		if (encoded == NULL) {
 			printf("Failed to allocate encode output buffer. \n");
 		} else {
-			base64_encode((const char *)cur_pos, remaining_length,
-				      encoded, &encoded_len, 0);
 			json_object_object_add(section_ir, "ccixPERLog",
 					       json_object_new_string_len(
 						       encoded, encoded_len));
@@ -83,19 +83,18 @@
 
 	//Write CCIX PER log itself to stream.
 	json_object *encoded = json_object_object_get(section, "ccixPERLog");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+	int32_t decoded_len = 0;
+
+	UINT8 *decoded = base64_decode(json_object_get_string(encoded),
+				       json_object_get_string_len(encoded),
+				       &decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		fwrite(decoded, decoded_len, 1, out);
 		fflush(out);
+		free(decoded);
 	}
-
 	//Free resources.
-	free(decoded);
 	free(section_cper);
 }
diff --git a/sections/cper-section-cxl-component.c b/sections/cper-section-cxl-component.c
index 9976df2..343611f 100644
--- a/sections/cper-section-cxl-component.c
+++ b/sections/cper-section-cxl-component.c
@@ -6,7 +6,7 @@
  **/
 #include <stdio.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-cxl-component.h"
@@ -63,21 +63,22 @@
 		cxl_error->Length - sizeof(EFI_CXL_COMPONENT_EVENT_HEADER);
 	if (remaining_len > 0) {
 		json_object *event_log = json_object_new_object();
-		char *encoded = malloc(2 * remaining_len);
-		size_t encoded_len = 0;
-		if (!encoded) {
-			printf("Failed to allocate encode output buffer. \n");
-		} else {
-			base64_encode((const char *)cur_pos, remaining_len,
-				      encoded, &encoded_len, 0);
-			json_object_object_add(event_log, "data",
-					       json_object_new_string_len(
-						       encoded, encoded_len));
 
-			free(encoded);
-			json_object_object_add(
-				section_ir, "cxlComponentEventLog", event_log);
+		int32_t encoded_len = 0;
+
+		char *encoded = base64_encode((UINT8 *)cur_pos, remaining_len,
+					      &encoded_len);
+		if (encoded == NULL) {
+			printf("Failed to allocate encode output buffer. \n");
+			return NULL;
 		}
+		json_object_object_add(event_log, "data",
+				       json_object_new_string_len(encoded,
+								  encoded_len));
+
+		free(encoded);
+		json_object_object_add(section_ir, "cxlComponentEventLog",
+				       event_log);
 	}
 
 	return section_ir;
@@ -129,14 +130,16 @@
 	json_object *event_log =
 		json_object_object_get(section, "cxlComponentEventLog");
 	json_object *encoded = json_object_object_get(event_log, "data");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+
+	int32_t decoded_len = 0;
+
+	UINT8 *decoded = base64_decode(json_object_get_string(encoded),
+				       json_object_get_string_len(encoded),
+				       &decoded_len);
+
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		fwrite(decoded, decoded_len, 1, out);
 		fflush(out);
 		free(decoded);
diff --git a/sections/cper-section-cxl-protocol.c b/sections/cper-section-cxl-protocol.c
index 7aef836..88ed2e9 100644
--- a/sections/cper-section-cxl-protocol.c
+++ b/sections/cper-section-cxl-protocol.c
@@ -6,7 +6,7 @@
  **/
 #include <stdio.h>
 #include <string.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-cxl-protocol.h"
@@ -92,6 +92,7 @@
 			cxl_protocol_error->DeviceId.SlotNumber));
 	json_object_object_add(section_ir, "deviceID", device_id);
 
+	char *encoded;
 	//Device serial & capability structure (if CXL 1.1 device).
 	if (cxl_protocol_error->CxlAgentType ==
 	    CXL_PROTOCOL_ERROR_DEVICE_AGENT) {
@@ -103,20 +104,20 @@
 		//The PCIe capability structure provided here could either be PCIe 1.1 Capability Structure
 		//(36-byte, padded to 60 bytes) or PCIe 2.0 Capability Structure (60-byte). There does not seem
 		//to be a way to differentiate these, so this is left as a b64 dump.
-		char *encoded = malloc(2 * 60);
-		size_t encoded_len = 0;
-		if (!encoded) {
+
+		int32_t encoded_len = 0;
+
+		encoded = base64_encode(
+			(UINT8 *)cxl_protocol_error->CapabilityStructure.PcieCap,
+			60, &encoded_len);
+		if (encoded == NULL) {
 			printf("Failed to allocate encode output buffer. \n");
-		} else {
-			base64_encode((const char *)cxl_protocol_error
-					      ->CapabilityStructure.PcieCap,
-				      60, encoded, &encoded_len, 0);
-			json_object_object_add(section_ir,
-					       "capabilityStructure",
-					       json_object_new_string_len(
-						       encoded, encoded_len));
-			free(encoded);
+			return NULL;
 		}
+		json_object_object_add(section_ir, "capabilityStructure",
+				       json_object_new_string_len(encoded,
+								  encoded_len));
+		free(encoded);
 	}
 
 	//CXL DVSEC & error log length.
@@ -131,35 +132,39 @@
 	//For CXL 1.1 devices, this is the "CXL DVSEC For Flex Bus Device" structure as in CXL 1.1 spec.
 	//For CXL 1.1 host downstream ports, this is the "CXL DVSEC For Flex Bus Port" structure as in CXL 1.1 spec.
 	const char *cur_pos = (const char *)(cxl_protocol_error + 1);
-	char *encoded = malloc(2 * cxl_protocol_error->CxlDvsecLength);
-	size_t encoded_len = 0;
-	if (!encoded) {
-		printf("Failed to allocate encode output buffer. \n");
-	} else {
-		base64_encode(cur_pos, cxl_protocol_error->CxlDvsecLength,
-			      encoded, &encoded_len, 0);
-		json_object_object_add(section_ir, "cxlDVSEC",
-				       json_object_new_string_len(encoded,
-								  encoded_len));
+	int32_t encoded_len = 0;
 
-		free(encoded);
+	encoded = base64_encode((UINT8 *)cur_pos,
+				cxl_protocol_error->CxlDvsecLength,
+				&encoded_len);
+	if (encoded == NULL) {
+		return NULL;
 	}
+	json_object_object_add(section_ir, "cxlDVSEC",
+			       json_object_new_string_len(encoded,
+							  encoded_len));
+
+	free(encoded);
+
 	cur_pos += cxl_protocol_error->CxlDvsecLength;
 
 	//CXL Error Log
 	//This is the "CXL RAS Capability Structure" as in CXL 1.1 spec.
-	encoded = malloc(2 * cxl_protocol_error->CxlErrorLogLength);
+
 	encoded_len = 0;
-	if (!encoded) {
+	encoded = base64_encode((UINT8 *)cur_pos,
+				cxl_protocol_error->CxlErrorLogLength,
+				&encoded_len);
+
+	if (encoded == NULL) {
 		printf("Failed to allocate encode output buffer. \n");
-	} else {
-		base64_encode(cur_pos, cxl_protocol_error->CxlErrorLogLength,
-			      encoded, &encoded_len, 0);
-		json_object_object_add(section_ir, "cxlErrorLog",
-				       json_object_new_string_len(encoded,
-								  encoded_len));
-		free(encoded);
+		return NULL;
 	}
+	json_object_object_add(section_ir, "cxlErrorLog",
+			       json_object_new_string_len(encoded,
+							  encoded_len));
+	free(encoded);
+
 	return section_ir;
 }
 
@@ -223,20 +228,23 @@
 		json_object_object_get(device_id, "slotNumber"));
 
 	//If CXL 1.1 device, the serial number & PCI capability structure.
+	UINT8 *decoded;
 	if (section_cper->CxlAgentType == CXL_PROTOCOL_ERROR_DEVICE_AGENT) {
 		section_cper->DeviceSerial = json_object_get_uint64(
 			json_object_object_get(section, "deviceSerial"));
 
 		json_object *encoded =
 			json_object_object_get(section, "capabilityStructure");
-		char *decoded = malloc(json_object_get_string_len(encoded));
-		size_t decoded_len = 0;
-		if (!decoded) {
+
+		int32_t decoded_len = 0;
+
+		decoded = base64_decode(json_object_get_string(encoded),
+					json_object_get_string_len(encoded),
+					&decoded_len);
+
+		if (decoded == NULL) {
 			printf("Failed to allocate decode output buffer. \n");
 		} else {
-			base64_decode(json_object_get_string(encoded),
-				      json_object_get_string_len(encoded),
-				      decoded, &decoded_len, 0);
 			memcpy(section_cper->CapabilityStructure.PcieCap,
 			       decoded, decoded_len);
 			free(decoded);
@@ -255,14 +263,15 @@
 
 	//DVSEC out to stream.
 	json_object *encoded = json_object_object_get(section, "cxlDVSEC");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+
+	int32_t decoded_len = 0;
+
+	decoded = base64_decode(json_object_get_string(encoded),
+				json_object_get_string_len(encoded),
+				&decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		fwrite(decoded, decoded_len, 1, out);
 		fflush(out);
 		free(decoded);
@@ -270,14 +279,14 @@
 
 	//Error log out to stream.
 	encoded = json_object_object_get(section, "cxlErrorLog");
-	decoded = malloc(json_object_get_string_len(encoded));
 	decoded_len = 0;
-	if (!decoded) {
+
+	decoded = base64_decode(json_object_get_string(encoded),
+				json_object_get_string_len(encoded),
+				&decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		fwrite(decoded, decoded_len, 1, out);
 		fflush(out);
 		free(decoded);
diff --git a/sections/cper-section-dmar-iommu.c b/sections/cper-section-dmar-iommu.c
index 0158a0b..b813a6e 100644
--- a/sections/cper-section-dmar-iommu.c
+++ b/sections/cper-section-dmar-iommu.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-dmar-iommu.h"
@@ -31,32 +31,33 @@
 
 	//IOMMU event log entry.
 	//The format of these entries differ widely by the type of error.
-	char *encoded = malloc(2 * 16);
-	size_t encoded_len = 0;
-	if (!encoded) {
+	int32_t encoded_len = 0;
+
+	char *encoded = base64_encode((UINT8 *)iommu_error->EventLogEntry, 16,
+				      &encoded_len);
+	if (encoded == NULL) {
 		printf("Failed to allocate encode output buffer. \n");
-	} else {
-		base64_encode((const char *)iommu_error->EventLogEntry, 16,
-			      encoded, &encoded_len, 0);
-		json_object_object_add(section_ir, "eventLogEntry",
-				       json_object_new_string_len(encoded,
-								  encoded_len));
-		free(encoded);
+
+		return NULL;
 	}
+	json_object_object_add(section_ir, "eventLogEntry",
+			       json_object_new_string_len(encoded,
+							  encoded_len));
+	free(encoded);
 
 	//Device table entry (as base64).
-	encoded = malloc(2 * 32);
 	encoded_len = 0;
-	if (!encoded) {
+
+	encoded = base64_encode((UINT8 *)iommu_error->DeviceTableEntry, 32,
+				&encoded_len);
+	if (encoded == NULL) {
 		printf("Failed to allocate encode output buffer. \n");
-	} else {
-		base64_encode((const char *)iommu_error->DeviceTableEntry, 32,
-			      encoded, &encoded_len, 0);
-		json_object_object_add(section_ir, "deviceTableEntry",
-				       json_object_new_string_len(encoded,
-								  encoded_len));
-		free(encoded);
+		return NULL;
 	}
+	json_object_object_add(section_ir, "deviceTableEntry",
+			       json_object_new_string_len(encoded,
+							  encoded_len));
+	free(encoded);
 
 	//Page table entries.
 	json_object_object_add(section_ir, "pageTableEntry_Level6",
@@ -92,28 +93,27 @@
 
 	//IOMMU event log entry.
 	json_object *encoded = json_object_object_get(section, "eventLogEntry");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+	int32_t decoded_len = 0;
+
+	UINT8 *decoded = base64_decode(json_object_get_string(encoded),
+				       json_object_get_string_len(encoded),
+				       &decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		memcpy(section_cper->EventLogEntry, decoded, decoded_len);
 		free(decoded);
 	}
-
 	//Device table entry.
 	encoded = json_object_object_get(section, "deviceTableEntry");
-	decoded = malloc(json_object_get_string_len(encoded));
 	decoded_len = 0;
-	if (!decoded) {
+
+	decoded = base64_decode(json_object_get_string(encoded),
+				json_object_get_string_len(encoded),
+				&decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		memcpy(section_cper->DeviceTableEntry, decoded, decoded_len);
 		free(decoded);
 	}
diff --git a/sections/cper-section-dmar-vtd.c b/sections/cper-section-dmar-vtd.c
index 5f4bad9..f954094 100644
--- a/sections/cper-section-dmar-vtd.c
+++ b/sections/cper-section-dmar-vtd.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-dmar-vtd.h"
@@ -82,27 +82,22 @@
 	json_object_object_add(section_ir, "faultRecord", fault_record_ir);
 
 	//Root entry.
-	char *encoded = malloc(2 * 16);
-	size_t encoded_len = 0;
-	if (!encoded) {
-		printf("Failed to allocate encode output buffer. \n");
-	} else {
-		base64_encode((const char *)vtd_error->RootEntry, 16, encoded,
-			      &encoded_len, 0);
-		json_object_object_add(section_ir, "rootEntry",
-				       json_object_new_string_len(encoded,
-								  encoded_len));
-		free(encoded);
-	}
+	int32_t encoded_len = 0;
+
+	char *encoded =
+		base64_encode((UINT8 *)vtd_error->RootEntry, 16, &encoded_len);
+	json_object_object_add(section_ir, "rootEntry",
+			       json_object_new_string_len(encoded,
+							  encoded_len));
+	free(encoded);
 
 	//Context entry.
-	encoded = malloc(2 * 16);
 	encoded_len = 0;
-	if (!encoded) {
+	encoded = base64_encode((UINT8 *)vtd_error->ContextEntry, 16,
+				&encoded_len);
+	if (encoded == NULL) {
 		printf("Failed to allocate encode output buffer. \n");
 	} else {
-		base64_encode((const char *)vtd_error->ContextEntry, 16,
-			      encoded, &encoded_len, 0);
 		json_object_object_add(section_ir, "contextEntry",
 				       json_object_new_string_len(encoded,
 								  encoded_len));
@@ -183,27 +178,29 @@
 
 	//Root entry.
 	json_object *encoded = json_object_object_get(section, "rootEntry");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+	int32_t decoded_len = 0;
+
+	UINT8 *decoded = base64_decode(json_object_get_string(encoded),
+				       json_object_get_string_len(encoded),
+				       &decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		memcpy(section_cper->RootEntry, decoded, decoded_len);
 		free(decoded);
 	}
+
 	//Context entry.
 	encoded = json_object_object_get(section, "contextEntry");
-	decoded = malloc(json_object_get_string_len(encoded));
 	decoded_len = 0;
-	if (!decoded) {
+
+	decoded = base64_decode(json_object_get_string(encoded),
+				json_object_get_string_len(encoded),
+				&decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
+
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		memcpy(section_cper->ContextEntry, decoded, decoded_len);
 		free(decoded);
 	}
diff --git a/sections/cper-section-ia32x64.c b/sections/cper-section-ia32x64.c
index e3ea1b8..bb07da6 100644
--- a/sections/cper-section-ia32x64.c
+++ b/sections/cper-section-ia32x64.c
@@ -7,7 +7,7 @@
 
 #include <stdio.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-ia32x64.h"
@@ -390,15 +390,13 @@
 		//No parseable data, just dump as base64 and shift the head to the next item.
 		*cur_pos = (void *)(context_info + 1);
 
-		char *encoded = malloc(2 * context_info->ArraySize);
-		size_t encoded_len = 0;
-		if (!encoded) {
+		int32_t encoded_len = 0;
+		char *encoded = base64_encode((UINT8 *)*cur_pos,
+					      context_info->ArraySize,
+					      &encoded_len);
+		if (encoded == NULL) {
 			printf("Failed to allocate encode output buffer. \n");
 		} else {
-			base64_encode((const char *)*cur_pos,
-				      context_info->ArraySize, encoded,
-				      &encoded_len, 0);
-
 			register_array = json_object_new_object();
 			json_object_object_add(register_array, "data",
 					       json_object_new_string_len(
@@ -819,14 +817,13 @@
 		//Unknown/structure is not defined.
 		json_object *encoded =
 			json_object_object_get(register_array, "data");
-		char *decoded = malloc(json_object_get_string_len(encoded));
-		size_t decoded_len = 0;
-		if (!decoded) {
+		int32_t decoded_len = 0;
+		const char *j_string = json_object_get_string(encoded);
+		int j_size = json_object_get_string_len(encoded);
+		UINT8 *decoded = base64_decode(j_string, j_size, &decoded_len);
+		if (decoded == NULL) {
 			printf("Failed to allocate decode output buffer. \n");
 		} else {
-			base64_decode(json_object_get_string(encoded),
-				      json_object_get_string_len(encoded),
-				      decoded, &decoded_len, 0);
 			fwrite(decoded, decoded_len, 1, out);
 			fflush(out);
 			free(decoded);
diff --git a/sections/cper-section-pcie.c b/sections/cper-section-pcie.c
index fe82b16..1c6534f 100644
--- a/sections/cper-section-pcie.c
+++ b/sections/cper-section-pcie.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <json.h>
-#include "libbase64.h"
+#include "base64.h"
 #include "../edk/Cper.h"
 #include "../cper-utils.h"
 #include "cper-section-pcie.h"
@@ -103,38 +103,39 @@
 	//The PCIe capability structure provided here could either be PCIe 1.1 Capability Structure
 	//(36-byte, padded to 60 bytes) or PCIe 2.0 Capability Structure (60-byte). There does not seem
 	//to be a way to differentiate these, so this is left as a b64 dump.
-	char *encoded = malloc(2 * 60);
-	size_t encoded_len = 0;
-	if (!encoded) {
+	int32_t encoded_len = 0;
+
+	char *encoded = base64_encode((UINT8 *)pcie_error->Capability.PcieCap,
+				      60, &encoded_len);
+	if (encoded == NULL) {
 		printf("Failed to allocate encode output buffer. \n");
 	} else {
-		base64_encode((const char *)pcie_error->Capability.PcieCap, 60,
-			      encoded, &encoded_len, 0);
 		json_object *capability = json_object_new_object();
 		json_object_object_add(capability, "data",
 				       json_object_new_string_len(encoded,
 								  encoded_len));
 		free(encoded);
+
 		json_object_object_add(section_ir, "capabilityStructure",
 				       capability);
 	}
 
 	//AER information.
 	json_object *aer_capability_ir = json_object_new_object();
-	encoded = malloc(2 * 96);
 	encoded_len = 0;
-	if (!encoded) {
+
+	encoded = base64_encode((UINT8 *)pcie_error->AerInfo.PcieAer, 96,
+				&encoded_len);
+	if (encoded == NULL) {
 		printf("Failed to allocate encode output buffer. \n");
 	} else {
-		base64_encode((const char *)pcie_error->AerInfo.PcieAer, 96,
-			      encoded, &encoded_len, 0);
 		json_object_object_add(aer_capability_ir, "data",
 				       json_object_new_string_len(encoded,
 								  encoded_len));
 		free(encoded);
-		json_object_object_add(section_ir, "aerInfo",
-				       aer_capability_ir);
 	}
+	json_object_object_add(section_ir, "aerInfo", aer_capability_ir);
+
 	return section_ir;
 }
 
@@ -206,14 +207,15 @@
 	json_object *capability =
 		json_object_object_get(section, "capabilityStructure");
 	json_object *encoded = json_object_object_get(capability, "data");
-	char *decoded = malloc(json_object_get_string_len(encoded));
-	size_t decoded_len = 0;
-	if (!decoded) {
+
+	int32_t decoded_len = 0;
+
+	UINT8 *decoded = base64_decode(json_object_get_string(encoded),
+				       json_object_get_string_len(encoded),
+				       &decoded_len);
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		memcpy(section_cper->Capability.PcieCap, decoded, decoded_len);
 		free(decoded);
 	}
@@ -221,14 +223,15 @@
 	//AER capability structure.
 	json_object *aer_info = json_object_object_get(section, "aerInfo");
 	encoded = json_object_object_get(aer_info, "data");
-	decoded = malloc(json_object_get_string_len(encoded));
 	decoded_len = 0;
-	if (!decoded) {
+
+	decoded = base64_decode(json_object_get_string(encoded),
+				json_object_get_string_len(encoded),
+				&decoded_len);
+
+	if (decoded == NULL) {
 		printf("Failed to allocate decode output buffer. \n");
 	} else {
-		base64_decode(json_object_get_string(encoded),
-			      json_object_get_string_len(encoded), decoded,
-			      &decoded_len, 0);
 		memcpy(section_cper->AerInfo.PcieAer, decoded, decoded_len);
 		free(decoded);
 	}