1 /** @file 2 Helper functions for SecureBoot configuration module. 3 4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 #include "SecureBootConfigImpl.h" 16 17 /** 18 Read file content into BufferPtr, the size of the allocate buffer 19 is *FileSize plus AddtionAllocateSize. 20 21 @param[in] FileHandle The file to be read. 22 @param[in, out] BufferPtr Pointers to the pointer of allocated buffer. 23 @param[out] FileSize Size of input file 24 @param[in] AddtionAllocateSize Addtion size the buffer need to be allocated. 25 In case the buffer need to contain others besides the file content. 26 27 @retval EFI_SUCCESS The file was read into the buffer. 28 @retval EFI_INVALID_PARAMETER A parameter was invalid. 29 @retval EFI_OUT_OF_RESOURCES A memory allocation failed. 30 @retval others Unexpected error. 31 32 **/ 33 EFI_STATUS 34 ReadFileContent ( 35 IN EFI_FILE_HANDLE FileHandle, 36 IN OUT VOID **BufferPtr, 37 OUT UINTN *FileSize, 38 IN UINTN AddtionAllocateSize 39 ) 40 41 { 42 UINTN BufferSize; 43 UINT64 SourceFileSize; 44 VOID *Buffer; 45 EFI_STATUS Status; 46 47 if ((FileHandle == NULL) || (FileSize == NULL)) { 48 return EFI_INVALID_PARAMETER; 49 } 50 51 Buffer = NULL; 52 53 // 54 // Get the file size 55 // 56 Status = FileHandle->SetPosition (FileHandle, (UINT64) -1); 57 if (EFI_ERROR (Status)) { 58 goto ON_EXIT; 59 } 60 61 Status = FileHandle->GetPosition (FileHandle, &SourceFileSize); 62 if (EFI_ERROR (Status)) { 63 goto ON_EXIT; 64 } 65 66 Status = FileHandle->SetPosition (FileHandle, 0); 67 if (EFI_ERROR (Status)) { 68 goto ON_EXIT; 69 } 70 71 BufferSize = (UINTN) SourceFileSize + AddtionAllocateSize; 72 Buffer = AllocateZeroPool(BufferSize); 73 if (Buffer == NULL) { 74 return EFI_OUT_OF_RESOURCES; 75 } 76 77 BufferSize = (UINTN) SourceFileSize; 78 *FileSize = BufferSize; 79 80 Status = FileHandle->Read (FileHandle, &BufferSize, Buffer); 81 if (EFI_ERROR (Status) || BufferSize != *FileSize) { 82 FreePool (Buffer); 83 Buffer = NULL; 84 Status = EFI_BAD_BUFFER_SIZE; 85 goto ON_EXIT; 86 } 87 88 ON_EXIT: 89 90 *BufferPtr = Buffer; 91 return Status; 92 } 93 94 /** 95 Close an open file handle. 96 97 @param[in] FileHandle The file handle to close. 98 99 **/ 100 VOID 101 CloseFile ( 102 IN EFI_FILE_HANDLE FileHandle 103 ) 104 { 105 if (FileHandle != NULL) { 106 FileHandle->Close (FileHandle); 107 } 108 } 109 110 /** 111 Convert a nonnegative integer to an octet string of a specified length. 112 113 @param[in] Integer Pointer to the nonnegative integer to be converted 114 @param[in] IntSizeInWords Length of integer buffer in words 115 @param[out] OctetString Converted octet string of the specified length 116 @param[in] OSSizeInBytes Intended length of resulting octet string in bytes 117 118 Returns: 119 120 @retval EFI_SUCCESS Data conversion successfully 121 @retval EFI_BUFFER_TOOL_SMALL Buffer is too small for output string 122 123 **/ 124 EFI_STATUS 125 EFIAPI 126 Int2OctStr ( 127 IN CONST UINTN *Integer, 128 IN UINTN IntSizeInWords, 129 OUT UINT8 *OctetString, 130 IN UINTN OSSizeInBytes 131 ) 132 { 133 CONST UINT8 *Ptr1; 134 UINT8 *Ptr2; 135 136 for (Ptr1 = (CONST UINT8 *)Integer, Ptr2 = OctetString + OSSizeInBytes - 1; 137 Ptr1 < (UINT8 *)(Integer + IntSizeInWords) && Ptr2 >= OctetString; 138 Ptr1++, Ptr2--) { 139 *Ptr2 = *Ptr1; 140 } 141 142 for (; Ptr1 < (CONST UINT8 *)(Integer + IntSizeInWords) && *Ptr1 == 0; Ptr1++); 143 144 if (Ptr1 < (CONST UINT8 *)(Integer + IntSizeInWords)) { 145 return EFI_BUFFER_TOO_SMALL; 146 } 147 148 if (Ptr2 >= OctetString) { 149 ZeroMem (OctetString, Ptr2 - OctetString + 1); 150 } 151 152 return EFI_SUCCESS; 153 } 154 155 156 157 /** 158 Convert a String to Guid Value. 159 160 @param[in] Str Specifies the String to be converted. 161 @param[in] StrLen Number of Unicode Characters of String (exclusive \0) 162 @param[out] Guid Return the result Guid value. 163 164 @retval EFI_SUCCESS The operation is finished successfully. 165 @retval EFI_NOT_FOUND Invalid string. 166 167 **/ 168 EFI_STATUS 169 StringToGuid ( 170 IN CHAR16 *Str, 171 IN UINTN StrLen, 172 OUT EFI_GUID *Guid 173 ) 174 { 175 CHAR16 *PtrBuffer; 176 CHAR16 *PtrPosition; 177 UINT16 *Buffer; 178 UINTN Data; 179 UINTN Index; 180 UINT16 Digits[3]; 181 182 Buffer = (CHAR16 *) AllocateZeroPool (sizeof (CHAR16) * (StrLen + 1)); 183 if (Buffer == NULL) { 184 return EFI_OUT_OF_RESOURCES; 185 } 186 187 StrCpyS (Buffer, (StrLen + 1), Str); 188 189 // 190 // Data1 191 // 192 PtrBuffer = Buffer; 193 PtrPosition = PtrBuffer; 194 while (*PtrBuffer != L'\0') { 195 if (*PtrBuffer == L'-') { 196 break; 197 } 198 PtrBuffer++; 199 } 200 if (*PtrBuffer == L'\0') { 201 FreePool (Buffer); 202 return EFI_NOT_FOUND; 203 } 204 205 *PtrBuffer = L'\0'; 206 Data = StrHexToUintn (PtrPosition); 207 Guid->Data1 = (UINT32)Data; 208 209 // 210 // Data2 211 // 212 PtrBuffer++; 213 PtrPosition = PtrBuffer; 214 while (*PtrBuffer != L'\0') { 215 if (*PtrBuffer == L'-') { 216 break; 217 } 218 PtrBuffer++; 219 } 220 if (*PtrBuffer == L'\0') { 221 FreePool (Buffer); 222 return EFI_NOT_FOUND; 223 } 224 *PtrBuffer = L'\0'; 225 Data = StrHexToUintn (PtrPosition); 226 Guid->Data2 = (UINT16)Data; 227 228 // 229 // Data3 230 // 231 PtrBuffer++; 232 PtrPosition = PtrBuffer; 233 while (*PtrBuffer != L'\0') { 234 if (*PtrBuffer == L'-') { 235 break; 236 } 237 PtrBuffer++; 238 } 239 if (*PtrBuffer == L'\0') { 240 FreePool (Buffer); 241 return EFI_NOT_FOUND; 242 } 243 *PtrBuffer = L'\0'; 244 Data = StrHexToUintn (PtrPosition); 245 Guid->Data3 = (UINT16)Data; 246 247 // 248 // Data4[0..1] 249 // 250 for ( Index = 0 ; Index < 2 ; Index++) { 251 PtrBuffer++; 252 if ((*PtrBuffer == L'\0') || ( *(PtrBuffer + 1) == L'\0')) { 253 FreePool (Buffer); 254 return EFI_NOT_FOUND; 255 } 256 Digits[0] = *PtrBuffer; 257 PtrBuffer++; 258 Digits[1] = *PtrBuffer; 259 Digits[2] = L'\0'; 260 Data = StrHexToUintn (Digits); 261 Guid->Data4[Index] = (UINT8)Data; 262 } 263 264 // 265 // skip the '-' 266 // 267 PtrBuffer++; 268 if ((*PtrBuffer != L'-' ) || ( *PtrBuffer == L'\0')) { 269 return EFI_NOT_FOUND; 270 } 271 272 // 273 // Data4[2..7] 274 // 275 for ( ; Index < 8; Index++) { 276 PtrBuffer++; 277 if ((*PtrBuffer == L'\0') || ( *(PtrBuffer + 1) == L'\0')) { 278 FreePool (Buffer); 279 return EFI_NOT_FOUND; 280 } 281 Digits[0] = *PtrBuffer; 282 PtrBuffer++; 283 Digits[1] = *PtrBuffer; 284 Digits[2] = L'\0'; 285 Data = StrHexToUintn (Digits); 286 Guid->Data4[Index] = (UINT8)Data; 287 } 288 289 FreePool (Buffer); 290 291 return EFI_SUCCESS; 292 } 293 294 /** 295 Worker function that prints an EFI_GUID into specified Buffer. 296 297 @param[in] Guid Pointer to GUID to print. 298 @param[in] Buffer Buffer to print Guid into. 299 @param[in] BufferSize Size of Buffer. 300 301 @retval Number of characters printed. 302 303 **/ 304 UINTN 305 GuidToString ( 306 IN EFI_GUID *Guid, 307 IN CHAR16 *Buffer, 308 IN UINTN BufferSize 309 ) 310 { 311 UINTN Size; 312 313 Size = UnicodeSPrint ( 314 Buffer, 315 BufferSize, 316 L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", 317 (UINTN)Guid->Data1, 318 (UINTN)Guid->Data2, 319 (UINTN)Guid->Data3, 320 (UINTN)Guid->Data4[0], 321 (UINTN)Guid->Data4[1], 322 (UINTN)Guid->Data4[2], 323 (UINTN)Guid->Data4[3], 324 (UINTN)Guid->Data4[4], 325 (UINTN)Guid->Data4[5], 326 (UINTN)Guid->Data4[6], 327 (UINTN)Guid->Data4[7] 328 ); 329 330 // 331 // SPrint will null terminate the string. The -1 skips the null 332 // 333 return Size - 1; 334 } 335
