Import userspace tests

.gitignore

 .DS_Store
 UDK
 Binaries
-TestsPrivate
+*.dSYM
+TestsUser/Serialized/Serialized
+TestsUser/Macho/Macho
+TestsUser/Smbios/Smbios
+DICT
+fuzz-*.log
+crash-*

Include/Library/OcCpuLib.h

@@ -23,9 +23,12 @@
 
 // CPU_INFO
 typedef struct {
-  UINT8                Type;
+  //
+  // Note, Vendor and BrandString are reordered for proper alignment.
+  //
   UINT8                Vendor[16];
   CHAR8                BrandString[48];
+  UINT8                Type;
 
   UINT8                Family;
   UINT8                Model;

Library/OcMiscLib/LegacyRegionLock.c

@@ -18,7 +18,6 @@
 
 #include <Guid/ApplePlatformInfo.h>
 
-#include <Protocol/DataHub.h>
 #include <Protocol/LegacyRegion.h>
 #include <Protocol/PciIo.h>
 

Library/OcMiscLib/LegacyRegionUnLock.c

@@ -18,7 +18,6 @@
 
 #include <Guid/ApplePlatformInfo.h>
 
-#include <Protocol/DataHub.h>
 #include <Protocol/LegacyRegion.h>
 #include <Protocol/PciIo.h>
 

Library/OcSmbiosLib/SmbiosPatch.c

@@ -1523,6 +1523,13 @@ SmbiosHandleLegacyRegion (
 {
   EFI_STATUS  Status;
 
+  //
+  // Not needed for mOriginalSmbios3.
+  //
+  if (mOriginalSmbios == NULL) {
+    return;
+  }
+
   if (Unlock) {
     if (((UINTN) mOriginalSmbios) < BASE_1MB) {
       //
@@ -1607,7 +1614,7 @@ SmbiosTableAllocate (
               );
 
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_VERBOSE, "SmbiosLookupHost failed to lookup SMBIOS - %r", Status));
+    DEBUG ((DEBUG_VERBOSE, "SmbiosLookupHost failed to lookup SMBIOS - %r\n", Status));
   }
 
   Status  = EfiGetSystemConfigurationTable (
@@ -1616,7 +1623,7 @@ SmbiosTableAllocate (
               );
 
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_VERBOSE, "SmbiosLookupHost failed to lookup SMBIOSv3 - %r", Status));
+    DEBUG ((DEBUG_VERBOSE, "SmbiosLookupHost failed to lookup SMBIOSv3 - %r\n", Status));
   }
 
   //
@@ -1651,7 +1658,7 @@ SmbiosTableAllocate (
 
   Status = SmbiosExtendTable (SmbiosTable, 1);
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_VERBOSE, "SmbiosLookupHost failed to lookup SMBIOSv3 - %r", Status));
+    DEBUG ((DEBUG_VERBOSE, "SmbiosLookupHost failed to lookup SMBIOSv3 - %r\n", Status));
   }
 
   return Status;
@@ -1665,6 +1672,10 @@ SmbiosTableApply (
 {
   SmbiosHandleLegacyRegion (TRUE);
 
+  if (mOriginalSmbios == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
   CopyMem ((VOID *)(UINTN)mOriginalSmbios->TableAddress,
            SmbiosTable->Table,
            SmbiosTable->CurrentPtr.Raw - SmbiosTable->Table

Tests/SmbiosTest/SmbiosTest.c

 /** @file
-  Test bless support.
+  Test smbios support.
 
 Copyright (c) 2018, vit9696. All rights reserved.<BR>
 This program and the accompanying materials

TestsUser/Include/Base.h

+/** @file
+  Copyright (C) 2016 - 2019, vit9696. All rights reserved.
+
+  All rights reserved.
+
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+
+#ifndef UEFI_BASE_H
+#define UEFI_BASE_H
+
+//
+// Includes
+//
+#include <string.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <assert.h>
+#include <cpuid.h>
+
+//
+// Types and limits
+//
+
+#define MAX_UINT8     UINT8_MAX
+#define MAX_UINT16    UINT16_MAX
+#define MAX_UINT32    UINT32_MAX
+#define MAX_UINT64    UINT64_MAX
+#define MAX_BIT       0x8000000000000000
+#define EFI_PAGE_SIZE  0x1000
+#define EFI_PAGE_MASK  0xFFF
+#define EFI_PAGE_SHIFT 12
+
+#define MDE_CPU_X64
+#define VOID void
+#define CONST const
+#define STATIC static
+typedef char CHAR8;
+typedef short CHAR16;
+typedef signed char INT8;
+typedef unsigned char UINT8;
+typedef ssize_t INTN;
+typedef size_t UINTN;
+typedef bool BOOLEAN;
+typedef int32_t INT32;
+typedef uint32_t UINT32;
+typedef int64_t INT64;
+typedef uint64_t UINT64;
+typedef int16_t INT16;
+typedef uint16_t UINT16;
+typedef size_t EFI_STATUS;
+typedef UINTN RETURN_STATUS;
+typedef UINT64 EFI_PHYSICAL_ADDRESS;
+typedef UINT64 EFI_VIRTUAL_ADDRESS;
+typedef VOID *EFI_HANDLE;
+typedef VOID *EFI_EVENT;
+typedef UINTN *BASE_LIST;
+
+typedef struct {
+  UINT32  Data1;
+  UINT16  Data2;
+  UINT16  Data3;
+  UINT8   Data4[8];
+} GUID;
+
+typedef enum {
+  AllocateAnyPages,
+  AllocateMaxAddress,
+  AllocateAddress,
+  MaxAllocateType
+} EFI_ALLOCATE_TYPE;
+
+typedef enum {
+  EfiReservedMemoryType,
+  EfiLoaderCode,
+  EfiLoaderData,
+  EfiBootServicesCode,
+  EfiBootServicesData,
+  EfiRuntimeServicesCode,
+  EfiRuntimeServicesData,
+  EfiConventionalMemory,
+  EfiUnusableMemory,
+  EfiACPIReclaimMemory,
+  EfiACPIMemoryNVS,
+  EfiMemoryMappedIO,
+  EfiMemoryMappedIOPortSpace,
+  EfiPalCode,
+  EfiPersistentMemory,
+  EfiMaxMemoryType
+} EFI_MEMORY_TYPE;
+
+typedef GUID EFI_GUID;
+typedef struct EFI_SYSTEM_TABLE_ EFI_SYSTEM_TABLE;
+typedef struct EFI_BOOT_SERVICES_ EFI_BOOT_SERVICES;
+typedef struct EFI_RUNTIME_SERVICES_ EFI_RUNTIME_SERVICES;
+typedef VOID (*EFI_EVENT_NOTIFY)(EFI_EVENT Event, VOID *Context);
+
+#define IN
+#define OUT
+#define OPTIONAL
+#define EFIAPI
+#define TRUE true
+#define FALSE false
+#define VA_LIST va_list
+#define VA_ARG va_arg
+#define VA_START va_start
+#define VA_END va_end
+#define VERIFY_SIZE_OF(TYPE, Size) extern unsigned char _VerifySizeof##TYPE[(sizeof(TYPE) == (Size)) / (sizeof(TYPE) == (Size))]
+#define EFI_D_ERROR stderr
+#define EFI_D_VERBOSE stdout
+#define DEBUG_ERROR stderr
+#define DEBUG_INFO stdout
+#define DEBUG_VERBOSE stdout
+#define DEBUG_WARN stderr
+#define PACKED
+#define GLOBAL_REMOVE_IF_UNREFERENCED
+
+//
+// Return codes
+//
+#define ENCODE_ERROR(a)              ((RETURN_STATUS)(MAX_BIT | (a)))
+
+#define ENCODE_WARNING(a)            ((RETURN_STATUS)(a))
+#define RETURN_ERROR(a)              (((INTN)(RETURN_STATUS)(a)) < 0)
+
+#define RETURN_SUCCESS               0
+#define RETURN_LOAD_ERROR            ENCODE_ERROR (1)
+#define RETURN_INVALID_PARAMETER     ENCODE_ERROR (2)
+#define RETURN_UNSUPPORTED           ENCODE_ERROR (3)
+#define RETURN_BAD_BUFFER_SIZE       ENCODE_ERROR (4)
+#define RETURN_BUFFER_TOO_SMALL      ENCODE_ERROR (5)
+#define RETURN_NOT_READY             ENCODE_ERROR (6)
+#define RETURN_DEVICE_ERROR          ENCODE_ERROR (7)
+#define RETURN_WRITE_PROTECTED       ENCODE_ERROR (8)
+#define RETURN_OUT_OF_RESOURCES      ENCODE_ERROR (9)
+#define RETURN_VOLUME_CORRUPTED      ENCODE_ERROR (10)
+#define RETURN_VOLUME_FULL           ENCODE_ERROR (11)
+#define RETURN_NO_MEDIA              ENCODE_ERROR (12)
+#define RETURN_MEDIA_CHANGED         ENCODE_ERROR (13)
+#define RETURN_NOT_FOUND             ENCODE_ERROR (14)
+#define RETURN_ACCESS_DENIED         ENCODE_ERROR (15)
+#define RETURN_NO_RESPONSE           ENCODE_ERROR (16)
+#define RETURN_NO_MAPPING            ENCODE_ERROR (17)
+#define RETURN_TIMEOUT               ENCODE_ERROR (18)
+#define RETURN_NOT_STARTED           ENCODE_ERROR (19)
+#define RETURN_ALREADY_STARTED       ENCODE_ERROR (20)
+#define RETURN_ABORTED               ENCODE_ERROR (21)
+#define RETURN_ICMP_ERROR            ENCODE_ERROR (22)
+#define RETURN_TFTP_ERROR            ENCODE_ERROR (23)
+#define RETURN_PROTOCOL_ERROR        ENCODE_ERROR (24)
+#define RETURN_INCOMPATIBLE_VERSION  ENCODE_ERROR (25)
+#define RETURN_SECURITY_VIOLATION    ENCODE_ERROR (26)
+#define RETURN_CRC_ERROR             ENCODE_ERROR (27)
+#define RETURN_END_OF_MEDIA          ENCODE_ERROR (28)
+#define RETURN_END_OF_FILE           ENCODE_ERROR (31)
+
+#define EFI_SUCCESS               RETURN_SUCCESS
+#define EFI_LOAD_ERROR            RETURN_LOAD_ERROR
+#define EFI_INVALID_PARAMETER     RETURN_INVALID_PARAMETER
+#define EFI_UNSUPPORTED           RETURN_UNSUPPORTED
+#define EFI_BAD_BUFFER_SIZE       RETURN_BAD_BUFFER_SIZE
+#define EFI_BUFFER_TOO_SMALL      RETURN_BUFFER_TOO_SMALL
+#define EFI_NOT_READY             RETURN_NOT_READY
+#define EFI_DEVICE_ERROR          RETURN_DEVICE_ERROR
+#define EFI_WRITE_PROTECTED       RETURN_WRITE_PROTECTED
+#define EFI_OUT_OF_RESOURCES      RETURN_OUT_OF_RESOURCES
+#define EFI_VOLUME_CORRUPTED      RETURN_VOLUME_CORRUPTED
+#define EFI_VOLUME_FULL           RETURN_VOLUME_FULL
+#define EFI_NO_MEDIA              RETURN_NO_MEDIA
+#define EFI_MEDIA_CHANGED         RETURN_MEDIA_CHANGED
+#define EFI_NOT_FOUND             RETURN_NOT_FOUND
+#define EFI_ACCESS_DENIED         RETURN_ACCESS_DENIED
+#define EFI_NO_RESPONSE           RETURN_NO_RESPONSE
+#define EFI_NO_MAPPING            RETURN_NO_MAPPING
+#define EFI_TIMEOUT               RETURN_TIMEOUT
+#define EFI_NOT_STARTED           RETURN_NOT_STARTED
+#define EFI_ALREADY_STARTED       RETURN_ALREADY_STARTED
+#define EFI_ABORTED               RETURN_ABORTED
+#define EFI_ICMP_ERROR            RETURN_ICMP_ERROR
+#define EFI_TFTP_ERROR            RETURN_TFTP_ERROR
+#define EFI_PROTOCOL_ERROR        RETURN_PROTOCOL_ERROR
+#define EFI_INCOMPATIBLE_VERSION  RETURN_INCOMPATIBLE_VERSION
+#define EFI_SECURITY_VIOLATION    RETURN_SECURITY_VIOLATION
+#define EFI_CRC_ERROR             RETURN_CRC_ERROR
+#define EFI_END_OF_MEDIA          RETURN_END_OF_MEDIA
+#define EFI_END_OF_FILE           RETURN_END_OF_FILE
+
+#define EFI_WARN_UNKNOWN_GLYPH    RETURN_WARN_UNKNOWN_GLYPH
+#define EFI_WARN_DELETE_FAILURE   RETURN_WARN_DELETE_FAILURE
+#define EFI_WARN_WRITE_FAILURE    RETURN_WARN_WRITE_FAILURE
+#define EFI_WARN_BUFFER_TOO_SMALL RETURN_WARN_BUFFER_TOO_SMALL
+
+//
+// Bits
+//
+
+#define  BIT0     0x00000001
+#define  BIT1     0x00000002
+#define  BIT2     0x00000004
+#define  BIT3     0x00000008
+#define  BIT4     0x00000010
+#define  BIT5     0x00000020
+#define  BIT6     0x00000040
+#define  BIT7     0x00000080
+#define  BIT8     0x00000100
+#define  BIT9     0x00000200
+#define  BIT10    0x00000400
+#define  BIT11    0x00000800
+#define  BIT12    0x00001000
+#define  BIT13    0x00002000
+#define  BIT14    0x00004000
+#define  BIT15    0x00008000
+#define  BIT16    0x00010000
+#define  BIT17    0x00020000
+#define  BIT18    0x00040000
+#define  BIT19    0x00080000
+#define  BIT20    0x00100000
+#define  BIT21    0x00200000
+#define  BIT22    0x00400000
+#define  BIT23    0x00800000
+#define  BIT24    0x01000000
+#define  BIT25    0x02000000
+#define  BIT26    0x04000000
+#define  BIT27    0x08000000
+#define  BIT28    0x10000000
+#define  BIT29    0x20000000
+#define  BIT30    0x40000000
+#define  BIT31    0x80000000
+#define  BIT32    0x0000000100000000ULL
+#define  BIT33    0x0000000200000000ULL
+#define  BIT34    0x0000000400000000ULL
+#define  BIT35    0x0000000800000000ULL
+#define  BIT36    0x0000001000000000ULL
+#define  BIT37    0x0000002000000000ULL
+#define  BIT38    0x0000004000000000ULL
+#define  BIT39    0x0000008000000000ULL
+#define  BIT40    0x0000010000000000ULL
+#define  BIT41    0x0000020000000000ULL
+#define  BIT42    0x0000040000000000ULL
+#define  BIT43    0x0000080000000000ULL
+#define  BIT44    0x0000100000000000ULL
+#define  BIT45    0x0000200000000000ULL
+#define  BIT46    0x0000400000000000ULL
+#define  BIT47    0x0000800000000000ULL
+#define  BIT48    0x0001000000000000ULL
+#define  BIT49    0x0002000000000000ULL
+#define  BIT50    0x0004000000000000ULL
+#define  BIT51    0x0008000000000000ULL
+#define  BIT52    0x0010000000000000ULL
+#define  BIT53    0x0020000000000000ULL
+#define  BIT54    0x0040000000000000ULL
+#define  BIT55    0x0080000000000000ULL
+#define  BIT56    0x0100000000000000ULL
+#define  BIT57    0x0200000000000000ULL
+#define  BIT58    0x0400000000000000ULL
+#define  BIT59    0x0800000000000000ULL
+#define  BIT60    0x1000000000000000ULL
+#define  BIT61    0x2000000000000000ULL
+#define  BIT62    0x4000000000000000ULL
+#define  BIT63    0x8000000000000000ULL
+
+//
+// Bases
+//
+
+#define  BASE_1KB    0x00000400
+#define  BASE_2KB    0x00000800
+#define  BASE_4KB    0x00001000
+#define  BASE_8KB    0x00002000
+#define  BASE_16KB   0x00004000
+#define  BASE_32KB   0x00008000
+#define  BASE_64KB   0x00010000
+#define  BASE_128KB  0x00020000
+#define  BASE_256KB  0x00040000
+#define  BASE_512KB  0x00080000
+#define  BASE_1MB    0x00100000
+#define  BASE_2MB    0x00200000
+#define  BASE_4MB    0x00400000
+#define  BASE_8MB    0x00800000
+#define  BASE_16MB   0x01000000
+#define  BASE_32MB   0x02000000
+#define  BASE_64MB   0x04000000
+#define  BASE_128MB  0x08000000
+#define  BASE_256MB  0x10000000
+#define  BASE_512MB  0x20000000
+#define  BASE_1GB    0x40000000
+#define  BASE_2GB    0x80000000
+#define  BASE_4GB    0x0000000100000000ULL
+#define  BASE_8GB    0x0000000200000000ULL
+#define  BASE_16GB   0x0000000400000000ULL
+#define  BASE_32GB   0x0000000800000000ULL
+#define  BASE_64GB   0x0000001000000000ULL
+#define  BASE_128GB  0x0000002000000000ULL
+#define  BASE_256GB  0x0000004000000000ULL
+#define  BASE_512GB  0x0000008000000000ULL
+#define  BASE_1TB    0x0000010000000000ULL
+#define  BASE_2TB    0x0000020000000000ULL
+#define  BASE_4TB    0x0000040000000000ULL
+#define  BASE_8TB    0x0000080000000000ULL
+#define  BASE_16TB   0x0000100000000000ULL
+#define  BASE_32TB   0x0000200000000000ULL
+#define  BASE_64TB   0x0000400000000000ULL
+#define  BASE_128TB  0x0000800000000000ULL
+#define  BASE_256TB  0x0001000000000000ULL
+#define  BASE_512TB  0x0002000000000000ULL
+#define  BASE_1PB    0x0004000000000000ULL
+#define  BASE_2PB    0x0008000000000000ULL
+#define  BASE_4PB    0x0010000000000000ULL
+#define  BASE_8PB    0x0020000000000000ULL
+#define  BASE_16PB   0x0040000000000000ULL
+#define  BASE_32PB   0x0080000000000000ULL
+#define  BASE_64PB   0x0100000000000000ULL
+#define  BASE_128PB  0x0200000000000000ULL
+#define  BASE_256PB  0x0400000000000000ULL
+#define  BASE_512PB  0x0800000000000000ULL
+#define  BASE_1EB    0x1000000000000000ULL
+#define  BASE_2EB    0x2000000000000000ULL
+#define  BASE_4EB    0x4000000000000000ULL
+#define  BASE_8EB    0x8000000000000000ULL
+
+//
+// Functional macros
+//
+
+#define DEBUG(X) ppprintf X
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+#define EFI_ERROR(x) ((x) != 0)
+#define OFFSET_OF(Base, Type) offsetof(Base, Type)
+#define ALIGN_VALUE(Value, Alignment) ((Value) + (((Alignment) - (Value)) & ((Alignment) - 1)))
+#define MAX(a, b) \
+  (((a) > (b)) ? (a) : (b))
+#define MIN(a, b) \
+  (((a) < (b)) ? (a) : (b))
+#define DEBUG_CODE_BEGIN()  do { if (DebugCodeEnabled ()) { UINT8  __DebugCodeLocal
+#define DEBUG_CODE_END()    __DebugCodeLocal = 0; __DebugCodeLocal++; } } while (FALSE)
+#define DEBUG_CODE(Expression)  \
+  DEBUG_CODE_BEGIN ();          \
+  Expression                    \
+  DEBUG_CODE_END ()
+#define EFI_SIZE_TO_PAGES(a)  (((a) >> EFI_PAGE_SHIFT) + (((a) & EFI_PAGE_MASK) ? 1 : 0))
+#define EFI_PAGES_TO_SIZE(a)   ( (a) << EFI_PAGE_SHIFT)
+
+
+//
+// Functions
+//
+
+#define AllocatePool(x) malloc(x)
+#define AllocateZeroPool(x) calloc(1, x)
+#define ReallocatePool(a,b,c) realloc(c,b)
+#define FreePool(x) free(x)
+#define CopyMem(a,b,c) memcpy((a),(b),(c))
+#define ZeroMem(a,b) memset(a, 0, b)
+#define AsciiSPrint snppprintf
+#define AsciiStrCmp strcmp
+#define AsciiStrLen strlen
+#define AsciiStrStr strstr
+#define AsciiStrnCmp strncmp
+#define AsciiStrSize(x) (strlen(x) + 1)
+#define AsciiStrnCpyS(a, b, c, d) strlcpy(a, c, b)
+#define AsciiStrDecimalToUint64(a) strtoull(a, NULL, 10)
+#define AsciiStrHexToUint64(a) strtoull(a, NULL, 16)
+#define ASSERT assert
+#define DebugCodeEnabled() false
+
+EFI_STATUS EfiGetSystemConfigurationTable (EFI_GUID *TableGuid, OUT VOID **Table);
+
+//
+// Dirty printf implementation
+//
+
+STATIC
+VOID
+ppptransform (
+  CHAR8  *Buffer
+  )
+{
+  char *AAA = NULL;
+
+  #define REPL(P, V) \
+    do { \
+      AAA = strstr(Buffer, P); \
+      if (AAA) \
+        AAA[1] = V; \
+    } while (AAA != NULL);
+
+
+  REPL("%a", 's')
+  REPL("%r", 'p')
+  REPL("%g", 'p')
+
+  #undef REPL
+}
+
+STATIC
+VOID
+ppprintf (
+  FILE        *Shit,
+  CONST CHAR8  *Src,
+  ...
+) {
+  char  Buffer[1024];
+  strlcpy (Buffer, Src, sizeof (Buffer));
+
+  ppptransform(Buffer);
+
+  va_list args;
+
+  va_start(args, Src);
+  vprintf(Buffer, args);
+  va_end(args);
+}
+
+STATIC
+VOID
+snppprintf (
+  CHAR8  *Buf,
+  UINTN  Size,
+  CONST CHAR8 *Src,
+  ...
+  )
+{
+  char  Buffer[1024];
+  strlcpy(Buffer, Src, sizeof (Buffer));
+
+  ppptransform(Buffer);
+
+  va_list args;
+
+  va_start(args, Src);
+  vsnprintf(Buf, Size, Buffer, args);
+  va_end(args);
+}
+
+STATIC
+UINT64
+MultU64x32 (
+  UINT64 Multiplicand,
+  UINT32 Multiplier
+  )
+{
+  return Multiplicand * Multiplier;
+}
+
+STATIC
+UINT64
+DivU64x32 (
+  UINT64 Dividend,
+  UINT32 Divisor
+  )
+{
+  return Dividend / Divisor;
+}
+
+STATIC
+UINT64
+LShiftU64 (
+  UINT64 Operand,
+  UINTN Count
+  )
+{
+  return Operand << Count;
+}
+
+STATIC
+UINT64
+RShiftU64 (
+  UINT64 Operand,
+  UINTN Count
+  )
+{
+  return Operand >> Count;
+}
+
+STATIC
+UINT8
+CalculateSum8 (
+  IN UINT8  *Buffer,
+  IN UINTN  Size
+  )
+{
+  UINTN Index;
+  UINT8 Sum;
+
+  Sum = 0;
+
+  //
+  // Perform the byte sum for buffer
+  //
+  for (Index = 0; Index < Size; Index++) {
+    Sum = (UINT8) (Sum + Buffer[Index]);
+  }
+
+  return Sum;
+}
+
+STATIC
+UINT8
+CalculateCheckSum8 (
+  IN UINT8        *Buffer,
+  IN UINTN        Size
+  )
+{
+  return (UINT8) (0x100 - CalculateSum8 (Buffer, Size));
+}
+
+STATIC
+UINT32
+AsmCpuid (
+  UINT32 Index,
+  UINT32 *Eax,
+  UINT32 *Ebx,
+  UINT32 *Ecx,
+  UINT32 *Edx
+  )
+{
+  uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
+
+  asm ("xchgq %%rbx, %q1\n"
+       "cpuid\n"
+       "xchgq %%rbx, %q1"
+       : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
+       : "0" (Index));
+
+  if (Eax) *Eax = eax;
+  if (Ebx) *Ebx = ebx;
+  if (Ecx) *Ecx = ecx;
+  if (Edx) *Edx = edx;
+
+  return Index;
+}
+
+STATIC
+UINT64
+AsmReadMsr64 (
+  UINT32 Index
+  )
+{
+  return 0;
+}
+
+STATIC
+UINT64
+EFIAPI
+GetPerformanceCounterProperties (
+  UINT64  *StartValue,
+  UINT64  *EndValue
+  )
+{
+  return 0;
+}
+
+//
+// Services
+//
+
+struct EFI_BOOT_SERVICES_ {
+  EFI_STATUS (*LocateProtocol)(EFI_GUID *ProtocolGuid, VOID *Registration, VOID **Interface);
+};
+
+STATIC EFI_STATUS NilLocateProtocol(EFI_GUID *ProtocolGuid, VOID *Registration, VOID **Interface) {
+  (VOID) ProtocolGuid;
+  (VOID) Registration;
+  (VOID) Interface;
+  return EFI_NOT_FOUND;
+}
+
+STATIC EFI_BOOT_SERVICES gNilBS = {
+  .LocateProtocol = NilLocateProtocol
+};
+
+STATIC EFI_BOOT_SERVICES *gBS = &gNilBS;
+
+#endif

TestsUser/Macho/Macho.c

+/** @file
+  Copyright (C) 2018, vit9696. All rights reserved.
+
+  All rights reserved.
+
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include <Library/OcMachoLib.h>
+#include <Library/OcMiscLib.h>
+
+#include <sys/time.h>
+
+/*
+ clang -g -fsanitize=undefined,address -I../Include -I../../Include -include ../Include/Base.h -I../../../EfiPkg/Include/ Macho.c  ../../Library/OcMiscLib/Base64Decode.c ../../Library/OcStringLib/OcAsciiLib.c  ../../Library/OcMachoLib/CxxSymbols.c ../../Library/OcMachoLib/Header.c ../../Library/OcMachoLib/Relocations.c ../../Library/OcMachoLib/Symbols.c -o Macho
+
+ for fuzzing:
+ clang-mp-7.0 -Dmain=__main -g -fsanitize=undefined,address,fuzzer -I../Include -I../../Include -include ../Include/Base.h -I../../../EfiPkg/Include/ Macho.c  ../../Library/OcMiscLib/Base64Decode.c ../../Library/OcStringLib/OcAsciiLib.c  ../../Library/OcMachoLib/CxxSymbols.c ../../Library/OcMachoLib/Header.c ../../Library/OcMachoLib/Relocations.c ../../Library/OcMachoLib/Symbols.c -o Macho
+ rm -rf DICT fuzz*.log ; mkdir DICT ; cp /System/Library/Kernels/kernel DICT ; ./Macho -rss_limit_mb=4096M -jobs=4 DICT
+
+ rm -rf fuzz*.log ; mkdir -p DICT ; cp /System/Library/Kernels/kernel DICT/kernel ; ./Macho -jobs=4 -rss_limit_mb=4096M DICT
+
+ rm -rf Macho.dSYM DICT fuzz*.log Macho
+*/
+
+uint8_t *readFile(const char *str, uint32_t *size) {
+  FILE *f = fopen(str, "rb");
+
+  if (!f) return NULL;
+
+  fseek(f, 0, SEEK_END);
+  long fsize = ftell(f);
+  fseek(f, 0, SEEK_SET);
+
+  uint8_t *string = malloc(fsize + 1);
+  fread(string, fsize, 1, f);
+  fclose(f);
+
+  string[fsize] = 0;
+  *size = fsize;
+
+  return string;
+}
+
+MACH_HEADER_64 Header;
+MACH_SECTION_64 Sect;
+MACH_SEGMENT_COMMAND_64 Seg;
+MACH_UUID_COMMAND Uuid;
+
+static int FeedMacho(void *file, uint32_t size) {
+  OC_MACHO_CONTEXT Context;
+  if (!MachoInitializeContext (&Context, file, size)) {
+    return -1;
+  }
+
+  int code = 0;
+
+  MACH_HEADER_64 *Hdr = MachoGetMachHeader64 (&Context);
+  if (Hdr && MachoGetFileSize(&Context) > 10 && MachoGetLastAddress64(&Context) != 10) {
+    memcpy(&Header, Hdr, sizeof(Header));
+    code++;
+  }
+
+  MACH_UUID_COMMAND *Cmd = MachoGetUuid64(&Context);
+  if (Cmd) {
+    memcpy(&Uuid, Cmd, sizeof(Uuid));
+    code++;
+  }
+
+  MACH_SEGMENT_COMMAND_64 *Segment = MachoGetSegmentByName64(&Context, "__LINKEDIT");
+  MACH_SECTION_64 *Section;
+  if (Segment) {
+    memcpy(&Seg, Segment, sizeof(Seg));
+    Section = MachoGetSectionByName64 (&Context, Segment, "__objc");
+    if (Section) {
+      memcpy(&Sect, Section, sizeof(Sect));
+      code++;
+    }
+  }
+
+  uint32_t index = 0;
+  while ((Section = MachoGetSectionByIndex64 (&Context, index))) {
+    memcpy(&Sect, Section, sizeof(Sect));
+    index++;
+  }
+
+  if ((Section = MachoGetSectionByAddress64 (&Context, index))) {
+    memcpy(&Sect, Section, sizeof(Sect));
+    code++;
+  }
+
+  MACH_NLIST_64 *Symbol = NULL;
+  for (index = 0; (Symbol = MachoGetSymbolByIndex64 (&Context, index)) != NULL; index++) {
+    CONST CHAR8 *Indirect = MachoGetIndirectSymbolName64 (&Context, Symbol);
+    if (!AsciiStrCmp (MachoGetSymbolName64 (&Context, Symbol), "__hack") ||
+      (Indirect && !AsciiStrCmp (Indirect, "__hack"))) {
+      code++;
+    }
+    if (MachoSymbolIsSection (Symbol)) {
+      code++;
+    }
+    if (MachoSymbolIsDefined (Symbol)) {
+      code++;
+    }
+    if (MachoSymbolIsLocalDefined (&Context, Symbol)) {
+      code++;
+    }
+
+    if (MachoIsSymbolValueInRange64 (&Context, Symbol)) {
+      code++;
+    }
+
+    UINT32 Offset;
+    if (MachoSymbolGetFileOffset64 (&Context, Symbol, &Offset)) {
+      code += Offset;
+    }
+
+    if (MachoSymbolNameIsPureVirtual (MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsPadslot (MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsSmcp64 (&Context, MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsMetaclassPointer64 (&Context, MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    char out[64];
+    if (MachoGetClassNameFromSuperMetaClassPointer (&Context, MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsVtable64 (MachoGetSymbolName64 (&Context, Symbol))) {
+      if (AsciiStrCmp(MachoGetClassNameFromVtableName (MachoGetSymbolName64 (&Context, Symbol)), "sym")) {
+        code++;
+      }
+    }
+
+    if (MachoGetFunctionPrefixFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetClassNameFromMetaClassPointer (&Context, MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetVtableNameFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetMetaVtableNameFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetFinalSymbolNameFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsCxx (MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    MACH_NLIST_64 *SCMP = MachoGetMetaclassSymbolFromSmcpSymbol64 (&Context, Symbol);
+    if (SCMP) {
+      if (!AsciiStrCmp (MachoGetSymbolName64 (&Context, SCMP), "__hack")) {
+        code++;
+      }
+
+      CONST MACH_NLIST_64  *Vtable;
+      CONST MACH_NLIST_64  *MetaVtable;
+      if (MachoGetVtableSymbolsFromSmcp64 (&Context, MachoGetSymbolName64 (&Context, SCMP), &Vtable, &MetaVtable)) {
+        if (!AsciiStrCmp (MachoGetSymbolName64 (&Context, Vtable), "__hack")) {
+          code++;
+        }
+        if (!AsciiStrCmp (MachoGetSymbolName64 (&Context, MetaVtable), "__hack")) {
+          code++;
+        }
+      }
+    }
+
+    MACH_NLIST_64 SSSS = *Symbol;
+    MachoRelocateSymbol64 (&Context, 0x100000000, &SSSS);
+  }
+
+  Symbol = MachoGetLocalDefinedSymbolByName (&Context, "_Assert");
+  if (Symbol) {
+    CONST CHAR8 *Indirect = MachoGetIndirectSymbolName64 (&Context, Symbol);
+    if (!AsciiStrCmp (MachoGetSymbolName64 (&Context, Symbol), "__hack") ||
+      (Indirect && !AsciiStrCmp (Indirect, "__hack"))) {
+      code++;
+    }
+    if (MachoSymbolIsSection (Symbol)) {
+      code++;
+    }
+    if (MachoSymbolIsDefined (Symbol)) {
+      code++;
+    }
+    if (MachoSymbolIsLocalDefined (&Context, Symbol)) {
+      code++;
+    }
+
+    if (MachoIsSymbolValueInRange64 (&Context, Symbol)) {
+      code++;
+    }
+    UINT32 Offset;
+    if (MachoSymbolGetFileOffset64 (&Context, Symbol, &Offset)) {
+      code += Offset;
+    }
+
+    if (MachoSymbolNameIsPureVirtual (MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsPadslot (MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsSmcp64 (&Context, MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsMetaclassPointer64 (&Context, MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+
+    char out[64];
+    if (MachoGetClassNameFromSuperMetaClassPointer (&Context, MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsVtable64 (MachoGetSymbolName64 (&Context, Symbol))) {
+      if (AsciiStrCmp(MachoGetClassNameFromVtableName (MachoGetSymbolName64 (&Context, Symbol)), "sym")) {
+        code++;
+      }
+    }
+
+    if (MachoGetFunctionPrefixFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetClassNameFromMetaClassPointer (&Context, MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetVtableNameFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetMetaVtableNameFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoGetFinalSymbolNameFromClassName (MachoGetSymbolName64 (&Context, Symbol), sizeof(out), out)
+      && !AsciiStrCmp("SomeReallyLongStringJustInCaseToCheckIt", out)) {
+      code++;
+    }
+
+    if (MachoSymbolNameIsCxx (MachoGetSymbolName64 (&Context, Symbol))) {
+      code++;
+    }
+  }
+
+  for (size_t i = 0x1000000; i < 0x100000000; i+= 0x1000000) {
+    if ((Symbol = MachoGetSymbolByExternRelocationOffset64 (&Context, i))) {
+      if (!AsciiStrCmp (MachoGetSymbolName64 (&Context, Symbol), "__hack")) {
+        code++;
+      }
+    }
+  }
+
+  return code != 963;
+}
+
+int main(int argc, char** argv) {
+  uint32_t f;
+  uint8_t *b;
+  if ((b = readFile(argc > 1 ? argv[1] : "kernel", &f)) == NULL) {
+    printf("Read fail\n");
+    return -1;
+  }
+
+  return FeedMacho (b, f);
+}
+
+INT32 LLVMFuzzerTestOneInput(CONST UINT8 *Data, UINTN Size) {
+  if (Size > 0) {
+    VOID *NewData = AllocatePool (Size);
+    if (NewData) {
+      CopyMem (NewData, Data, Size);
+      FeedMacho (NewData, (UINT32) Size);
+      FreePool (NewData);
+    }
+  }
+  return 0;
+}

TestsUser/Serialized/Serialized.c

+/** @file
+  Copyright (C) 2018, vit9696. All rights reserved.
+
+  All rights reserved.
+
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include <Library/OcTemplateLib.h>
+#include <Library/OcSerializeLib.h>
+#include <Library/OcMiscLib.h>
+
+#include <sys/time.h>
+
+/*
+ clang -g -fsanitize=undefined,address -I../Include -I../../Include -include ../Include/Base.h Serialized.c ../../Library/OcXmlLib/OcXmlLib.c ../../Library/OcTemplateLib/OcTemplateLib.c ../../Library/OcSerializeLib/OcSerializeLib.c ../../Library/OcMiscLib/Base64Decode.c ../../Library/OcStringLib/OcAsciiLib.c  -o Serialized
+
+ for fuzzing:
+ clang-mp-7.0 -Dmain=__main -g -fsanitize=undefined,address,fuzzer -I../Include -I../../Include -include ../Include/Base.h Serialized.c ../../Library/OcXmlLib/OcXmlLib.c ../../Library/OcTemplateLib/OcTemplateLib.c ../../Library/OcSerializeLib/OcSerializeLib.c ../../Library/OcMiscLib/Base64Decode.c ../../Library/OcStringLib/OcAsciiLib.c  -o Serialized
+ rm -rf DICT fuzz*.log ; mkdir DICT ; cp Serialized.plist DICT ; ./Serialized -jobs=4 DICT
+
+ rm -rf Serialized.dSYM DICT fuzz*.log Serialized
+*/
+
+VOID ConfigDestructCustom(VOID *Ptr, UINT32 Size) {
+  printf("ConfigDestructCustom for %p with %u\n", Ptr, Size);
+}
+
+#define A_FIELDS(_, __) \
+  _(int   , a, , 1   , ()             ) \
+  _(int   , b, , 2   , ()             ) \
+  _(char *, c, , NULL, OcFreePointer  )
+  OC_DECLARE (A)
+
+#define TEST_FIELDS(_, __) \
+  OC_ARRAY (A, _, __)
+  OC_DECLARE (TEST)
+
+#define BLOB_FIELDS(_, __) \
+  OC_BLOB (UINT8, [64], __({1, 2}), _, __)
+  OC_DECLARE (BLOB)
+
+#define STR_FIELDS(_, __) \
+  OC_BLOB (CHAR8, [64], "Hello", _, __)
+  OC_DECLARE (STR)
+
+#define CONFIG_FIELDS(_, __) \
+  _(bool    , val_b,     , true                   , ()                ) \
+  _(uint32_t, val32,     , 123                    , ()                ) \
+  _(char    , buf  , [16], "Hello"                , ()                ) \
+  _(uint8_t , data , [16], __({1, 2, 3, 4})       , ()                ) \
+  _(A       , str  ,     , OC_CONSTR(A, _, __)    , OC_DESTR (A)      ) \
+  _(char *  , heap ,     , NULL                   , OcFreePointer     ) \
+  _(TEST    , arr  ,     , OC_CONSTR(TEST, _, __) , OC_DESTR (TEST)   ) \
+  _(BLOB    , blob ,     , OC_CONSTR(BLOB, _, __) , OC_DESTR (BLOB)   ) \
+  _(STR     , dstr ,     , OC_CONSTR(STR, _, __)  , OC_DESTR (STR)    )
+  OC_DECLARE (CONFIG)
+
+//
+// Structure implementation...
+//
+
+OC_STRUCTORS (A, ())
+OC_STRUCTORS (TEST, ())
+OC_STRUCTORS (BLOB, ())
+OC_STRUCTORS (STR,  ())
+OC_STRUCTORS (CONFIG, ConfigDestructCustom)
+
+///////////////////////////////////////////////////////////////
+
+
+
+#define KEXT_MODIFICATION_FIELDS(_, __)  \
+  _(OC_STRING, Identifier , , OC_STRING_CONSTR ("", _, __), OC_DESTR (OC_STRING) ) \
+  _(OC_STRING, Symbol     , , OC_STRING_CONSTR ("", _, __), OC_DESTR (OC_STRING) ) \
+  _(OC_DATA  , Find       , , OC_DATA_CONSTR ({0}, _, __) , OC_DESTR (OC_DATA)   ) \
+  _(OC_DATA  , Mask       , , OC_DATA_CONSTR ({0}, _, __) , OC_DESTR (OC_DATA)   ) \
+  _(OC_DATA  , Replace    , , OC_DATA_CONSTR ({0}, _, __) , OC_DESTR (OC_DATA)   ) \
+  _(UINT32   , Count      , , 0                           , ()                   ) \
+  _(UINT32   , Skip       , , 0                           , ()                   )
+  OC_DECLARE (KEXT_MODIFICATION)
+
+#define DEVICE_PROP_MAP_FIELDS(_, __) \
+  OC_MAP (OC_STRING, OC_ASSOC, _, __)
+  OC_DECLARE (DEVICE_PROP_MAP)
+
+
+#define KEXT_MOD_ARRAY_FIELDS(_, __) \
+  OC_ARRAY (KEXT_MODIFICATION, _, __)
+  OC_DECLARE (KEXT_MOD_ARRAY)
+
+//
+// Target configuration layout
+//
+
+#define GLOBAL_CONFIGURATION_FIELDS(_, __) \
+  _(BOOLEAN                  , CleanAcpiHeaders  ,     , FALSE, ()) \
+  _(OC_STRING                , SmbiosProductName ,     , OC_STRING_CONSTR ("Computer1,1", _, __), OC_DESTR (OC_STRING) ) \
+  _(OC_ASSOC                 , NvramVariables    ,     , OC_CONSTR (OC_ASSOC, _, __)            , OC_DESTR (OC_ASSOC) ) \
+  _(KEXT_MOD_ARRAY           , KextMods          ,     , OC_CONSTR (KEXT_MOD_ARRAY, _, __)      , OC_DESTR (KEXT_MOD_ARRAY)) \
+  _(DEVICE_PROP_MAP          , DeviceProperties  ,     , OC_CONSTR (DEVICE_PROP_MAP, _, __)     , OC_DESTR (DEVICE_PROP_MAP)) \
+  _(UINT8                    , DataFixed         , [16], {0}                                    , ()) \
+  _(UINT8                    , DataMeta          , [16], {0}                                    , ()) \
+  _(OC_DATA                  , DataVar           ,     , OC_DATA_CONSTR ({0}, _, __)            , OC_DESTR (OC_DATA)   ) \
+  _(OC_DATA                  , DataMetaVar       ,     , OC_DATA_CONSTR ({0}, _, __)            , OC_DESTR (OC_DATA)   ) \
+  _(CHAR8                    , String            , [16], "Default"                              , ()) \
+  _(INT32                    , Test32            ,     , 0                                      , ())
+  OC_DECLARE (GLOBAL_CONFIGURATION)
+
+OC_STRUCTORS (KEXT_MODIFICATION, ())
+OC_ARRAY_STRUCTORS (KEXT_MOD_ARRAY)
+OC_MAP_STRUCTORS (DEVICE_PROP_MAP)
+OC_STRUCTORS (GLOBAL_CONFIGURATION, ())
+
+STATIC
+OC_SCHEMA
+mNullConfigurationSchema[] = {};
+
+//
+// ACPI Support
+//
+
+STATIC
+OC_SCHEMA
+mAcpiConfigurationSchema[] = {
+  OC_SCHEMA_BOOLEAN_IN ("CleanHeaders", GLOBAL_CONFIGURATION, CleanAcpiHeaders)
+};
+
+//
+// Device Properties Support
+//
+
+STATIC
+OC_SCHEMA
+mDevicePropertiesEntrySchema = OC_SCHEMA_MDATA (NULL);
+
+
+STATIC
+OC_SCHEMA
+mDevicePropertiesSchema = OC_SCHEMA_MAP (NULL, OC_ASSOC, &mDevicePropertiesEntrySchema);
+
+//
+// Miscellaneous Support
+//
+
+STATIC
+OC_SCHEMA
+mMiscConfigurationSchema[] = {
+  OC_SCHEMA_DATAF_IN   ("DataFix", GLOBAL_CONFIGURATION, DataFixed),
+  OC_SCHEMA_MDATAF_IN  ("DataMeta", GLOBAL_CONFIGURATION, DataMeta),
+  OC_SCHEMA_DATA_IN    ("DataMetaVar", GLOBAL_CONFIGURATION, DataMetaVar),
+  OC_SCHEMA_DATA_IN    ("DataVar", GLOBAL_CONFIGURATION, DataVar),
+  OC_SCHEMA_STRINGF_IN ("String", GLOBAL_CONFIGURATION, String),
+  OC_SCHEMA_INTEGER_IN ("Test32", GLOBAL_CONFIGURATION, Test32)
+};
+
+//
+// Binary Modification Support
+//
+
+STATIC
+OC_SCHEMA
+mKextModConfigurationSchema[] = {
+  OC_SCHEMA_INTEGER_IN   ("Count", KEXT_MODIFICATION, Count),
+  OC_SCHEMA_DATA_IN      ("Find", KEXT_MODIFICATION, Find),
+  OC_SCHEMA_STRING_IN    ("Identifier", KEXT_MODIFICATION, Identifier),
+  OC_SCHEMA_DATA_IN      ("Mask", KEXT_MODIFICATION, Mask),
+  OC_SCHEMA_DATA_IN      ("Replace", KEXT_MODIFICATION, Replace),
+  OC_SCHEMA_STRING_IN    ("Symbol", KEXT_MODIFICATION, Symbol),
+  OC_SCHEMA_INTEGER_IN   ("Skip", KEXT_MODIFICATION, Skip)
+};
+
+STATIC
+OC_SCHEMA
+mKextModSchema = OC_SCHEMA_DICT (NULL, mKextModConfigurationSchema);
+
+STATIC
+OC_SCHEMA
+mModsConfigurationSchema[] = {
+  OC_SCHEMA_ARRAY_IN ("Kext", GLOBAL_CONFIGURATION, KextMods, &mKextModSchema)
+};
+
+//
+// NVRAM Support
+//
+
+STATIC
+OC_SCHEMA
+mNvramVariableSchema = OC_SCHEMA_MDATA (NULL);
+
+//
+// SMBIOS Support
+//
+
+STATIC
+OC_SCHEMA
+mSmbiosConfigurationSchema[] = {
+  OC_SCHEMA_STRING_IN ("ProductName", GLOBAL_CONFIGURATION, SmbiosProductName)
+};
+
+//
+// Root configuration
+//
+
+STATIC
+OC_SCHEMA
+mRootConfigurationNodes[] = {
+  OC_SCHEMA_DICT   ("ACPI", mAcpiConfigurationSchema),
+  OC_SCHEMA_MAP_IN ("DeviceProperties", GLOBAL_CONFIGURATION, DeviceProperties, &mDevicePropertiesSchema),
+  OC_SCHEMA_DICT   ("Misc", mMiscConfigurationSchema),
+  OC_SCHEMA_DICT   ("Mods", mModsConfigurationSchema),
+  OC_SCHEMA_MAP_IN ("NVRAM", GLOBAL_CONFIGURATION, NvramVariables, &mNvramVariableSchema),
+  OC_SCHEMA_DICT   ("SMBIOS", mSmbiosConfigurationSchema)
+};
+
+STATIC
+OC_SCHEMA_INFO
+mRootConfigurationInfo = {
+  .Dict = {mRootConfigurationNodes, ARRAY_SIZE (mRootConfigurationNodes)}
+};
+
+STATIC
+GLOBAL_CONFIGURATION
+mGlobalConfiguration;
+
+
+long long current_timestamp() {
+    struct timeval te;
+    gettimeofday(&te, NULL); // get current time
+    long long milliseconds = te.tv_sec*1000LL + te.tv_usec/1000; // calculate milliseconds
+    // printf("milliseconds: %lld\n", milliseconds);
+    return milliseconds;
+}
+
+uint8_t *readFile(const char *str, uint32_t *size) {
+  FILE *f = fopen(str, "rb");
+
+  if (!f) return NULL;
+
+  fseek(f, 0, SEEK_END);
+  long fsize = ftell(f);
+  fseek(f, 0, SEEK_SET);
+
+  uint8_t *string = malloc(fsize + 1);
+  fread(string, fsize, 1, f);
+  fclose(f);
+
+  string[fsize] = 0;
+  *size = fsize;
+
+  return string;
+}
+
+int main(int argc, char** argv) {
+  uint32_t f;
+  uint8_t *b;
+  if ((b = readFile(argc > 1 ? argv[1] : "Serialized.plist", &f)) == NULL) {
+    printf("Read fail\n");
+    return -1;
+  }
+
+  CONFIG cfg;
+  CONFIG_CONSTRUCT (&cfg, sizeof (CONFIG));
+  CONFIG_DESTRUCT (&cfg, sizeof (CONFIG));
+
+  long long a = current_timestamp();
+
+  GLOBAL_CONFIGURATION_CONSTRUCT(&mGlobalConfiguration, sizeof (mGlobalConfiguration));
+
+  ParseSerialized (&mGlobalConfiguration, &mRootConfigurationInfo, b, f);
+
+  DEBUG((EFI_D_ERROR, "Done in %llu ms\n", current_timestamp() - a));
+
+  DEBUG((EFI_D_ERROR, "CleanAcpiHeaders %d\n", mGlobalConfiguration.CleanAcpiHeaders));
+  DEBUG((EFI_D_ERROR, "SmbiosProductName %s\n", mGlobalConfiguration.SmbiosProductName.Value));
+  UINT8  *Blob = mGlobalConfiguration.DataFixed;
+  DEBUG((EFI_D_ERROR, "DataFixed %02X %02X %02X %02X\n", Blob[0], Blob[1], Blob[2], Blob[3]));
+  Blob = mGlobalConfiguration.DataMeta;
+  DEBUG((EFI_D_ERROR, "DataMeta %02X %02X %02X %02X\n", Blob[0], Blob[1], Blob[2], Blob[3]));
+  Blob = OC_BLOB_GET (&mGlobalConfiguration.DataVar);
+  DEBUG((EFI_D_ERROR, "DataVar (%u) %02X %02X %02X %02X\n", mGlobalConfiguration.DataVar.Size, Blob[0], Blob[1], Blob[2], Blob[3]));
+  Blob = OC_BLOB_GET (&mGlobalConfiguration.DataMetaVar);
+  DEBUG((EFI_D_ERROR, "DataMetaVar (%u) %02X %02X %02X %02X\n", mGlobalConfiguration.DataMetaVar.Size, Blob[0], Blob[1], Blob[2], Blob[3]));
+  DEBUG((EFI_D_ERROR, "Test32 %u\n", mGlobalConfiguration.Test32));
+
+  DEBUG((EFI_D_ERROR, "KextMod has %u entries\n", mGlobalConfiguration.KextMods.Count));
+  for (UINT32 i = 0; i < mGlobalConfiguration.KextMods.Count; i++) {
+    DEBUG((EFI_D_ERROR, "KextMod %u is for %s kext\n", i, OC_BLOB_GET (&mGlobalConfiguration.KextMods.Values[i]->Identifier)));
+  }
+
+  DEBUG((EFI_D_ERROR, "NVRAM has %u entries\n", mGlobalConfiguration.NvramVariables.Count));
+  for (UINT32 i = 0; i < mGlobalConfiguration.NvramVariables.Count; i++) {
+    CHAR8 *Str  = OC_BLOB_GET (mGlobalConfiguration.NvramVariables.Keys[i]);
+    UINT8 *Blob = OC_BLOB_GET (mGlobalConfiguration.NvramVariables.Values[i]);
+    DEBUG((EFI_D_ERROR, "NVRAM %u %s gives %.64s value\n", i, Str, (CHAR8 *) Blob));
+  }
+
+  DEBUG((EFI_D_ERROR, "DevProps have %u entries\n", mGlobalConfiguration.DeviceProperties.Count));
+  for (UINT32 i = 0; i < mGlobalConfiguration.DeviceProperties.Count; i++) {
+    CHAR8 *Str  = OC_BLOB_GET (mGlobalConfiguration.DeviceProperties.Keys[i]);
+    DEBUG((EFI_D_ERROR, "DevProps device %u is called %.64s and has %u props\n", i, Str,
+      mGlobalConfiguration.DeviceProperties.Values[i]->Count));
+
+    for (UINT32 j = 0; j < mGlobalConfiguration.DeviceProperties.Values[i]->Count; j++) {
+      CHAR8 *Str  = OC_BLOB_GET (mGlobalConfiguration.DeviceProperties.Values[i]->Keys[j]);
+      UINT8 *Blob = OC_BLOB_GET (mGlobalConfiguration.DeviceProperties.Values[i]->Values[j]);
+      DEBUG((EFI_D_ERROR, " Prop %u is called %.64s and has value %.64s\n", j,
+        Str, Blob));
+    }
+  }
+
+  GLOBAL_CONFIGURATION_DESTRUCT (&mGlobalConfiguration, sizeof (mGlobalConfiguration));
+  free(b);
+
+  return 0;
+}
+
+INT32 LLVMFuzzerTestOneInput(CONST UINT8 *Data, UINTN Size) {
+  VOID *NewData = AllocatePool (Size);
+  if (NewData) {
+    CopyMem (NewData, Data, Size);
+    GLOBAL_CONFIGURATION_CONSTRUCT (&mGlobalConfiguration, sizeof (mGlobalConfiguration));
+    ParseSerialized (&mGlobalConfiguration, &mRootConfigurationInfo, NewData, Size);
+    GLOBAL_CONFIGURATION_DESTRUCT (&mGlobalConfiguration, sizeof (mGlobalConfiguration));
+    FreePool (NewData);
+  }
+  return 0;
+}
+

TestsUser/Serialized/Serialized.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>ACPI</key>
+	<dict>
+		<key>CleanHeaders</key>
+		<true/>
+	</dict>
+	<key>DeviceProperties</key>
+	<dict>
+		<key>DeviceName1</key>
+		<dict>
+			<key>Prop1</key>
+			<string>Val1</string>
+			<key>Prop2</key>
+			<string>Val2</string>
+		</dict>
+		<key>DeviceName2</key>
+		<dict>
+			<key>Prop21</key>
+			<string>Val21</string>
+			<key>Prop22</key>
+			<string>Val22</string>
+		</dict>
+	</dict>
+	<key>Misc</key>
+	<dict>
+		<key>DataFix</key>
+		<data>ESIz</data>
+		<key>DataVar</key>
+		<data>RFVm</data>
+		<key>DataMeta</key>
+		<string>123</string>
+		<key>DataMetaVar</key>
+		<data>MTIzAA==</data>
+		<key>DataMeta3</key>
+		<true/>
+		<key>DataMeta4</key>
+		<integer>65535</integer>
+		<key>Test32</key>
+		<integer>123456</integer>
+	</dict>
+	<key>Mods</key>
+	<dict>
+		<key>Kext</key>
+		<array>
+			<dict>
+				<key>Identifier</key>
+				<string>Hello</string>
+			</dict>
+			<dict>
+				<key>Identifier</key>
+				<string>Idt</string>
+			</dict>
+		</array>
+	</dict>
+	<key>NVRAM</key>
+	<dict>
+		<key>COOL:boot-args</key>
+		<string>nopasaran=1 debug=1</string>
+		<key>HACK:booter</key>
+		<string>#something</string>
+	</dict>
+	<key>SMBIOS</key>
+	<dict>
+		<key>ProductName</key>
+		<string>Computer2,1</string>
+	</dict>
+</dict>
+</plist>

TestsUser/Smbios/Smbios.c

+/** @file
+  Copyright (C) 2018, vit9696. All rights reserved.
+
+  All rights reserved.
+
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include <Library/OcSmbiosLib.h>
+#include <Library/OcMiscLib.h>
+#include <IndustryStandard/AppleSmBios.h>
+
+#include <sys/time.h>
+
+/*
+ clang -g -fsanitize=undefined,address -I../Include -I../../Include -I../../../EfiPkg/Include/ -I../../../MdePkg/Include/ -I../../../IntelFrameworkPkg/Include/ -I../../../UefiCpuPkg/Include/ -include ../Include/Base.h Smbios.c ../../Library/OcSmbiosLib/DebugSmbios.c ../../Library/OcSmbiosLib/SmbiosInternal.c ../../Library/OcSmbiosLib/SmbiosPatch.c ../../Library/OcStringLib/OcAsciiLib.c ../../Library/OcMiscLib/LegacyRegionLock.c ../../Library/OcMiscLib/LegacyRegionUnlock.c ../../Library/OcCpuLib/OcCpuLib.c -o Smbios
+
+ for fuzzing:
+ clang-mp-7.0 -Dmain=__main -g -fsanitize=undefined,address,fuzzer -I../Include -I../../Include -I../../../EfiPkg/Include/ -I../../../MdePkg/Include/ -I../../../IntelFrameworkPkg/Include/ -I../../../UefiCpuPkg/Include/ -include ../Include/Base.h Smbios.c ../../Library/OcSmbiosLib/DebugSmbios.c ../../Library/OcSmbiosLib/SmbiosInternal.c ../../Library/OcSmbiosLib/SmbiosPatch.c ../../Library/OcStringLib/OcAsciiLib.c ../../Library/OcMiscLib/LegacyRegionLock.c ../../Library/OcMiscLib/LegacyRegionUnlock.c ../../Library/OcCpuLib/OcCpuLib.c -o Smbios
+
+ rm -rf DICT fuzz*.log ; mkdir DICT ; cp Smbios.bin DICT ; ./Smbios -jobs=4 DICT
+
+ rm -rf Smbios.dSYM DICT fuzz*.log Smbios
+*/
+
+uint8_t *readFile(const char *str, uint32_t *size) {
+  FILE *f = fopen(str, "rb");
+
+  if (!f) return NULL;
+
+  fseek(f, 0, SEEK_END);
+  long fsize = ftell(f);
+  fseek(f, 0, SEEK_SET);
+
+  uint8_t *string = malloc(fsize + 1);
+  fread(string, fsize, 1, f);
+  fclose(f);
+
+  string[fsize] = 0;
+  *size = fsize;
+
+  return string;
+}
+
+EFI_GUID gEfiLegacyRegionProtocolGuid;
+EFI_GUID gEfiPciRootBridgeIoProtocolGuid;
+EFI_GUID gEfiSmbios3TableGuid;
+EFI_GUID gEfiSmbiosTableGuid;
+
+static GUID SystemUUID = {0x5BC82C38, 0x4DB6, 0x4883, {0x85, 0x2E, 0xE7, 0x8D, 0x78, 0x0A, 0x6F, 0xE6}};
+static OC_SMBIOS_DATA SmbiosData = {
+  .BIOSVendor = NULL, // Do not change BIOS Vendor
+  .BIOSVersion = "134.0.0.0.0",
+  .BIOSReleaseDate = "12/08/2017",
+  .SystemManufacturer = NULL, // Do not change System Manufacturer
+  .SystemProductName = "iMac14,2",
+  .SystemVersion = "1.0",
+  .SystemSerialNumber = "SU77OPENCORE",
+  .SystemUUID = &SystemUUID,
+  .SystemSKUNumber = "Mac-27ADBB7B4CEE8E61",
+  .SystemFamily = "iMac",
+  .BoardManufacturer = NULL, // Do not change Board Manufacturer
+  .BoardProduct = "Mac-27ADBB7B4CEE8E61",
+  .BoardVersion = "iMac14,2",
+  .BoardSerialNumber = "SU77PEPELATZWAFFE",
+  .BoardAssetTag = "",
+  .BoardLocationInChassis = "Part Component",
+  .BoardType = 0xA, // Motherboard (BaseBoardTypeMotherBoard)
+  .MemoryFormFactor = 0xD, // SODIMM, 0x9 for DIMM (MemoryFormFactorSodimm)
+  .ChassisType = 0xD, // All in one (MiscChassisTypeAllInOne)
+  .ChassisManufacturer = NULL, // Do not change Chassis Manufacturer
+  .ChassisVersion = "Mac-27ADBB7B4CEE8E61",
+  .ChassisSerialNumber = "SU77OPENCORE",
+  .ChassisAssetTag = "iMac-Aluminum",
+  .FirmwareFeatures = 0xE00FE137,
+  .FirmwareFeaturesMask = 0xFF1FFF3F,
+  .ExtendedFirmwareFeatures = 0xE00FE137,
+  .ExtendedFirmwareFeaturesMask = 0xFF1FFF3F,
+  .ProcessorType = 0, // Will be calculated automatically
+  .ProcessorBusSpeed = 0, // unused
+  .PlatformFeature = 1
+};
+
+_Thread_local SMBIOS_TABLE_ENTRY_POINT        gSmbios;
+_Thread_local SMBIOS_TABLE_3_0_ENTRY_POINT    gSmbios3;
+
+EFI_STATUS EfiGetSystemConfigurationTable (EFI_GUID *TableGuid, OUT VOID **Table) {
+  /*if (Table && TableGuid == &gEfiSmbiosTableGuid) {
+    *Table = &gSmbios;
+    return EFI_SUCCESS;
+  } else*/ if (Table && TableGuid == &gEfiSmbios3TableGuid) {
+    *Table = &gSmbios3;
+    return EFI_SUCCESS;
+  }
+
+  return EFI_NOT_FOUND;
+}
+
+int main(int argc, char** argv) {
+  uint32_t f;
+  uint8_t *b;
+  if ((b = readFile(argc > 1 ? argv[1] : "Smbios.bin", &f)) == NULL) {
+    printf("Read fail\n");
+    return -1;
+  }
+
+  gSmbios3.TableMaximumSize = f;
+  gSmbios3.TableAddress = (uintptr_t)b;
+
+  CreateSmBios (
+    &SmbiosData,
+    0
+    );
+
+  return 0;
+}
+
+INT32 LLVMFuzzerTestOneInput(CONST UINT8 *Data, UINTN Size) {
+  if (Size > 0) {
+    VOID *NewData = AllocatePool (Size);
+    if (NewData) {
+      CopyMem (NewData, Data, Size);
+
+      gSmbios3.TableMaximumSize = Size;
+      gSmbios3.TableAddress = (uintptr_t)NewData;
+
+      CreateSmBios (
+        &SmbiosData,
+        0
+        );
+
+      FreePool (NewData);
+    }
+  }
+  return 0;
+}