struct menu_item {
CHAR16 *text;
- INTN (* callback)(void *data, void *data2, void *data3);
+ INTN (*callback)(void *data, void *data2, void *data3);
void *data;
void *data2;
void *data3;
CHAR16 Password[SB_PASSWORD_LEN];
} __attribute__ ((packed)) MokDBvar;
-static EFI_STATUS get_sha1sum (void *Data, int DataSize, UINT8 *hash)
+static EFI_STATUS get_sha1sum(void *Data, int DataSize, UINT8 * hash)
{
EFI_STATUS status;
unsigned int ctxsize;
return status;
}
-static BOOLEAN is_sha2_hash (EFI_GUID Type)
+static BOOLEAN is_sha2_hash(EFI_GUID Type)
{
if (CompareGuid(&Type, &EFI_CERT_SHA224_GUID) == 0)
return TRUE;
return FALSE;
}
-static UINT32 sha_size (EFI_GUID Type)
+static UINT32 sha_size(EFI_GUID Type)
{
if (CompareGuid(&Type, &EFI_CERT_SHA1_GUID) == 0)
return SHA1_DIGEST_SIZE;
return 0;
}
-static BOOLEAN is_valid_siglist (EFI_GUID Type, UINT32 SigSize)
+static BOOLEAN is_valid_siglist(EFI_GUID Type, UINT32 SigSize)
{
UINT32 hash_sig_size;
if (CompareGuid (&Type, &X509_GUID) == 0 && SigSize != 0)
return TRUE;
- if (!is_sha2_hash (Type))
+ if (!is_sha2_hash(Type))
return FALSE;
- hash_sig_size = sha_size (Type) + sizeof(EFI_GUID);
+ hash_sig_size = sha_size(Type) + sizeof(EFI_GUID);
if (SigSize != hash_sig_size)
return FALSE;
void *end = Data + DataSize;
while ((dbsize > 0) && (dbsize >= CertList->SignatureListSize)) {
-
/* Use ptr arithmetics to ensure bounded access. Do not allow 0
- * SignatureListSize that will cause endless loop.
- */
- if ((void *)(CertList + 1) > end || CertList->SignatureListSize == 0) {
- console_notify(L"Invalid MOK detected! Ignoring MOK List.");
+ * SignatureListSize that will cause endless loop. */
+ if ((void *)(CertList + 1) > end
+ || CertList->SignatureListSize == 0) {
+ console_notify
+ (L"Invalid MOK detected! Ignoring MOK List.");
return 0;
}
return 0;
}
- if (!is_valid_siglist(CertList->SignatureType, CertList->SignatureSize)) {
+ if (!is_valid_siglist
+ (CertList->SignatureType, CertList->SignatureSize)) {
console_errorbox(L"Invalid signature list found");
return 0;
}
MokNum++;
dbsize -= CertList->SignatureListSize;
CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList +
- CertList->SignatureListSize);
+ CertList->SignatureListSize);
}
return MokNum;
}
-static MokListNode *build_mok_list(UINT32 num, void *Data, UINTN DataSize) {
+static MokListNode *build_mok_list(UINT32 num, void *Data, UINTN DataSize)
+{
MokListNode *list;
EFI_SIGNATURE_LIST *CertList = Data;
EFI_SIGNATURE_DATA *Cert;
void *end = Data + DataSize;
list = AllocatePool(sizeof(MokListNode) * num);
-
if (!list) {
console_notify(L"Unable to allocate MOK list");
return NULL;
while ((dbsize > 0) && (dbsize >= CertList->SignatureListSize)) {
/* CertList out of bounds? */
- if ((void *)(CertList + 1) > end || CertList->SignatureListSize == 0) {
+ if ((void *)(CertList + 1) > end
+ || CertList->SignatureListSize == 0) {
FreePool(list);
return NULL;
}
in count_keys() */
Cert = (EFI_SIGNATURE_DATA *) (((UINT8 *) CertList) +
- sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);
-
+ sizeof(EFI_SIGNATURE_LIST) +
+ CertList->SignatureHeaderSize);
/* Cert out of bounds? */
- if ((void *)(Cert + 1) > end || CertList->SignatureSize <= sizeof(EFI_GUID)) {
+ if ((void *)(Cert + 1) > end
+ || CertList->SignatureSize <= sizeof(EFI_GUID)) {
FreePool(list);
return NULL;
}
list[count].Type = CertList->SignatureType;
if (CompareGuid (&CertList->SignatureType, &X509_GUID) == 0) {
list[count].MokSize = CertList->SignatureSize -
- sizeof(EFI_GUID);
+ sizeof(EFI_GUID);
list[count].Mok = (void *)Cert->SignatureData;
} else {
list[count].MokSize = CertList->SignatureListSize -
- sizeof(EFI_SIGNATURE_LIST);
+ sizeof(EFI_SIGNATURE_LIST);
list[count].Mok = (void *)Cert;
}
/* MOK out of bounds? */
if (list[count].MokSize > (unsigned long)end -
- (unsigned long)list[count].Mok) {
+ (unsigned long)list[count].Mok) {
FreePool(list);
return NULL;
}
count++;
dbsize -= CertList->SignatureListSize;
CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList +
- CertList->SignatureListSize);
+ CertList->SignatureListSize);
}
return list;
{-1, NULL}
};
-static CHAR16* get_x509_name (X509_NAME *X509Name)
+static CHAR16 *get_x509_name(X509_NAME * X509Name)
{
- CHAR16 name[NAME_LINE_MAX+1];
- CHAR16 part[NAME_LINE_MAX+1];
+ CHAR16 name[NAME_LINE_MAX + 1];
+ CHAR16 part[NAME_LINE_MAX + 1];
char str[NAME_LINE_MAX];
int i, len, rest, first;
first = 1;
for (i = 0; nidname[i].name != NULL; i++) {
int add;
- len = X509_NAME_get_text_by_NID (X509Name, nidname[i].nid,
- str, NAME_LINE_MAX);
+ len = X509_NAME_get_text_by_NID(X509Name, nidname[i].nid,
+ str, NAME_LINE_MAX);
if (len <= 0)
continue;
return NULL;
}
-static CHAR16* get_x509_time (ASN1_TIME *time)
+static CHAR16 *get_x509_time(ASN1_TIME * time)
{
- BIO *bio = BIO_new (BIO_s_mem());
+ BIO *bio = BIO_new(BIO_s_mem());
char str[30];
int len;
- ASN1_TIME_print (bio, time);
+ ASN1_TIME_print(bio, time);
len = BIO_read(bio, str, 29);
if (len < 0)
len = 0;
str[len] = '\0';
- BIO_free (bio);
+ BIO_free(bio);
return PoolPrint(L"%a", str);
}
-static void show_x509_info (X509 *X509Cert, UINT8 *hash)
+static void show_x509_info(X509 * X509Cert, UINT8 * hash)
{
ASN1_INTEGER *serial;
BIGNUM *bnser;
fields++;
}
- for (i=0; i<10; i++)
+ for (i = 0; i < 10; i++)
CatPrint(&hash_string1, L"%02x ", hash[i]);
- for (i=10; i<20; i++)
+ for (i = 10; i < 20; i++)
CatPrint(&hash_string2, L"%02x ", hash[i]);
if (hash_string1.str)
i = 0;
extusage = X509_get_ext_d2i(X509Cert, NID_ext_key_usage, NULL, NULL);
- text = AllocateZeroPool(sizeof(CHAR16 *) * (fields*3 + sk_ASN1_OBJECT_num(extusage) + 3));
-
+ text = AllocateZeroPool(sizeof(CHAR16 *) *
+ (fields * 3 +
+ sk_ASN1_OBJECT_num(extusage) + 3));
if (extusage) {
int j = 0;
console_print_box(text, -1);
- for (i=0; text[i] != NULL; i++)
+ for (i = 0; text[i] != NULL; i++)
FreePool(text[i]);
FreePool(text);
}
-static void show_sha_digest (EFI_GUID Type, UINT8 *hash)
+static void show_sha_digest(EFI_GUID Type, UINT8 * hash)
{
CHAR16 *text[5];
POOL_PRINT hash_string1;
text[1] = L"";
- for (i=0; i<length/2; i++)
+ for (i = 0; i < length / 2; i++)
CatPrint(&hash_string1, L"%02x ", hash[i]);
- for (i=length/2; i<length; i++)
+ for (i = length / 2; i < length; i++)
CatPrint(&hash_string2, L"%02x ", hash[i]);
text[2] = hash_string1.str;
FreePool(hash_string2.str);
}
-static void show_efi_hash (EFI_GUID Type, void *Mok, UINTN MokSize)
+static void show_efi_hash(EFI_GUID Type, void *Mok, UINTN MokSize)
{
UINTN sig_size;
UINTN hash_num;
hash_num = MokSize / sig_size;
if (hash_num == 1) {
- hash = (UINT8 *)Mok + sizeof(EFI_GUID);
+ hash = (UINT8 *) Mok + sizeof(EFI_GUID);
show_sha_digest(Type, hash);
return;
}
console_errorbox(L"Out of Resources");
return;
}
- for (i=0; i<hash_num; i++) {
+
+ for (i = 0; i < hash_num; i++) {
menu_strings[i] = PoolPrint(L"View hash %d", i);
}
menu_strings[i] = StrDuplicate(L"Back");
- menu_strings[i+1] = NULL;
+ menu_strings[i + 1] = NULL;
while (key_num < hash_num) {
int rc;
if (rc < 0 || key_num >= hash_num)
break;
- hash = (UINT8 *)Mok + sig_size*key_num + sizeof(EFI_GUID);
+ hash = (UINT8 *) Mok + sig_size * key_num + sizeof(EFI_GUID);
show_sha_digest(Type, hash);
}
- for (i=0; menu_strings[i] != NULL; i++)
+ for (i = 0; menu_strings[i] != NULL; i++)
FreePool(menu_strings[i]);
FreePool(menu_strings);
}
-static void show_mok_info (EFI_GUID Type, void *Mok, UINTN MokSize)
+static void show_mok_info(EFI_GUID Type, void *Mok, UINTN MokSize)
{
EFI_STATUS efi_status;
if (CompareGuid (&Type, &X509_GUID) == 0) {
UINT8 hash[SHA1_DIGEST_SIZE];
X509 *X509Cert;
- efi_status = get_sha1sum(Mok, MokSize, hash);
+ efi_status = get_sha1sum(Mok, MokSize, hash);
if (efi_status != EFI_SUCCESS) {
console_notify(L"Failed to compute MOK fingerprint");
return;
}
if (X509ConstructCertificate(Mok, MokSize,
- (UINT8 **) &X509Cert) && X509Cert != NULL) {
+ (UINT8 **) & X509Cert)
+ && X509Cert != NULL) {
show_x509_info(X509Cert, hash);
X509_free(X509Cert);
} else {
}
}
-static EFI_STATUS list_keys (void *KeyList, UINTN KeyListSize, CHAR16 *title)
+static EFI_STATUS list_keys(void *KeyList, UINTN KeyListSize, CHAR16 * title)
{
UINTN MokNum = 0;
MokListNode *keys = NULL;
}
menu_strings = AllocateZeroPool(sizeof(CHAR16 *) * (MokNum + 2));
-
if (!menu_strings)
return EFI_OUT_OF_RESOURCES;
- for (i=0; i<MokNum; i++) {
+ for (i = 0; i < MokNum; i++) {
menu_strings[i] = PoolPrint(L"View key %d", i);
}
menu_strings[i] = StrDuplicate(L"Continue");
- menu_strings[i+1] = NULL;
+ menu_strings[i + 1] = NULL;
while (key_num < MokNum) {
int rc;
keys[key_num].MokSize);
}
- for (i=0; menu_strings[i] != NULL; i++)
+ for (i = 0; menu_strings[i] != NULL; i++)
FreePool(menu_strings[i]);
-
FreePool(menu_strings);
-
FreePool(keys);
return EFI_SUCCESS;
}
-static EFI_STATUS get_line (UINT32 *length, CHAR16 *line, UINT32 line_max, UINT8 show)
+static EFI_STATUS get_line(UINT32 * length, CHAR16 * line, UINT32 line_max,
+ UINT8 show)
{
EFI_INPUT_KEY key;
EFI_STATUS status;
do {
status = console_get_keystroke(&key);
- if (EFI_ERROR (status)) {
+ if (EFI_ERROR(status)) {
console_error(L"Failed to read the keystroke", status);
*length = 0;
return status;
if ((count >= line_max &&
key.UnicodeChar != CHAR_BACKSPACE) ||
key.UnicodeChar == CHAR_NULL ||
- key.UnicodeChar == CHAR_TAB ||
+ key.UnicodeChar == CHAR_TAB ||
key.UnicodeChar == CHAR_LINEFEED ||
key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
continue;
return EFI_SUCCESS;
}
-static EFI_STATUS compute_pw_hash (void *Data, UINTN DataSize, UINT8 *password,
- UINT32 pw_length, UINT8 *hash)
+static EFI_STATUS compute_pw_hash(void *Data, UINTN DataSize, UINT8 * password,
+ UINT32 pw_length, UINT8 * hash)
{
EFI_STATUS status;
unsigned int ctxsize;
ctxsize = Sha256GetContextSize();
ctx = AllocatePool(ctxsize);
-
if (!ctx) {
console_notify(L"Unable to allocate memory for hash context");
return EFI_OUT_OF_RESOURCES;
return status;
}
-static void console_save_and_set_mode (SIMPLE_TEXT_OUTPUT_MODE *SavedMode)
+static void console_save_and_set_mode(SIMPLE_TEXT_OUTPUT_MODE * SavedMode)
{
if (!SavedMode) {
Print(L"Invalid parameter: SavedMode\n");
EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE);
}
-static void console_restore_mode (SIMPLE_TEXT_OUTPUT_MODE *SavedMode)
+static void console_restore_mode(SIMPLE_TEXT_OUTPUT_MODE * SavedMode)
{
uefi_call_wrapper(ST->ConOut->EnableCursor, 2, ST->ConOut,
SavedMode->CursorVisible);
SavedMode->Attribute);
}
-static INTN reset_system ()
+static INTN reset_system()
{
uefi_call_wrapper(RT->ResetSystem, 4, EfiResetWarm,
EFI_SUCCESS, 0, NULL);
return -1;
}
-static UINT32 get_password (CHAR16 *prompt, CHAR16 *password, UINT32 max)
+static UINT32 get_password(CHAR16 * prompt, CHAR16 * password, UINT32 max)
{
SIMPLE_TEXT_OUTPUT_MODE SavedMode;
CHAR16 *str;
message[0] = str;
message[1] = NULL;
length = StrLen(message[0]);
- console_print_box_at(message, -1, -length-4, -5, length+4, 3, 0, 1);
+ console_print_box_at(message, -1, -length - 4, -5, length + 4, 3, 0, 1);
get_line(&pw_length, password, max, 0);
console_restore_mode(&SavedMode);
return pw_length;
}
-static EFI_STATUS match_password (PASSWORD_CRYPT *pw_crypt,
- void *Data, UINTN DataSize,
- UINT8 *auth, CHAR16 *prompt)
+static EFI_STATUS match_password(PASSWORD_CRYPT * pw_crypt,
+ void *Data, UINTN DataSize,
+ UINT8 * auth, CHAR16 * prompt)
{
EFI_STATUS status;
UINT8 hash[128];
if (pw_crypt) {
auth_hash = pw_crypt->hash;
- auth_size = get_hash_size (pw_crypt->method);
+ auth_size = get_hash_size(pw_crypt->method);
if (auth_size == 0)
return EFI_INVALID_PARAMETER;
} else if (auth) {
pw_ascii[i] = (char)password[i];
pw_ascii[pw_length] = '\0';
- status = password_crypt(pw_ascii, pw_length, pw_crypt, hash);
+ status = password_crypt(pw_ascii, pw_length, pw_crypt,
+ hash);
} else {
/*
* For backward compatibility
*/
- status = compute_pw_hash(Data, DataSize, (UINT8 *)password,
- pw_length * sizeof(CHAR16), hash);
+ status = compute_pw_hash(Data, DataSize,
+ (UINT8 *) password,
+ pw_length * sizeof(CHAR16),
+ hash);
}
if (status != EFI_SUCCESS) {
console_errorbox(L"Unable to generate password hash");
return EFI_SUCCESS;
}
-static EFI_STATUS write_db (CHAR16 *db_name, void *MokNew, UINTN MokNewSize)
+static EFI_STATUS write_db(CHAR16 * db_name, void *MokNew, UINTN MokNewSize)
{
EFI_STATUS status;
UINT32 attributes;
return status;
}
-static EFI_STATUS store_keys (void *MokNew, UINTN MokNewSize, int authenticate,
- BOOLEAN MokX)
+static EFI_STATUS store_keys(void *MokNew, UINTN MokNewSize, int authenticate,
+ BOOLEAN MokX)
{
EFI_STATUS efi_status;
CHAR16 *db_name;
(auth_size != SHA256_DIGEST_SIZE &&
auth_size != PASSWORD_CRYPT_SIZE)) {
if (MokX)
- console_error(L"Failed to get MokXAuth", efi_status);
+ console_error(L"Failed to get MokXAuth",
+ efi_status);
else
- console_error(L"Failed to get MokAuth", efi_status);
+ console_error(L"Failed to get MokAuth",
+ efi_status);
return efi_status;
}
if (auth_size == PASSWORD_CRYPT_SIZE) {
- efi_status = match_password((PASSWORD_CRYPT *)auth,
+ efi_status = match_password((PASSWORD_CRYPT *) auth,
NULL, 0, NULL, NULL);
} else {
efi_status = match_password(NULL, MokNew, MokNewSize,
efi_status = uefi_call_wrapper(RT->SetVariable, 5, db_name,
&SHIM_LOCK_GUID,
EFI_VARIABLE_NON_VOLATILE
- | EFI_VARIABLE_BOOTSERVICE_ACCESS,
+ |
+ EFI_VARIABLE_BOOTSERVICE_ACCESS,
0, NULL);
} else {
/* Write new MOK */
return EFI_SUCCESS;
}
-static EFI_STATUS mok_enrollment_prompt (void *MokNew, UINTN MokNewSize, int auth,
- BOOLEAN MokX)
+static EFI_STATUS mok_enrollment_prompt(void *MokNew, UINTN MokNewSize,
+ int auth, BOOLEAN MokX)
{
EFI_STATUS efi_status;
CHAR16 *enroll_p[] = { L"Enroll the key(s)?", NULL };
}
if (MokNew)
- FreePool (MokNew);
+ FreePool(MokNew);
return EFI_SUCCESS;
}
-static EFI_STATUS mok_reset_prompt (BOOLEAN MokX)
+static EFI_STATUS mok_reset_prompt(BOOLEAN MokX)
{
EFI_STATUS efi_status;
CHAR16 *prompt[] = { NULL, NULL };
return EFI_ABORTED;
efi_status = store_keys(NULL, 0, TRUE, MokX);
-
if (efi_status != EFI_SUCCESS) {
console_notify(L"Failed to erase keys\n");
return efi_status;
return EFI_SUCCESS;
}
-static EFI_STATUS write_back_mok_list (MokListNode *list, INTN key_num,
- BOOLEAN MokX)
+static EFI_STATUS write_back_mok_list(MokListNode * list, INTN key_num,
+ BOOLEAN MokX)
{
EFI_STATUS efi_status;
EFI_SIGNATURE_LIST *CertList;
if (list[i].Mok == NULL)
continue;
- CertList = (EFI_SIGNATURE_LIST *)ptr;
- CertData = (EFI_SIGNATURE_DATA *)(((uint8_t *)ptr) +
- sizeof(EFI_SIGNATURE_LIST));
+ CertList = (EFI_SIGNATURE_LIST *) ptr;
+ CertData = (EFI_SIGNATURE_DATA *) (((uint8_t *) ptr) +
+ sizeof(EFI_SIGNATURE_LIST));
CertList->SignatureType = list[i].Type;
CertList->SignatureHeaderSize = 0;
if (CompareGuid(&(list[i].Type), &X509_GUID) == 0) {
CertList->SignatureListSize = list[i].MokSize +
- sizeof(EFI_SIGNATURE_LIST) +
- sizeof(EFI_GUID);
- CertList->SignatureSize = list[i].MokSize + sizeof(EFI_GUID);
+ sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_GUID);
+ CertList->SignatureSize =
+ list[i].MokSize + sizeof(EFI_GUID);
CertData->SignatureOwner = SHIM_LOCK_GUID;
- CopyMem(CertData->SignatureData, list[i].Mok, list[i].MokSize);
+ CopyMem(CertData->SignatureData, list[i].Mok,
+ list[i].MokSize);
} else {
CertList->SignatureListSize = list[i].MokSize +
- sizeof(EFI_SIGNATURE_LIST);
- CertList->SignatureSize = sha_size(list[i].Type) + sizeof(EFI_GUID);
+ sizeof(EFI_SIGNATURE_LIST);
+ CertList->SignatureSize =
+ sha_size(list[i].Type) + sizeof(EFI_GUID);
CopyMem(CertData, list[i].Mok, list[i].MokSize);
}
- ptr = (uint8_t *)ptr + CertList->SignatureListSize;
+ ptr = (uint8_t *) ptr + CertList->SignatureListSize;
}
efi_status = uefi_call_wrapper(RT->SetVariable, 5, db_name,
return EFI_SUCCESS;
}
-static void delete_cert (void *key, UINT32 key_size,
- MokListNode *mok, INTN mok_num)
+static void delete_cert(void *key, UINT32 key_size,
+ MokListNode * mok, INTN mok_num)
{
int i;
}
}
-static int match_hash (UINT8 *hash, UINT32 hash_size, int start,
- void *hash_list, UINT32 list_num)
+static int match_hash(UINT8 * hash, UINT32 hash_size, int start,
+ void *hash_list, UINT32 list_num)
{
UINT8 *ptr;
UINTN i;
return -1;
}
-static void mem_move (void *dest, void *src, UINTN size)
+static void mem_move(void *dest, void *src, UINTN size)
{
UINT8 *d, *s;
UINTN i;
- d = (UINT8 *)dest;
- s = (UINT8 *)src;
+ d = (UINT8 *) dest;
+ s = (UINT8 *) src;
for (i = 0; i < size; i++)
d[i] = s[i];
}
-static void delete_hash_in_list (EFI_GUID Type, UINT8 *hash, UINT32 hash_size,
- MokListNode *mok, INTN mok_num)
+static void delete_hash_in_list(EFI_GUID Type, UINT8 * hash, UINT32 hash_size,
+ MokListNode * mok, INTN mok_num)
{
UINT32 sig_size;
UINT32 list_num;
list_num = mok[i].MokSize / sig_size;
- del_ind = match_hash(hash, hash_size, 0, mok[i].Mok,
- list_num);
+ del_ind = match_hash(hash, hash_size, 0, mok[i].Mok, list_num);
while (del_ind >= 0) {
/* Remove the hash */
if (sig_size == mok[i].MokSize) {
start = mok[i].Mok + del_ind * sig_size;
end = start + sig_size;
- remain = mok[i].MokSize - (del_ind + 1)*sig_size;
+ remain = mok[i].MokSize - (del_ind + 1) * sig_size;
mem_move(start, end, remain);
mok[i].MokSize -= sig_size;
}
}
-static void delete_hash_list (EFI_GUID Type, void *hash_list, UINT32 list_size,
- MokListNode *mok, INTN mok_num)
+static void delete_hash_list(EFI_GUID Type, void *hash_list, UINT32 list_size,
+ MokListNode * mok, INTN mok_num)
{
UINT32 hash_size;
UINT32 hash_num;
UINT8 *hash;
UINT32 i;
- hash_size = sha_size (Type);
+ hash_size = sha_size(Type);
sig_size = hash_size + sizeof(EFI_GUID);
if (list_size < sig_size)
return;
hash = hash_list + sizeof(EFI_GUID);
for (i = 0; i < hash_num; i++) {
- delete_hash_in_list (Type, hash, hash_size, mok, mok_num);
+ delete_hash_in_list(Type, hash, hash_size, mok, mok_num);
hash += sig_size;
}
}
-static EFI_STATUS delete_keys (void *MokDel, UINTN MokDelSize, BOOLEAN MokX)
+static EFI_STATUS delete_keys(void *MokDel, UINTN MokDelSize, BOOLEAN MokX)
{
EFI_STATUS efi_status;
CHAR16 *db_name;
efi_status = uefi_call_wrapper(RT->GetVariable, 5, auth_name,
&SHIM_LOCK_GUID,
&attributes, &auth_size, auth);
-
if (efi_status != EFI_SUCCESS ||
- (auth_size != SHA256_DIGEST_SIZE && auth_size != PASSWORD_CRYPT_SIZE)) {
+ (auth_size != SHA256_DIGEST_SIZE
+ && auth_size != PASSWORD_CRYPT_SIZE)) {
if (MokX)
console_error(L"Failed to get MokXDelAuth", efi_status);
else
}
if (auth_size == PASSWORD_CRYPT_SIZE) {
- efi_status = match_password((PASSWORD_CRYPT *)auth, NULL, 0,
+ efi_status = match_password((PASSWORD_CRYPT *) auth, NULL, 0,
NULL, NULL);
} else {
- efi_status = match_password(NULL, MokDel, MokDelSize, auth, NULL);
+ efi_status =
+ match_password(NULL, MokDel, MokDelSize, auth, NULL);
}
if (efi_status != EFI_SUCCESS)
return EFI_ACCESS_DENIED;
- efi_status = get_variable_attr (db_name, &MokListData, &MokListDataSize,
- SHIM_LOCK_GUID, &attributes);
+ efi_status = get_variable_attr(db_name, &MokListData, &MokListDataSize,
+ SHIM_LOCK_GUID, &attributes);
if (efi_status != EFI_SUCCESS) {
if (MokX)
console_errorbox(L"Failed to retrieve MokListX");
uefi_call_wrapper(RT->SetVariable, 5, db_name,
&SHIM_LOCK_GUID,
EFI_VARIABLE_NON_VOLATILE |
- EFI_VARIABLE_BOOTSERVICE_ACCESS,
- 0, NULL);
+ EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
return EFI_ACCESS_DENIED;
}
uefi_call_wrapper(RT->SetVariable, 5, db_name,
&SHIM_LOCK_GUID,
EFI_VARIABLE_NON_VOLATILE |
- EFI_VARIABLE_BOOTSERVICE_ACCESS,
- 0, NULL);
+ EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
efi_status = EFI_ABORTED;
goto error;
}
return efi_status;
}
-static EFI_STATUS mok_deletion_prompt (void *MokDel, UINTN MokDelSize, BOOLEAN MokX)
+static EFI_STATUS mok_deletion_prompt(void *MokDel, UINTN MokDelSize,
+ BOOLEAN MokX)
{
EFI_STATUS efi_status;
CHAR16 *delete_p[] = { L"Delete the key(s)?", NULL };
return EFI_SUCCESS;
}
-static CHAR16 get_password_charater (CHAR16 *prompt)
+static CHAR16 get_password_charater(CHAR16 * prompt)
{
SIMPLE_TEXT_OUTPUT_MODE SavedMode;
EFI_STATUS status;
message[0] = prompt;
message[1] = NULL;
length = StrLen(message[0]);
- console_print_box_at(message, -1, -length-4, -5, length+4, 3, 0, 1);
+ console_print_box_at(message, -1, -length - 4, -5, length + 4, 3, 0, 1);
status = get_line(&pw_length, &character, 1, 0);
if (EFI_ERROR(status))
character = 0;
return character;
}
-static EFI_STATUS mok_sb_prompt (void *MokSB, UINTN MokSBSize) {
+static EFI_STATUS mok_sb_prompt(void *MokSB, UINTN MokSBSize)
+{
EFI_STATUS efi_status;
SIMPLE_TEXT_OUTPUT_MODE SavedMode;
MokSBvar *var = MokSB;
console_restore_mode(&SavedMode);
while (fail_count < 3) {
- RandomBytes (&pos1, sizeof(pos1));
+ RandomBytes(&pos1, sizeof(pos1));
pos1 = (pos1 % var->PWLen);
do {
- RandomBytes (&pos2, sizeof(pos2));
+ RandomBytes(&pos2, sizeof(pos2));
pos2 = (pos2 % var->PWLen);
} while (pos2 == pos1);
do {
- RandomBytes (&pos3, sizeof(pos3));
- pos3 = (pos3 % var->PWLen) ;
+ RandomBytes(&pos3, sizeof(pos3));
+ pos3 = (pos3 % var->PWLen);
} while (pos3 == pos2 || pos3 == pos1);
str = PoolPrint(L"Enter password character %d: ", pos1 + 1);
return EFI_SUCCESS;
}
-static EFI_STATUS mok_db_prompt (void *MokDB, UINTN MokDBSize) {
+static EFI_STATUS mok_db_prompt(void *MokDB, UINTN MokDBSize)
+{
EFI_STATUS efi_status;
SIMPLE_TEXT_OUTPUT_MODE SavedMode;
MokDBvar *var = MokDB;
console_restore_mode(&SavedMode);
while (fail_count < 3) {
- RandomBytes (&pos1, sizeof(pos1));
+ RandomBytes(&pos1, sizeof(pos1));
pos1 = (pos1 % var->PWLen);
do {
- RandomBytes (&pos2, sizeof(pos2));
+ RandomBytes(&pos2, sizeof(pos2));
pos2 = (pos2 % var->PWLen);
} while (pos2 == pos1);
do {
- RandomBytes (&pos3, sizeof(pos3));
- pos3 = (pos3 % var->PWLen) ;
+ RandomBytes(&pos3, sizeof(pos3));
+ pos3 = (pos3 % var->PWLen);
} while (pos3 == pos2 || pos3 == pos1);
str = PoolPrint(L"Enter password character %d: ", pos1 + 1);
return EFI_SUCCESS;
}
-static EFI_STATUS mok_pw_prompt (void *MokPW, UINTN MokPWSize) {
+static EFI_STATUS mok_pw_prompt(void *MokPW, UINTN MokPWSize)
+{
EFI_STATUS efi_status;
UINT8 hash[PASSWORD_CRYPT_SIZE];
UINT8 clear = 0;
uefi_call_wrapper(RT->SetVariable, 5, L"MokPWStore",
&SHIM_LOCK_GUID,
EFI_VARIABLE_NON_VOLATILE
- | EFI_VARIABLE_BOOTSERVICE_ACCESS,
- 0, NULL);
+ | EFI_VARIABLE_BOOTSERVICE_ACCESS, 0, NULL);
goto mokpw_done;
}
if (MokPWSize == PASSWORD_CRYPT_SIZE) {
- efi_status = match_password((PASSWORD_CRYPT *)MokPW, NULL, 0,
+ efi_status = match_password((PASSWORD_CRYPT *) MokPW, NULL, 0,
NULL, L"Confirm MOK passphrase: ");
} else {
efi_status = match_password(NULL, NULL, 0, MokPW,
return EFI_SUCCESS;
}
-static BOOLEAN verify_certificate(UINT8 *cert, UINTN size)
+static BOOLEAN verify_certificate(UINT8 * cert, UINTN size)
{
X509 *X509Cert;
UINTN length;
return FALSE;
}
- length = (cert[2]<<8 | cert[3]);
+ length = (cert[2] << 8 | cert[3]);
if (length != (size - 4)) {
console_notify(L"Invalid X509 certificate: Inconsistent size");
return FALSE;
}
- if (!(X509ConstructCertificate(cert, size, (UINT8 **) &X509Cert)) ||
+ if (!(X509ConstructCertificate(cert, size, (UINT8 **) & X509Cert)) ||
X509Cert == NULL) {
console_notify(L"Invalid X509 certificate");
return FALSE;
return TRUE;
}
-static EFI_STATUS enroll_file (void *data, UINTN datasize, BOOLEAN hash)
+static EFI_STATUS enroll_file(void *data, UINTN datasize, BOOLEAN hash)
{
EFI_STATUS status = EFI_SUCCESS;
EFI_SIGNATURE_LIST *CertList;
goto out;
mokbuffersize = sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_GUID) +
- SHA256_DIGEST_SIZE;
+ SHA256_DIGEST_SIZE;
mokbuffer = AllocatePool(mokbuffersize);
if (status != EFI_SUCCESS)
goto out;
-
+
status = shim_lock->Hash(data, datasize, &context, sha256,
sha1);
CertList = mokbuffer;
CertList->SignatureType = EFI_CERT_SHA256_GUID;
CertList->SignatureSize = 16 + SHA256_DIGEST_SIZE;
- CertData = (EFI_SIGNATURE_DATA *)(((UINT8 *)mokbuffer) +
- sizeof(EFI_SIGNATURE_LIST));
+ CertData = (EFI_SIGNATURE_DATA *) (((UINT8 *) mokbuffer) +
+ sizeof(EFI_SIGNATURE_LIST));
CopyMem(CertData->SignatureData, sha256, SHA256_DIGEST_SIZE);
} else {
mokbuffersize = datasize + sizeof(EFI_SIGNATURE_LIST) +
- sizeof(EFI_GUID);
+ sizeof(EFI_GUID);
mokbuffer = AllocatePool(mokbuffersize);
if (!mokbuffer)
memcpy(mokbuffer + sizeof(EFI_SIGNATURE_LIST) + 16, data,
datasize);
- CertData = (EFI_SIGNATURE_DATA *)(((UINT8 *)mokbuffer) +
- sizeof(EFI_SIGNATURE_LIST));
+ CertData = (EFI_SIGNATURE_DATA *) (((UINT8 *) mokbuffer) +
+ sizeof(EFI_SIGNATURE_LIST));
}
CertList->SignatureListSize = mokbuffersize;
static EFI_STATUS mok_hash_enroll(void)
{
EFI_STATUS efi_status;
- CHAR16 *file_name = NULL;
+ CHAR16 *file_name = NULL;
EFI_HANDLE im = NULL;
EFI_FILE *file = NULL;
UINTN filesize;
return EFI_INVALID_PARAMETER;
efi_status = simple_file_open(im, file_name, &file, EFI_FILE_MODE_READ);
-
if (efi_status != EFI_SUCCESS) {
console_error(L"Unable to open file", efi_status);
return efi_status;
simple_file_read_all(file, &filesize, &data);
simple_file_close(file);
-
if (!filesize) {
console_error(L"Unable to read file", efi_status);
return EFI_BAD_BUFFER_SIZE;
}
efi_status = enroll_file(data, filesize, TRUE);
-
if (efi_status != EFI_SUCCESS)
- console_error(L"Hash failed (did you select a valid EFI binary?)", efi_status);
+ console_error(
+ L"Hash failed (did you select a valid EFI binary?)",
+ efi_status);
FreePool(data);
NULL
};
-static BOOLEAN check_der_suffix (CHAR16 *file_name)
+static BOOLEAN check_der_suffix(CHAR16 * file_name)
{
CHAR16 suffix[5];
int i;
suffix[0] = '\0';
StrCat(suffix, file_name + StrLen(file_name) - 4);
- StrLwr (suffix);
+ StrLwr(suffix);
for (i = 0; der_suffix[i] != NULL; i++) {
if (StrCmp(suffix, der_suffix[i]) == 0) {
return TRUE;
static EFI_STATUS mok_key_enroll(void)
{
EFI_STATUS efi_status;
- CHAR16 *file_name = NULL;
+ CHAR16 *file_name = NULL;
EFI_HANDLE im = NULL;
EFI_FILE *file = NULL;
UINTN filesize;
}
efi_status = simple_file_open(im, file_name, &file, EFI_FILE_MODE_READ);
-
if (efi_status != EFI_SUCCESS) {
console_error(L"Unable to open file", efi_status);
return efi_status;
simple_file_read_all(file, &filesize, &data);
simple_file_close(file);
-
if (!filesize) {
console_error(L"Unable to read file", efi_status);
return EFI_BAD_BUFFER_SIZE;
return efi_status;
}
-static BOOLEAN verify_pw(BOOLEAN *protected)
+static BOOLEAN verify_pw(BOOLEAN * protected)
{
EFI_STATUS efi_status;
SIMPLE_TEXT_OUTPUT_MODE SavedMode;
efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"MokPWStore",
&SHIM_LOCK_GUID, &attributes, &size,
pwhash);
-
/*
* If anything can attack the password it could just set it to a
* known value, so there's no safety advantage in failing to validate
/* Draw the background */
console_save_and_set_mode(&SavedMode);
- message[0] = PoolPrint (L"%s UEFI key management", SHIM_VENDOR);
+ message[0] = PoolPrint(L"%s UEFI key management", SHIM_VENDOR);
message[1] = NULL;
console_print_box_at(message, -1, 0, 0, -1, -1, 1, 1);
FreePool(message[0]);
console_restore_mode(&SavedMode);
if (size == PASSWORD_CRYPT_SIZE) {
- efi_status = match_password((PASSWORD_CRYPT *)pwhash, NULL, 0,
+ efi_status = match_password((PASSWORD_CRYPT *) pwhash, NULL, 0,
NULL, L"Enter MOK password:");
} else {
efi_status = match_password(NULL, NULL, 0, pwhash,
EFI_STATUS status;
UINTN cols, rows;
CHAR16 *title[2];
- CHAR16 *message = L"Press any key to perform MOK management";
+ CHAR16 *message = L"Press any key to perform MOK management";
int timeout = 10, wait = 10000000;
- console_save_and_set_mode (&SavedMode);
+ console_save_and_set_mode(&SavedMode);
- title[0] = PoolPrint (L"%s UEFI key management", SHIM_VENDOR);
+ title[0] = PoolPrint(L"%s UEFI key management", SHIM_VENDOR);
title[1] = NULL;
console_print_box_at(title, -1, 0, 0, -1, -1, 1, 1);
uefi_call_wrapper(ST->ConOut->QueryMode, 4, ST->ConOut,
ST->ConOut->Mode->Mode, &cols, &rows);
- PrintAt((cols - StrLen(message))/2, rows/2, message);
+ PrintAt((cols - StrLen(message)) / 2, rows / 2, message);
while (1) {
if (timeout > 1)
- PrintAt(2, rows - 3, L"Booting in %d seconds ", timeout);
+ PrintAt(2, rows - 3, L"Booting in %d seconds ",
+ timeout);
else if (timeout)
- PrintAt(2, rows - 3, L"Booting in %d second ", timeout);
+ PrintAt(2, rows - 3, L"Booting in %d second ",
+ timeout);
status = WaitForSingleEvent(ST->ConIn->WaitForKey, wait);
MOK_HASH_ENROLL
} mok_menu_item;
-static void free_menu(mok_menu_item *menu_item, CHAR16 **menu_strings)
+static void free_menu(mok_menu_item * menu_item, CHAR16 ** menu_strings)
{
if (menu_strings)
FreePool(menu_strings);
UINT32 MokXDelAuth = 0;
efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"MokAuth",
- &SHIM_LOCK_GUID,
- &attributes, &auth_size, auth);
-
+ &SHIM_LOCK_GUID,
+ &attributes, &auth_size, auth);
if ((efi_status == EFI_SUCCESS) &&
- (auth_size == SHA256_DIGEST_SIZE || auth_size == PASSWORD_CRYPT_SIZE))
+ (auth_size == SHA256_DIGEST_SIZE ||
+ auth_size == PASSWORD_CRYPT_SIZE))
MokAuth = 1;
- efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"MokDelAuth",
- &SHIM_LOCK_GUID,
- &attributes, &auth_size, auth);
+ efi_status = uefi_call_wrapper(RT->GetVariable, 5,
+ L"MokDelAuth",
+ &SHIM_LOCK_GUID,
+ &attributes, &auth_size, auth);
if ((efi_status == EFI_SUCCESS) &&
- (auth_size == SHA256_DIGEST_SIZE || auth_size == PASSWORD_CRYPT_SIZE))
+ (auth_size == SHA256_DIGEST_SIZE ||
+ auth_size == PASSWORD_CRYPT_SIZE))
MokDelAuth = 1;
efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"MokXAuth",
- &SHIM_LOCK_GUID,
- &attributes, &auth_size, auth);
+ &SHIM_LOCK_GUID,
+ &attributes, &auth_size, auth);
if ((efi_status == EFI_SUCCESS) &&
- (auth_size == SHA256_DIGEST_SIZE || auth_size == PASSWORD_CRYPT_SIZE))
+ (auth_size == SHA256_DIGEST_SIZE ||
+ auth_size == PASSWORD_CRYPT_SIZE))
MokXAuth = 1;
- efi_status = uefi_call_wrapper(RT->GetVariable, 5, L"MokXDelAuth",
- &SHIM_LOCK_GUID,
- &attributes, &auth_size, auth);
+ efi_status = uefi_call_wrapper(RT->GetVariable, 5,
+ L"MokXDelAuth",
+ &SHIM_LOCK_GUID,
+ &attributes, &auth_size, auth);
if ((efi_status == EFI_SUCCESS) &&
- (auth_size == SHA256_DIGEST_SIZE || auth_size == PASSWORD_CRYPT_SIZE))
+ (auth_size == SHA256_DIGEST_SIZE ||
+ auth_size == PASSWORD_CRYPT_SIZE))
MokXDelAuth = 1;
if (MokNew || MokAuth)
if (MokDB)
menucount++;
- menu_strings = AllocateZeroPool(sizeof(CHAR16 *) * (menucount + 1));
-
+ menu_strings = AllocateZeroPool(sizeof(CHAR16 *) *
+ (menucount + 1));
if (!menu_strings)
return EFI_OUT_OF_RESOURCES;
menu_item = AllocateZeroPool(sizeof(mok_menu_item) * menucount);
-
if (!menu_item) {
FreePool(menu_strings);
return EFI_OUT_OF_RESOURCES;
efi_status = mok_reset_prompt(FALSE);
break;
case MOK_ENROLL_MOK:
- efi_status = mok_enrollment_prompt(MokNew, MokNewSize, TRUE, FALSE);
+ efi_status = mok_enrollment_prompt(MokNew, MokNewSize,
+ TRUE, FALSE);
if (efi_status == EFI_SUCCESS)
MokNew = NULL;
break;
case MOK_DELETE_MOK:
- efi_status = mok_deletion_prompt(MokDel, MokDelSize, FALSE);
+ efi_status = mok_deletion_prompt(MokDel, MokDelSize,
+ FALSE);
if (efi_status == EFI_SUCCESS)
MokDel = NULL;
break;
efi_status = mok_reset_prompt(TRUE);
break;
case MOK_ENROLL_MOKX:
- efi_status = mok_enrollment_prompt(MokXNew, MokXNewSize, TRUE, TRUE);
+ efi_status = mok_enrollment_prompt(MokXNew, MokXNewSize,
+ TRUE, TRUE);
if (efi_status == EFI_SUCCESS)
MokXNew = NULL;
break;
case MOK_DELETE_MOKX:
- efi_status = mok_deletion_prompt(MokXDel, MokXDelSize, TRUE);
+ efi_status = mok_deletion_prompt(MokXDel, MokXDelSize,
+ TRUE);
if (efi_status == EFI_SUCCESS)
MokXDel = NULL;
break;
EFI_STATUS status;
status = get_variable(L"MokNew", (UINT8 **)&MokNew, &MokNewSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
- if (LibDeleteVariable(L"MokNew", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
+ if (LibDeleteVariable(L"MokNew", &SHIM_LOCK_GUID) !=
+ EFI_SUCCESS) {
console_notify(L"Failed to delete MokNew");
}
} else if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
}
status = get_variable(L"MokDel", (UINT8 **)&MokDel, &MokDelSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
- if (LibDeleteVariable(L"MokDel", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
+ if (LibDeleteVariable(L"MokDel", &SHIM_LOCK_GUID) !=
+ EFI_SUCCESS) {
console_notify(L"Failed to delete MokDel");
}
} else if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
}
status = get_variable(L"MokSB", (UINT8 **)&MokSB, &MokSBSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
- if (LibDeleteVariable(L"MokSB", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
+ if (LibDeleteVariable(L"MokSB", &SHIM_LOCK_GUID) !=
+ EFI_SUCCESS) {
console_notify(L"Failed to delete MokSB");
}
} else if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
}
status = get_variable(L"MokPW", (UINT8 **)&MokPW, &MokPWSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
- if (LibDeleteVariable(L"MokPW", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
+ if (LibDeleteVariable(L"MokPW", &SHIM_LOCK_GUID) !=
+ EFI_SUCCESS) {
console_notify(L"Failed to delete MokPW");
}
} else if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
}
status = get_variable(L"MokDB", (UINT8 **)&MokDB, &MokDBSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
if (LibDeleteVariable(L"MokDB", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
console_notify(L"Failed to delete MokDB");
}
status = get_variable(L"MokXNew", (UINT8 **)&MokXNew, &MokXNewSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
- if (LibDeleteVariable(L"MokXNew", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
+ if (LibDeleteVariable(L"MokXNew", &SHIM_LOCK_GUID) !=
+ EFI_SUCCESS) {
console_notify(L"Failed to delete MokXNew");
}
} else if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
}
status = get_variable(L"MokXDel", (UINT8 **)&MokXDel, &MokXDelSize,
- SHIM_LOCK_GUID);
+ SHIM_LOCK_GUID);
if (status == EFI_SUCCESS) {
- if (LibDeleteVariable(L"MokXDel", &SHIM_LOCK_GUID) != EFI_SUCCESS) {
+ if (LibDeleteVariable(L"MokXDel", &SHIM_LOCK_GUID) !=
+ EFI_SUCCESS) {
console_notify(L"Failed to delete MokXDel");
}
} else if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
MokXNew, MokXNewSize, MokXDel, MokXDelSize);
if (MokNew)
- FreePool (MokNew);
+ FreePool(MokNew);
if (MokDel)
- FreePool (MokDel);
+ FreePool(MokDel);
if (MokSB)
- FreePool (MokSB);
+ FreePool(MokSB);
if (MokPW)
- FreePool (MokPW);
+ FreePool(MokPW);
if (MokDB)
- FreePool (MokDB);
+ FreePool(MokDB);
if (MokXNew)
- FreePool (MokXNew);
+ FreePool(MokXNew);
if (MokXDel)
- FreePool (MokXDel);
+ FreePool(MokXDel);
LibDeleteVariable(L"MokAuth", &SHIM_LOCK_GUID);
LibDeleteVariable(L"MokDelAuth", &SHIM_LOCK_GUID);
return EFI_SUCCESS;
}
-static EFI_STATUS setup_rand (void)
+static EFI_STATUS setup_rand(void)
{
EFI_TIME time;
EFI_STATUS efi_status;
if (efi_status != EFI_SUCCESS)
return efi_status;
- seed = ((UINT64)time.Year << 48) | ((UINT64)time.Month << 40) |
- ((UINT64)time.Day << 32) | ((UINT64)time.Hour << 24) |
- ((UINT64)time.Minute << 16) | ((UINT64)time.Second << 8) |
- ((UINT64)time.Daylight);
+ seed = ((UINT64) time.Year << 48) | ((UINT64) time.Month << 40) |
+ ((UINT64) time.Day << 32) | ((UINT64) time.Hour << 24) |
+ ((UINT64) time.Minute << 16) | ((UINT64) time.Second << 8) |
+ ((UINT64) time.Daylight);
- status = RandomSeed((UINT8 *)&seed, sizeof(seed));
+ status = RandomSeed((UINT8 *) & seed, sizeof(seed));
if (!status)
return EFI_ABORTED;
return EFI_SUCCESS;
}
-EFI_STATUS efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
+EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE * systab)
{
EFI_STATUS efi_status;
projects / efi-boot-shim.git / commitdiff