SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigMisc.c

   1 /** @file
   2   Helper functions for SecureBoot configuration module.
   3
   4 Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
   5 SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include "SecureBootConfigImpl.h"
  10
  11 /**
  12   Read file content into BufferPtr, the size of the allocate buffer
  13   is *FileSize plus AdditionAllocateSize.
  14
  15   @param[in]       FileHandle            The file to be read.
  16   @param[in, out]  BufferPtr             Pointers to the pointer of allocated buffer.
  17   @param[out]      FileSize              Size of input file
  18   @param[in]       AdditionAllocateSize   Addition size the buffer need to be allocated.
  19                                          In case the buffer need to contain others besides the file content.
  20
  21   @retval   EFI_SUCCESS                  The file was read into the buffer.
  22   @retval   EFI_INVALID_PARAMETER        A parameter was invalid.
  23   @retval   EFI_OUT_OF_RESOURCES         A memory allocation failed.
  24   @retval   others                       Unexpected error.
  25
  26 **/
  27 EFI_STATUS
  28 ReadFileContent (
  29   IN      EFI_FILE_HANDLE  FileHandle,
  30   IN OUT  VOID             **BufferPtr,
  31   OUT  UINTN               *FileSize,
  32   IN      UINTN            AdditionAllocateSize
  33   )
  34
  35 {
  36   UINTN       BufferSize;
  37   UINT64      SourceFileSize;
  38   VOID        *Buffer;
  39   EFI_STATUS  Status;
  40
  41   if ((FileHandle == NULL) || (FileSize == NULL)) {
  42     return EFI_INVALID_PARAMETER;
  43   }
  44
  45   Buffer = NULL;
  46
  47   //
  48   // Get the file size
  49   //
  50   Status = FileHandle->SetPosition (FileHandle, (UINT64)-1);
  51   if (EFI_ERROR (Status)) {
  52     goto ON_EXIT;
  53   }
  54
  55   Status = FileHandle->GetPosition (FileHandle, &SourceFileSize);
  56   if (EFI_ERROR (Status)) {
  57     goto ON_EXIT;
  58   }
  59
  60   Status = FileHandle->SetPosition (FileHandle, 0);
  61   if (EFI_ERROR (Status)) {
  62     goto ON_EXIT;
  63   }
  64
  65   BufferSize = (UINTN)SourceFileSize + AdditionAllocateSize;
  66   Buffer     =  AllocateZeroPool (BufferSize);
  67   if (Buffer == NULL) {
  68     return EFI_OUT_OF_RESOURCES;
  69   }
  70
  71   BufferSize = (UINTN)SourceFileSize;
  72   *FileSize  = BufferSize;
  73
  74   Status = FileHandle->Read (FileHandle, &BufferSize, Buffer);
  75   if (EFI_ERROR (Status) || (BufferSize != *FileSize)) {
  76     FreePool (Buffer);
  77     Buffer = NULL;
  78     Status = EFI_BAD_BUFFER_SIZE;
  79     goto ON_EXIT;
  80   }
  81
  82 ON_EXIT:
  83
  84   *BufferPtr = Buffer;
  85   return Status;
  86 }
  87
  88 /**
  89   Close an open file handle.
  90
  91   @param[in] FileHandle           The file handle to close.
  92
  93 **/
  94 VOID
  95 CloseFile (
  96   IN EFI_FILE_HANDLE  FileHandle
  97   )
  98 {
  99   if (FileHandle != NULL) {
 100     FileHandle->Close (FileHandle);
 101   }
 102 }
 103
 104 /**
 105   Convert a nonnegative integer to an octet string of a specified length.
 106
 107   @param[in]   Integer          Pointer to the nonnegative integer to be converted
 108   @param[in]   IntSizeInWords   Length of integer buffer in words
 109   @param[out]  OctetString      Converted octet string of the specified length
 110   @param[in]   OSSizeInBytes    Intended length of resulting octet string in bytes
 111
 112 Returns:
 113
 114   @retval   EFI_SUCCESS            Data conversion successfully
 115   @retval   EFI_BUFFER_TOOL_SMALL  Buffer is too small for output string
 116
 117 **/
 118 EFI_STATUS
 119 EFIAPI
 120 Int2OctStr (
 121   IN     CONST UINTN  *Integer,
 122   IN     UINTN        IntSizeInWords,
 123   OUT UINT8           *OctetString,
 124   IN     UINTN        OSSizeInBytes
 125   )
 126 {
 127   CONST UINT8  *Ptr1;
 128   UINT8        *Ptr2;
 129
 130   for (Ptr1 = (CONST UINT8 *)Integer, Ptr2 = OctetString + OSSizeInBytes - 1;
 131        Ptr1 < (UINT8 *)(Integer + IntSizeInWords) && Ptr2 >= OctetString;
 132        Ptr1++, Ptr2--)
 133   {
 134     *Ptr2 = *Ptr1;
 135   }
 136
 137   for ( ; Ptr1 < (CONST UINT8 *)(Integer + IntSizeInWords) && *Ptr1 == 0; Ptr1++) {
 138   }
 139
 140   if (Ptr1 < (CONST UINT8 *)(Integer + IntSizeInWords)) {
 141     return EFI_BUFFER_TOO_SMALL;
 142   }
 143
 144   if (Ptr2 >= OctetString) {
 145     ZeroMem (OctetString, Ptr2 - OctetString + 1);
 146   }
 147
 148   return EFI_SUCCESS;
 149 }
 150
 151 /**
 152   Worker function that prints an EFI_GUID into specified Buffer.
 153
 154   @param[in]     Guid          Pointer to GUID to print.
 155   @param[in]     Buffer        Buffer to print Guid into.
 156   @param[in]     BufferSize    Size of Buffer.
 157
 158   @retval    Number of characters printed.
 159
 160 **/
 161 UINTN
 162 GuidToString (
 163   IN  EFI_GUID  *Guid,
 164   IN  CHAR16    *Buffer,
 165   IN  UINTN     BufferSize
 166   )
 167 {
 168   UINTN  Size;
 169
 170   Size = UnicodeSPrint (
 171            Buffer,
 172            BufferSize,
 173            L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 174            (UINTN)Guid->Data1,
 175            (UINTN)Guid->Data2,
 176            (UINTN)Guid->Data3,
 177            (UINTN)Guid->Data4[0],
 178            (UINTN)Guid->Data4[1],
 179            (UINTN)Guid->Data4[2],
 180            (UINTN)Guid->Data4[3],
 181            (UINTN)Guid->Data4[4],
 182            (UINTN)Guid->Data4[5],
 183            (UINTN)Guid->Data4[6],
 184            (UINTN)Guid->Data4[7]
 185            );
 186
 187   //
 188   // SPrint will null terminate the string. The -1 skips the null
 189   //
 190   return Size - 1;
 191 }