static int check_fw_support(fwts_framework *fw, uint64_t status) { if ((status == EFI_INVALID_PARAMETER) && ((attributes & FWTS_UEFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) || (attributes & FWTS_UEFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) || (attributes & FWTS_UEFI_VARIABLE_APPEND_WRITE))) { fwts_uefi_print_status_info(fw, status); fwts_skipped(fw, "EFI_INVALID_PARAMETER shall be returned, " "when firmware doesn't support these operations " "with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, " "EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS " "or EFI_VARIABLE_APPEND_WRITE attributes is set."); return FWTS_SKIP; } if (status == EFI_OUT_OF_RESOURCES) { fwts_uefi_print_status_info(fw, status); fwts_skipped(fw, "Run out of resources for SetVariable " "UEFI runtime interface: cannot test."); fwts_advice(fw, "Firmware may reclaim some resources " "after rebooting. Reboot and test " "again may be helpful to continue " "the test."); return FWTS_SKIP; } return FWTS_OK; }
/* * Set the created authenticated variable, AuthVarCreate, * and checking the data size and data. * expect EFI_SUCCESS returned. */ static int uefirtauthvar_test1(fwts_framework *fw) { long ioret; uint8_t data[getvar_buf_size]; uint64_t getdatasize = sizeof(data); uint64_t status; uint32_t attributestest; size_t i; ioret = setvar(>estguid, attributes, sizeof(AuthVarCreate), AuthVarCreate, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; fwts_failed(fw, LOG_LEVEL_HIGH, "UEFICreateAuthVar", "Failed to create authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFICreateAuthVar", "Failed to get authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (getdatasize != sizeof(AuthVarCreateData)) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFICreateAuthVar", "Get authenticated variable data size is not the " "same as it set."); return FWTS_ERROR; } for (i = 0; i < sizeof(AuthVarCreateData); i++) { if (data[i] != AuthVarCreateData[i]) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFICreateAuthVar", "Get authenticated variable data are not the " "same as it set."); return FWTS_ERROR; } } data_exist |= E_AUTHVARCREATE; fwts_passed(fw, "Create authenticated variable test passed."); return FWTS_OK; }
static int uefirttime_test_settime_invalid_time( fwts_framework *fw, EFI_TIME *time) { struct efi_gettime gettime; struct efi_settime settime; EFI_TIME oldtime, newtime; uint64_t status = ~0ULL; int ret, ioret; gettime.Time = &oldtime; gettime.status = &status; gettime.Capabilities = NULL; ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } memcpy(&newtime, &oldtime, sizeof(EFI_TIME)); if (time->Year != 0xffff) newtime.Year = time->Year; if (time->Month != 0xff) newtime.Month = time->Month; if (time->Day != 0xff) newtime.Day = time->Day; if (time->Hour != 0xff) newtime.Hour = time->Hour; if (time->Minute != 0xff) newtime.Minute = time->Minute; if (time->Second != 0xff) newtime.Second = time->Second; if (time->Nanosecond != 0xffffffff) newtime.Nanosecond = time->Nanosecond; if ((uint16_t)time->TimeZone != 0xffff) newtime.TimeZone = time->TimeZone; settime.Time = &newtime; settime.status = &status; ret = uefirttime_test_settime_invalid(fw, &settime); /* Restore original time */ settime.Time = &oldtime; status = ~0ULL; settime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, &settime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime", "Failed to set wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } return ret; }
/* * Delete the test authenticated variable. */ static int uefirtauthvar_test7(fwts_framework *fw) { long ioret; uint8_t data[getvar_buf_size]; uint64_t getdatasize = sizeof(data); uint64_t status; uint32_t attributestest; if (!(data_exist & E_AUTHVARCREATE)) { fwts_skipped(fw,"The test data, AuthVarCreate, doesn't exist, skip the test."); return FWTS_SKIP; } ioret = setvar(>estguid, attributes, sizeof(AuthVarDel), AuthVarDel, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIDelAuthVar", "Failed to delete authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status); if (ioret == -1) { if (status == EFI_NOT_FOUND) { fwts_passed(fw, "Delete authenticated variable tests passed."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_MEDIUM, "UEFIDelAuthVar", "Failed to get authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIDelAuthVar", "Failed to delete authenticated variable still get the test" "authenticated variable."); return FWTS_ERROR; }
/* * Set the authenticated variable with different guid, expect * EFI_SECURITY_VIOLATION returned. */ static int uefirtauthvar_test10(fwts_framework *fw) { long ioret; uint64_t status; EFI_GUID gtestguiddiff = TEST_GUID1; ioret = setvar(>estguiddiff, attributes, sizeof(AuthVarCreate), AuthVarCreate, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; if (status == EFI_SECURITY_VIOLATION) { fwts_passed(fw, "Set authenticated variable test with different guid passed."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_MEDIUM, "UEFISetAuthVarDiffGuid", "Set authenticated variable fail"); fwts_uefi_print_status_info(fw, status); } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarDiffGuid", "Set authenticated variable expected fail but success"); return FWTS_ERROR; }
/* * Set the authenticated variable with invalid modified timestamp, expect * EFI_SECURITY_VIOLATION returned. */ static int uefirtauthvar_test9(fwts_framework *fw) { long ioret; uint64_t status; ioret = setvar(>estguid, attributes, sizeof(AuthVarModTime), AuthVarModTime, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; if (status == EFI_SECURITY_VIOLATION) { fwts_passed(fw, "Set authenticated variable test with invalid modified timestamp passed."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_MEDIUM, "UEFISetAuthVarInvalidTime", "Set authenticated variable fail"); fwts_uefi_print_status_info(fw, status); } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarInvalidTime", "Set authenticated variable expected fail but success"); return FWTS_ERROR; }
/* * After updated, set the old data and timestamp authenticated variable, * AuthVarCreate, expect EFI_SECURITY_VIOLATION returned. */ static int uefirtauthvar_test6(fwts_framework *fw) { long ioret; uint64_t status; if (!(data_exist & E_AUTHVARUPDATE)) { fwts_skipped(fw,"The test variable, AuthVarUpdate, doesn't exist, skip the test."); return FWTS_SKIP; } ioret = setvar(>estguid, attributes, sizeof(AuthVarCreate), AuthVarCreate, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; if (status == EFI_SECURITY_VIOLATION) { fwts_passed(fw, "Authenticated variable test with old authenticated variable passed."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_MEDIUM, "UEFISetOldAuthVar", "Set authenticated variable fail"); fwts_uefi_print_status_info(fw, status); } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetOldAuthVar", "Set authenticated variable expected fail but success"); return FWTS_ERROR; }
/* * The authenticated variable is followed EFI_VARIABLE_AUTHENTICATION_2 descriptor, * set the authenticated variable with invalid * EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS instead of * EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute should * return EFI_SECURITY_VIOLATION. */ static int uefirtauthvar_test11(fwts_framework *fw) { long ioret; uint64_t status; uint32_t attr = FWTS_UEFI_VAR_NON_VOLATILE | FWTS_UEFI_VAR_BOOTSERVICE_ACCESS | FWTS_UEFI_VAR_RUNTIME_ACCESS | FWTS_UEFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS; ioret = setvar(>estguid, attr, sizeof(AuthVarCreate), AuthVarCreate, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; if (status == EFI_SECURITY_VIOLATION) { fwts_passed(fw, "Set authenticated variable test with invalid attributes passed."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_MEDIUM, "UEFISetAuthVarInvalidAttr", "Set authenticated variable fail"); fwts_uefi_print_status_info(fw, status); } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarInvalidAttr", "Set authenticated variable expected fail but success"); return FWTS_ERROR; }
static int uefirttime_test1(fwts_framework *fw) { long ioret; struct efi_gettime gettime; EFI_TIME efi_time; EFI_TIME_CAPABILITIES efi_time_cap; uint64_t status; gettime.Capabilities = &efi_time_cap; gettime.Time = &efi_time; gettime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (!checktimefields(fw, gettime.Time)) return FWTS_ERROR; fwts_passed(fw, "UEFI runtime service GetTime interface test passed."); return FWTS_OK; }
static int uefirttime_test18(fwts_framework *fw) { long ioret; struct efi_getwakeuptime getwakeuptime; uint64_t status; uint8_t enabled, pending; EFI_TIME efi_time; getwakeuptime.Enabled = &enabled; getwakeuptime.Pending = &pending; getwakeuptime.Time = &efi_time; getwakeuptime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime); if (ioret == -1) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "Skipping test, GetWakeupTime runtime " "service is not supported on this platform."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime", "Failed to get wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (!checktimefields(fw, getwakeuptime.Time)) return FWTS_ERROR; fwts_passed(fw, "UEFI runtime service GetWakeupTime interface test passed."); return FWTS_OK; }
static int uefirttime_test_setwakeuptime_invalid( fwts_framework *fw, struct efi_setwakeuptime *setwakeuptime ) { long ioret; uint64_t status; setwakeuptime->status = &status; ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, setwakeuptime); if (ioret == -1) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "Skipping test, GetWakeupTime runtime " "service is not supported on this platform."); return FWTS_OK; } if (status == EFI_INVALID_PARAMETER) { fwts_passed(fw, "UEFI runtime service SetTimeWakeupTime interface test " "passed, returned EFI_INVALID_PARAMETER as expected."); return FWTS_OK; } else { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime", "Failed to get correct return status from UEFI runtime service, " "expecting EFI_INVALID_PARAMETER."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime", "Failed to get error return status from UEFI runtime service, expected EFI_INVALID_PARAMETER."); return FWTS_ERROR; }
static int uefirttime_test_getwaketime_invalid( fwts_framework *fw, struct efi_getwakeuptime *getwakeuptime) { long ioret; uint64_t status; getwakeuptime->status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, getwakeuptime); if (ioret == -1) { if (status == EFI_INVALID_PARAMETER || status == EFI_UNSUPPORTED) { fwts_passed(fw, "UEFI runtime service GetTimeWakeupTime interface test " "passed, returned EFI_INVALID_PARAMETER or " "EFI_UNSUPPORTED as expected."); return FWTS_OK; } else { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime", "Failed to get correct return status from UEFI " "runtime service, expecting EFI_INVALID_PARAMETER " "or EFI_UNSUPPORTED."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime", "Failed to get error return status from UEFI runtime service, expected EFI_INVALID_PARAMETER."); return FWTS_ERROR; }
static int uefirttime_test_settime_invalid( fwts_framework *fw, struct efi_settime *settime) { long ioret; uint64_t status; settime->status = &status; ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, settime); if (ioret == -1) { if (status == EFI_INVALID_PARAMETER) { fwts_passed(fw, "UEFI runtime service SetTime interface test " "passed, returned EFI_INVALID_PARAMETER as expected."); return FWTS_OK; } else { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime", "Failed to get correct return status from UEFI runtime service, expecting EFI_INVALID_PARAMETER."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime", "Failed to get error return status from UEFI runtime service, expected EFI_INVALID_PARAMETER."); return FWTS_ERROR; }
static int uefirttime_test_gettime_invalid( fwts_framework *fw, EFI_TIME *efi_time, EFI_TIME_CAPABILITIES *efi_time_cap) { long ioret; struct efi_gettime gettime; uint64_t status; gettime.Capabilities = efi_time_cap; gettime.Time = efi_time; gettime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime); if (ioret == -1) { if (status == EFI_INVALID_PARAMETER) { fwts_passed(fw, "UEFI runtime service GetTime interface test " "passed, returned EFI_INVALID_PARAMETER as expected."); return FWTS_OK; } else { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get correct return status from UEFI runtime service, expecting EFI_INVALID_PARAMETER."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get error return status from UEFI runtime service, expected EFI_INAVLID_PARAMETER."); return FWTS_ERROR; }
static int uefivarinfo_test1(fwts_framework *fw) { uint64_t status; uint64_t remvarstoragesize; uint64_t maxvariablesize; uint64_t maxvarstoragesize; uint64_t usedvars; uint64_t usedvarssize; if (do_queryvariableinfo(&status, &maxvarstoragesize, &remvarstoragesize, &maxvariablesize) == FWTS_ERROR) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "QueryVariableInfo UEFI runtime interface not supported: cannot test."); fwts_advice(fw, "Firmware also needs to check if the revision " "of system table is correct or not. Linux " "kernel returns EFI_UNSUPPORTED as well, if " "the FirmwareRevision of system table is less " "than EFI_2_00_SYSTEM_TABLE_REVISION."); return FWTS_SKIP; } else { fwts_log_info(fw, "Failed to query variable info with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } } fwts_log_info_verbatim(fw, "UEFI NVRAM storage:"); fwts_log_info_verbatim(fw, " Maximum storage: %8" PRIu64 " bytes", maxvarstoragesize); fwts_log_info_verbatim(fw, " Remaining storage: %8" PRIu64 " bytes", remvarstoragesize); fwts_log_info_verbatim(fw, " Maximum variable size: %8" PRIu64 " bytes", maxvariablesize); if (do_checkvariables(fw, &usedvars, &usedvarssize, maxvariablesize) == FWTS_OK) { fwts_log_info_verbatim(fw, "Currently used:"); fwts_log_info_verbatim(fw, " %" PRIu64 " variables, storage used: %" PRIu64 " bytes", usedvars, usedvarssize); } return FWTS_OK; }
static int do_checkvariables( fwts_framework *fw, uint64_t *usedvars, uint64_t *usedvarssize, const uint64_t maxvarsize) { uint64_t status; struct efi_getnextvariablename getnextvariablename; uint64_t variablenamesize = MAX_VARNAME_LENGTH; uint16_t variablename[MAX_VARNAME_LENGTH]; EFI_GUID vendorguid; uint8_t *data; uint64_t getdatasize; uint32_t attributestest; struct efi_getvariable getvariable; getvariable.Attributes = &attributestest; getvariable.status = &status; getnextvariablename.VariableNameSize = &variablenamesize; getnextvariablename.VariableName = variablename; getnextvariablename.VendorGuid = &vendorguid; getnextvariablename.status = &status; *usedvars = 0; *usedvarssize = 0; /* * To start the search, need to pass a Null-terminated string * in VariableName */ variablename[0] = '\0'; while (true) { long ioret; status = ~0ULL; variablenamesize = MAX_VARNAME_LENGTH; ioret = ioctl(fd, EFI_RUNTIME_GET_NEXTVARIABLENAME, &getnextvariablename); if (ioret == -1) { /* no next variable was found*/ if (*getnextvariablename.status == EFI_NOT_FOUND) break; fwts_log_info(fw, "Failed to get next variable name with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } (*usedvars)++; data = malloc(maxvarsize); if (!data) { fwts_log_info(fw, "Failed to allocate memory for test."); return FWTS_ERROR; } getdatasize = maxvarsize; getvariable.VariableName = variablename; getvariable.VendorGuid = &vendorguid; getvariable.DataSize = &getdatasize; getvariable.Data = data; status = ~0ULL; ioret = ioctl(fd, EFI_RUNTIME_GET_VARIABLE, &getvariable); if (ioret == -1) { if (status != EFI_BUFFER_TOO_SMALL) { free(data); fwts_log_info(fw, "Failed to get variable with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } else if (getdatasize > maxvarsize) { free(data); fwts_log_info(fw, "Variable is larger than maximum variable length."); fwts_uefi_print_status_info(fw, status); /* * Although the variable is larger than maximum variable length, * still try to calculate the total sizes of the used variables. */ data = malloc(getdatasize); if (!data) { fwts_log_info(fw, "Failed to allocate memory for test."); return FWTS_ERROR; } getvariable.Data = data; status = ~0ULL; ioret = ioctl(fd, EFI_RUNTIME_GET_VARIABLE, &getvariable); if (ioret == -1) { fwts_log_info(fw, "Failed to get variable with variable larger than maximum variable length."); fwts_uefi_print_status_info(fw, status); free(data); return FWTS_ERROR; } } } free(data); (*usedvarssize) += getdatasize; }; return FWTS_OK; }
static int uefirttime_test_setwakeuptime_invalid_time( fwts_framework *fw, EFI_TIME *time) { struct efi_getwakeuptime getwakeuptime; struct efi_setwakeuptime setwakeuptime; EFI_TIME oldtime, newtime; uint64_t status; uint8_t pending, enabled; int ret, ioret; getwakeuptime.Enabled = &enabled; getwakeuptime.Pending = &pending; getwakeuptime.Time = &oldtime; getwakeuptime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime); if (ioret == -1) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "Skipping test, GetWakeupTime runtime " "service is not supported on this platform."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime", "Failed to get wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } memcpy(&newtime, &oldtime, sizeof(EFI_TIME)); if (time->Year != 0xffff) newtime.Year = time->Year; if (time->Month != 0xff) newtime.Month = time->Month; if (time->Day != 0xff) newtime.Day = time->Day; if (time->Hour != 0xff) newtime.Hour = time->Hour; if (time->Minute != 0xff) newtime.Minute = time->Minute; if (time->Second != 0xff) newtime.Second = time->Second; if (time->Nanosecond != 0xffffffff) newtime.Nanosecond = time->Nanosecond; if ((uint16_t)time->TimeZone != 0xffff) newtime.TimeZone = time->TimeZone; setwakeuptime.Time = &newtime; setwakeuptime.status = &status; setwakeuptime.Enabled = true; ret = uefirttime_test_setwakeuptime_invalid(fw, &setwakeuptime); /* Restore original time */ setwakeuptime.Time = &oldtime; setwakeuptime.status = &status; setwakeuptime.Enabled = true; ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, &setwakeuptime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime", "Failed to set wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } return ret; }
static int uefirttime_test23(fwts_framework *fw) { long ioret; struct efi_setwakeuptime setwakeuptime; uint64_t status; EFI_TIME oldtime; EFI_TIME newtime; struct efi_gettime gettime; EFI_TIME_CAPABILITIES efi_time_cap; struct efi_getwakeuptime getwakeuptime; uint8_t enabled, pending; gettime.Capabilities = &efi_time_cap; gettime.Time = &oldtime; gettime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } /* change the hour, add 1 hour*/ addonehour(&oldtime); setwakeuptime.Time = &oldtime; setwakeuptime.status = &status; setwakeuptime.Enabled = true; ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, &setwakeuptime); if (ioret == -1) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "Skipping test, GetWakeupTime runtime " "service is not supported on this platform."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime", "Failed to set wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } sleep(1); getwakeuptime.Enabled = &enabled; getwakeuptime.Pending = &pending; getwakeuptime.Time = &newtime; getwakeuptime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime); if (ioret == -1) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "Skipping test, GetWakeupTime runtime " "service is not supported on this platform."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime", "Failed to get wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (*getwakeuptime.Enabled != true) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimeEnable", "Failed to set wakeup alarm clock, wakeup timer should be enabled."); return FWTS_ERROR; } if (*getwakeuptime.Pending != false) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimePending", "Get error alarm signle status."); return FWTS_ERROR; } if ((oldtime.Year != newtime.Year) || (oldtime.Month != newtime.Month) || (oldtime.Day != newtime.Day) || (oldtime.Hour != newtime.Hour)) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimeVerify", "Failed to verify wakeup time after change."); return FWTS_ERROR; } setwakeuptime.Enabled = false; ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, &setwakeuptime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime", "Failed to set wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } sleep(1); ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime); if (ioret == -1) { if (status == EFI_UNSUPPORTED) { fwts_skipped(fw, "Skipping test, GetWakeupTime runtime " "service is not supported on this platform."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime", "Failed to get wakeup time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (*getwakeuptime.Enabled != false) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimeEnable", "Failed to set wakeup alarm clock, wakeup timer should be disabled."); return FWTS_ERROR; } fwts_passed(fw, "UEFI runtime service SetWakeupTime interface test passed."); return FWTS_OK; }
static int uefirttime_test4(fwts_framework *fw) { long ioret; struct efi_settime settime; uint64_t status; struct efi_gettime gettime; EFI_TIME oldtime; EFI_TIME newtime; EFI_TIME time; EFI_TIME_CAPABILITIES efi_time_cap; gettime.Capabilities = &efi_time_cap; gettime.Time = &oldtime; gettime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } /* refer to UEFI SCT 2.3 test items */ /* change year */ time = oldtime; if (time.Year != 2012) time.Year = 2012; else time.Year = 2016; /* change month */ if (time.Month != 1) time.Month = 1; else time.Month = 12; /* Change daylight */ if (time.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT) time.Daylight &= ~FWTS_UEFI_TIME_ADJUST_DAYLIGHT; else time.Daylight |= FWTS_UEFI_TIME_ADJUST_DAYLIGHT; /* Change time zone */ if (time.TimeZone != 0) time.TimeZone = 0; else /* Unspecified timezone, local time */ time.TimeZone = 2047; settime.Time = &time; settime.status = &status; ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, &settime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime", "Failed to set time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } sleep(1); gettime.Time = &newtime; ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime", "Failed to get time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (!((oldtime.Year == 2012) && (newtime.Year == 2016)) && !((oldtime.Year != 2012) && (newtime.Year == 2012))) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeYear", "Failed to set year with UEFI runtime service."); return FWTS_ERROR; } if (!((oldtime.Month == 1) && (newtime.Month == 12)) && !((oldtime.Month != 1) && (newtime.Month == 1))) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeMonth", "Failed to set month with UEFI runtime service."); return FWTS_ERROR; } if (!((oldtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT) && (!(newtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT))) && !((!(oldtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT)) && (newtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT))) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeDaylight", "Failed to set daylight with UEFI runtime service."); return FWTS_ERROR; } if (!((oldtime.TimeZone == 0) && (newtime.TimeZone == 2047)) && !((oldtime.TimeZone != 0) && (newtime.TimeZone == 0))) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeTimezone", "Failed to set timezone with UEFI runtime service."); return FWTS_ERROR; } /* restore the previous time. */ settime.Time = &oldtime; ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, &settime); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime", "Failed to set time with UEFI runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } fwts_passed(fw, "UEFI runtime service SetTime interface test passed."); return FWTS_OK; }
/* * Execute the normal append operation. */ static int uefirtauthvar_test4(fwts_framework *fw) { long ioret; uint8_t data[getvar_buf_size]; uint64_t getdatasize = sizeof(data); uint64_t status; uint32_t attributestest; size_t i; uint32_t attribappend = attributes | FWTS_UEFI_VARIABLE_APPEND_WRITE; if (!(data_exist & E_AUTHVARCREATE)) { fwts_skipped(fw,"The test variable, AuthVarCreate, doesn't exist, skip the test."); return FWTS_SKIP; } ioret = setvar(>estguid, attribappend, sizeof(AuthVarAppend), AuthVarAppend, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIAppendAuthVar", "Failed to append authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIAppendAuthVar", "Failed to get authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (getdatasize != (sizeof(AuthVarCreateData) + sizeof(AuthVarAppendData))) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIAppendAuthVar", "Get total authenticated variable data size is not the " "same as it set and appended."); return FWTS_ERROR; } for (i = 0; i < getdatasize; i++) { if (i < sizeof(AuthVarCreateData)) { if (data[i] != AuthVarCreateData[i]) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIAppendAuthVar", "Get authenticated variable data are not the " "same as it set."); return FWTS_ERROR; } } else { if (data[i] != AuthVarAppendData[i - sizeof(AuthVarCreateData)]) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIAppendAuthVar", "Get authenticated variable data are not the " "same as it set."); return FWTS_ERROR; } } } data_exist |= E_AUTHVARAPPEND; fwts_passed(fw, "Append authenticated variable tests passed."); return FWTS_OK; }
/* * Test with setting and deleting another authenticated variable, * after previous test authenticated variable was deleted. */ static int uefirtauthvar_test12(fwts_framework *fw) { long ioret; uint8_t data[getvar_buf_size]; uint64_t getdatasize = sizeof(data); uint64_t status; uint32_t attributestest; size_t i; ioret = setvar(>estguid, attributes, sizeof(AuthVarCreateDiff), AuthVarCreateDiff, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarDiff", "Failed to set authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status); if (ioret == -1) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarDiff", "Failed to get authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } if (getdatasize != sizeof(AuthVarCreateData)) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarDiff", "Get authenticated variable data size is not the " "same as it set."); return FWTS_ERROR; } for (i = 0; i < sizeof(AuthVarCreateData); i++) { if (data[i] != AuthVarCreateData[i]) { fwts_failed(fw, LOG_LEVEL_HIGH, "UEFISetAuthVarDiff", "Get authenticated variable data are not the " "same as it set."); return FWTS_ERROR; } } fwts_passed(fw, "Set authenticated variable created by different key test passed."); ioret = setvar(>estguid, attributes, sizeof(AuthVarDelDiff), AuthVarDelDiff, &status); if (ioret == -1) { int supcheck = check_fw_support(fw, status); if (supcheck != FWTS_OK) return supcheck; fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIDelAuthVarDiff", "Failed to delete authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status); if (ioret == -1) { if (status == EFI_NOT_FOUND) { fwts_passed(fw, "Delete authenticated variable created by different key test passed."); return FWTS_OK; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIDelAuthVarDiff", "Failed to get authenticated variable with UEFI " "runtime service."); fwts_uefi_print_status_info(fw, status); return FWTS_ERROR; } fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIDelAuthVarDiff", "Failed to delete authenticated variable still get the test" "authenticated variable."); return FWTS_ERROR; }