def _ioctl(self, ioctl_code, in_buf, out_length):
if not self.driver_loaded:
_handle_error(
"chipsec kernel driver is not loaded (in native API mode?)")
out_buf = (c_char * out_length)()
self.get_driver_handle()
if logger().DEBUG: print_buffer(bytestostring(in_buf))
try:
out_buf = win32file.DeviceIoControl(self.driver_handle, ioctl_code,
in_buf, out_length, None)
except pywintypes.error as _err:
err_status = _err.args[0] + 0x100000000
if STATUS_PRIVILEGED_INSTRUCTION == err_status:
err_msg = "HW Access Violation: DeviceIoControl returned STATUS_PRIVILEGED_INSTRUCTION (0x{:X})".format(
err_status)
if logger().DEBUG: logger().error(err_msg)
raise HWAccessViolationError(err_msg, err_status)
else:
_handle_error(
"HW Access Error: DeviceIoControl returned status 0x{:X} ({})"
.format(err_status, _err.args[2]), err_status)
return out_buf
def get_ACPI_table_list(self):
try:
# 1. Try to extract ACPI table(s) from physical memory
# read_physical_mem can be implemented using both
# CHIPSEC kernel module and OS native API
if logger().HAL:
logger().log(
"[acpi] trying to enumerate ACPI tables from physical memory..."
)
# find RSDT/XSDT table
(is_xsdt, sdt_pa, sdt, sdt_header) = self.get_SDT()
# cache RSDT/XSDT in the list of ACPI tables
if sdt_pa is not None:
self.tableList[bytestostring(
sdt_header.Signature)].append(sdt_pa)
self.get_table_list_from_SDT(sdt, is_xsdt)
self.get_DSDT_from_FADT()
except oshelper.UnimplementedNativeAPIError:
# 2. If didn't work, try using get_ACPI_table if a helper implemented
# reading ACPI tables via native API which some OS may provide
if self.cs.use_native_api():
if logger().HAL:
logger().log(
"[acpi] trying to enumerate ACPI tables using get_ACPI_table..."
)
for t in ACPI_TABLES.keys():
table = self.cs.helper.get_ACPI_table(t)
if table: self.tableList[t].append(0)
return self.tableList
def _find_RSDP_in_EFI(self):
rsdp_pa = None
rsdp = None
if logger().HAL:
logger().log(
"[acpi] searching all EFI memory for RSDP (this may take a minute).."
)
CHUNK_SZ = 1024 * 1024 # 1MB
(smram_base, smram_limit, smram_size) = self.cs.cpu.get_SMRAM()
pa = smram_base - CHUNK_SZ
while pa > CHUNK_SZ:
membuf = self.cs.mem.read_physical_mem(pa, CHUNK_SZ)
pos = bytestostring(membuf).find(ACPI_RSDP_SIG)
if -1 != pos:
rsdp_pa = pa + pos
if logger().HAL:
logger().log(
"[acpi] found '{}' signature at 0x{:16X}. Checking if valid RSDP.."
.format(ACPI_RSDP_SIG, rsdp_pa))
rsdp = self.read_RSDP(rsdp_pa)
if rsdp.is_RSDP_valid():
if logger().HAL:
logger().log(
"[acpi] found RSDP in EFI memory: 0x{:016X}".
format(rsdp_pa))
break
pa -= CHUNK_SZ
return rsdp, rsdp_pa
def parse_script(script, log_script=False):
off = 0
entry_type = 0
s3_boot_script_entries = []
len_s = len(script)
if log_script: logger().log('[uefi] +++ S3 Resume Boot-Script +++\n')
script_type, script_header_length = uefi_platform.id_s3bootscript_type(
script, log_script)
off += script_header_length
while (off < len_s) and (
entry_type != S3BootScriptOpcode.EFI_BOOT_SCRIPT_TERMINATE_OPCODE):
entry_type, s3script_entry = uefi_platform.parse_s3bootscript_entry(
script_type, script, off, log_script)
# couldn't parse the next entry - return what has been parsed so far
if s3script_entry is None: return s3_boot_script_entries
s3_boot_script_entries.append(s3script_entry)
off += s3script_entry.length
if log_script: logger().log('[uefi] +++ End of S3 Resume Boot-Script +++')
if logger().HAL:
logger().log('[uefi] S3 Resume Boot-Script size: 0x{:X}'.format(off))
if logger().HAL:
logger().log(
'\n[uefi] [++++++++++ S3 Resume Boot-Script Buffer ++++++++++]')
print_buffer(bytestostring(script[:off]))
return s3_boot_script_entries
def _find_RSDP_in_legacy_BIOS_segments(self):
rsdp_pa = None
rsdp = None
membuf = self.cs.mem.read_physical_mem(0xE0000, 0x20000)
membuf = bytestostring(membuf)
pos = bytestostring(membuf).find(ACPI_RSDP_SIG)
if -1 != pos:
rsdp_pa = 0xE0000 + pos
rsdp = self.read_RSDP(rsdp_pa)
if rsdp.is_RSDP_valid():
if logger().HAL:
logger().log(
"[acpi] found RSDP in BIOS E/F segments: 0x{:016X}".
format(rsdp_pa))
else:
rsdp_pa = None
return rsdp, rsdp_pa
def __str__(self):
_s = "{}+{:08X}h {}: Type {:02X}h".format(self.indent,self.Offset,self.name(),self.Type)
if self.Guid: _s += " GUID {{{}}}".format(self.Guid)
if self.Attributes: _s += " Attr {:04X}h".format(self.Attributes)
if self.DataOffset: _s += " DataOffset {:04X}h".format(self.DataOffset)
if self.Comments: _s += "Comments {}".format(self.Comments)
_s += super(EFI_SECTION, self).__str__()
return bytestostring(_s)
def get_table_list_from_SDT(self, sdt, is_xsdt):
if logger().HAL: logger().log( '[acpi] Getting table list from entries in {}'.format('XSDT' if is_xsdt else 'RSDT') )
for a in sdt.Entries:
_sig = self.cs.mem.read_physical_mem( a, ACPI_TABLE_SIG_SIZE )
_sig = bytestostring(_sig)
if _sig not in ACPI_TABLES.keys():
if logger().HAL: logger().warn( 'Unknown ACPI table signature: {}'.format(_sig) )
self.tableList[ _sig ].append(a)
def get_EFI_variable(self, name, guid, filename=None):
var = self.helper.get_EFI_variable(name, guid)
if var:
if filename: write_file(filename, var)
if logger().UTIL_TRACE or logger().HAL:
logger().log('[uefi] EFI variable {}:{} :'.format(guid, name))
print_buffer(bytestostring(var))
return var
def write_mmio_reg(self, phys_address, size, value):
phys_address_lo = phys_address & 0xFFFFFFFF
phys_address_hi = (phys_address >> 32) & 0xFFFFFFFF
if size == 4:
return edk2.writemem_dword(phys_address_lo, phys_address_hi, value)
else:
buf = bytestostring(struct.pack(size * "B", value))
edk2.writemem(phys_address_lo, phys_address_hi, buf, size)
def find_EFI_Table( self, table_sig ):
(smram_base,smram_limit,smram_size) = self.cs.cpu.get_SMRAM()
CHUNK_SZ = 1024*1024 # 1MB
if logger().HAL: logger().log( "[uefi] searching memory for EFI table with signature '{}' ..".format(table_sig) )
table_pa,table_header,table,table_buf = None,None,None,None
pa = smram_base - CHUNK_SZ
isFound = False
while pa > CHUNK_SZ:
if logger().HAL: logger().log( '[uefi] reading 0x{:016X}..'.format(pa) )
membuf = self.cs.mem.read_physical_mem( pa, CHUNK_SZ )
pos = bytestostring(membuf).find( table_sig )
if -1 != pos:
table_pa = pa + pos
if logger().HAL: logger().log( "[uefi] found signature '{}' at 0x{:016X}..".format(table_sig,table_pa) )
if pos < (CHUNK_SZ - EFI_TABLE_HEADER_SIZE):
hdr = membuf[ pos : pos + EFI_TABLE_HEADER_SIZE ]
else:
hdr = self.cs.mem.read_physical_mem( table_pa, EFI_TABLE_HEADER_SIZE )
table_header = EFI_TABLE_HEADER( *struct.unpack_from( EFI_TABLE_HEADER_FMT, hdr ) )
# do some sanity checks on the header
if 0 != table_header.Reserved or \
0 == table_header.CRC32 or \
table_header.Revision not in EFI_REVISIONS or \
table_header.HeaderSize > MAX_EFI_TABLE_SIZE:
if logger().HAL:
logger().log( "[uefi] found '{}' at 0x{:016X} but doesn't look like an actual table. keep searching..".format(table_sig,table_pa) )
logger().log( table_header )
else:
isFound = True
if logger().HAL: logger().log( "[uefi] found EFI table at 0x{:016X} with signature '{}'..".format(table_pa,table_sig) )
table_size = struct.calcsize( EFI_TABLES[table_sig]['fmt'] )
if pos < (CHUNK_SZ - EFI_TABLE_HEADER_SIZE - table_size):
table_buf = membuf[ pos : pos + EFI_TABLE_HEADER_SIZE + table_size ]
else:
table_buf = self.cs.mem.read_physical_mem( table_pa, EFI_TABLE_HEADER_SIZE + table_size )
table = EFI_TABLES[table_sig]['struct']( *struct.unpack_from( EFI_TABLES[table_sig]['fmt'], table_buf[EFI_TABLE_HEADER_SIZE:] ) )
if logger().HAL:
print_buffer( bytestostring(table_buf) )
logger().log( '[uefi] {}:'.format(EFI_TABLES[table_sig]['name']) )
logger().log( table_header )
logger().log( table )
break
pa -= CHUNK_SZ
if (not isFound) and logger().HAL: logger().log( "[uefi] could not find EFI table with signature '{}'".format(table_sig) )
return (isFound,table_pa,table_header,table,table_buf)
def print_efi_variable( offset, efi_var_buf, EFI_var_header, efi_var_name, efi_var_data, efi_var_guid, efi_var_attributes ):
logger().log( '\n--------------------------------' )
logger().log( 'EFI Variable (offset = 0x{:X}):'.format(offset) )
logger().log( '--------------------------------' )
# Print Variable Name
logger().log( u'Name : {}'.format(efi_var_name) )
# Print Variable GUID
logger().log( 'Guid : {}'.format(efi_var_guid) )
# Print Variable State
if EFI_var_header:
if 'State' in EFI_var_header._fields:
state = getattr(EFI_var_header, 'State')
state_str = 'State :'
if uefi_platform.IS_VARIABLE_STATE( state, uefi_platform.VAR_IN_DELETED_TRANSITION ):
state_str = state_str + ' IN_DELETED_TRANSITION +'
if uefi_platform.IS_VARIABLE_STATE( state, uefi_platform.VAR_DELETED ):
state_str = state_str + ' DELETED +'
if uefi_platform.IS_VARIABLE_STATE( state, uefi_platform.VAR_ADDED ):
state_str = state_str + ' ADDED +'
logger().log( state_str )
# Print Variable Complete Header
if logger().VERBOSE:
if EFI_var_header.__str__:
logger().log( EFI_var_header )
else:
logger().log( 'Decoded Header ({}):'.format(uefi_platform.EFI_VAR_DICT[ uefi_platform.FWType.EFI_FW_TYPE_UEFI ]['name']) )
for attr in EFI_var_header._fields:
logger().log( '{} = {:X}'.format('{0:<16}'.format(attr), getattr(EFI_var_header, attr)) )
attr_str = ('Attributes: 0x{:X} ( {} )'.format(efi_var_attributes, get_attr_string( efi_var_attributes )))
logger().log( attr_str )
# Print Variable Data
logger().log( 'Data:' )
print_buffer( bytestostring(efi_var_data) )
# Print Variable Full Contents
if logger().VERBOSE:
logger().log( 'Full Contents:' )
if not efi_var_buf is None:
print_buffer( bytestostring(efi_var_buf) )
def find_s3_bootscript( self ):
found = False
BootScript_addresses = []
efivars = self.list_EFI_variables()
if efivars is None:
logger().error( 'Could not enumerate UEFI variables at runtime' )
return (found,BootScript_addresses)
if logger().HAL: logger().log( "[uefi] searching for EFI variable(s): " + str(S3_BOOTSCRIPT_VARIABLES) )
for efivar_name in efivars:
(off, buf, hdr, data, guid, attrs) = efivars[efivar_name][0]
if efivar_name in S3_BOOTSCRIPT_VARIABLES:
if logger().HAL: logger().log( "[uefi] found: {} {{{}}} {} variable".format(efivar_name,guid,get_attr_string(attrs)) )
if logger().HAL:
logger().log('[uefi] {} variable data:'.format(efivar_name))
print_buffer( bytestostring(data) )
varsz = len(data)
if 4 == varsz: AcpiGlobalAddr_fmt = '<L'
elif 8 == varsz: AcpiGlobalAddr_fmt = '<Q'
else:
logger().error( "Unrecognized format of '{}' UEFI variable (data size = 0x{:X})".format(efivar_name,varsz) )
break
AcpiGlobalAddr = struct.unpack_from( AcpiGlobalAddr_fmt, data )[0]
if 0 == AcpiGlobalAddr:
logger().error( "Pointer to ACPI Global Data structure in {} variable is 0".format(efivar_name) )
break
if logger().HAL: logger().log( "[uefi] Pointer to ACPI Global Data structure: 0x{:016X}".format( AcpiGlobalAddr ) )
if logger().HAL: logger().log( "[uefi] Decoding ACPI Global Data structure.." )
AcpiVariableSet = self.helper.read_physical_mem( AcpiGlobalAddr, ACPI_VARIABLE_SET_STRUCT_SIZE )
if logger().HAL:
logger().log('[uefi] AcpiVariableSet structure:')
print_buffer( bytestostring(AcpiVariableSet) )
AcpiVariableSet_fmt = '<6Q'
#if len(AcpiVariableSet) < struct.calcsize(AcpiVariableSet_fmt):
# logger().error( 'Unrecognized format of AcpiVariableSet structure' )
# return (False,0)
AcpiReservedMemoryBase, AcpiReservedMemorySize, S3ReservedLowMemoryBase, AcpiBootScriptTable, RuntimeScriptTableBase, AcpiFacsTable = struct.unpack_from( AcpiVariableSet_fmt, AcpiVariableSet )
if logger().HAL: logger().log( '[uefi] ACPI Boot-Script table base = 0x{:016X}'.format(AcpiBootScriptTable) )
found = True
BootScript_addresses.append( AcpiBootScriptTable )
#break
return (found,BootScript_addresses)
def __str__(self):
return """Header:
Signature : {}
Revision : {}
HeaderSize : 0x{:08X}
CRC32 : 0x{:08X}
Reserved : 0x{:08X}""".format(bytestostring(self.Signature),
EFI_SYSTEM_TABLE_REVISION(self.Revision),
self.HeaderSize, self.CRC32,
self.Reserved)
def __str__(self):
schecksum = ('{:04X}h ({:04X}h) *** checksum mismatch ***'.format(
self.Checksum,
self.CalcSum)) if self.CalcSum != self.Checksum else (
'{:04X}h'.format(self.Checksum))
_s = "\n{}+{:08X}h {}\n{}Type {:02X}h, Attr {:08X}h, State {:02X}h, Size {:06X}h, Checksum {}".format(
self.indent, self.Offset, self.name(), self.indent, self.Type,
self.Attributes, self.State, self.Size, schecksum)
_s += (super(EFI_FILE, self).__str__() + '\n')
return bytestostring(_s)
def get_json_results(json_file):
file_data = chipsec.file.read_file(json_file)
if file_data == 0:
return None
try:
json_data = json.loads(bytestostring(file_data))
except:
logger().error("Unable to load JSON file: {}".format(json_file))
return None
return json_data
def dump_ACPI_table(self, name, isfile=False):
acpi_tables = self.get_parse_ACPI_table(name, isfile)
for acpi_table in acpi_tables:
(table_header, table, table_header_blob, table_blob) = acpi_table
logger().log(
"=================================================================="
)
logger().log("ACPI Table: {}".format(name))
logger().log(
"=================================================================="
)
# print table header
logger().log(table_header)
print_buffer(bytestostring(table_header_blob))
# print table contents
logger().log('')
logger().log(table)
print_buffer(bytestostring(table_blob))
logger().log('')
def __str__(self):
return """
Header (Windows)
----------------
VendorGuid= {{{:08X}-{:04X}-{:04X}-{:4}-{:6}}}
Size = 0x{:08X}
DataOffset= 0x{:08X}
DataSize = 0x{:08X}
Attributes= 0x{:08X}
""".format( self.guid0, self.guid1, self.guid2, bytestostring(codecs.encode(self.guid3[:2],'hex')).upper(), bytestostring(codecs.encode(self.guid3[-6::],'hex')).upper(), self.Size, self.DataOffset, self.DataSize, self.Attributes )
def FvSum16(buffer):
sum16 = 0
buffer = bytestostring(buffer)
blen = len(buffer) // 2
i = 0
while i < blen:
el16 = ord(buffer[2 * i]) | (ord(buffer[2 * i + 1]) << 8)
sum16 = (sum16 + el16) & 0xffff
i = i + 1
return sum16
def mem_read(self):
self.logger.log(
'[CHIPSEC] Reading buffer from memory: PA = 0x{:016X}, len = 0x{:X}..'
.format(self.phys_address, self.buffer_length))
buffer = self.cs.mem.read_physical_mem(self.phys_address,
self.buffer_length)
if self.file_name:
write_file(self.file_name, buffer)
self.logger.log("[CHIPSEC] Written 0x{:X} bytes to '{}'".format(
len(buffer), self.file_name))
else:
print_buffer(bytestostring(buffer))
def kern_get_EFI_variable_full(self, name, guid):
status_dict = { 0:"EFI_SUCCESS", 1:"EFI_LOAD_ERROR", 2:"EFI_INVALID_PARAMETER", 3:"EFI_UNSUPPORTED", 4:"EFI_BAD_BUFFER_SIZE", 5:"EFI_BUFFER_TOO_SMALL", 6:"EFI_NOT_READY", 7:"EFI_DEVICE_ERROR", 8:"EFI_WRITE_PROTECTED", 9:"EFI_OUT_OF_RESOURCES", 14:"EFI_NOT_FOUND", 26:"EFI_SECURITY_VIOLATION" }
off = 0
data = ""
attr = 0
buf = list()
hdr = 0
base = 12
namelen = len(name)
header_size = 52
data_size = header_size + namelen
guid0 = int(guid[:8] , 16)
guid1 = int(guid[9:13], 16)
guid2 = int(guid[14:18], 16)
guid3 = int(guid[19:21], 16)
guid4 = int(guid[21:23], 16)
guid5 = int(guid[24:26], 16)
guid6 = int(guid[26:28], 16)
guid7 = int(guid[28:30], 16)
guid8 = int(guid[30:32], 16)
guid9 = int(guid[32:34], 16)
guid10 = int(guid[34:], 16)
in_buf = struct.pack('13I'+str(namelen)+'s', data_size, guid0, guid1, guid2, guid3, guid4, guid5, guid6, guid7, guid8, guid9, guid10, namelen, name.encode())
buffer = array.array("B", in_buf)
stat = self.ioctl(IOCTL_GET_EFIVAR, buffer)
new_size, status = struct.unpack( "2I", buffer[:8])
if (status == 0x5):
data_size = new_size + header_size + namelen # size sent by driver + size of header (size + guid) + size of name
in_buf = struct.pack('13I'+str(namelen+new_size)+'s', data_size, guid0, guid1, guid2, guid3, guid4, guid5, guid6, guid7, guid8, guid9, guid10, namelen, name.encode())
buffer = array.array("B", in_buf)
try:
stat = self.ioctl(IOCTL_GET_EFIVAR, buffer)
except IOError:
if logger().DEBUG: logger().error("IOError IOCTL GetUEFIvar\n")
return (off, buf, hdr, None, guid, attr)
new_size, status = struct.unpack( "2I", buffer[:8])
if (new_size > data_size):
if logger().DEBUG: logger().error( "Incorrect size returned from driver" )
return (off, buf, hdr, None, guid, attr)
if (status > 0):
if logger().DEBUG: logger().error( "Reading variable (GET_EFIVAR) did not succeed: {}".format(status_dict[status]))
data = ""
guid = 0
attr = 0
else:
data = buffer[base:base+new_size].tostring()
attr = struct.unpack( "I", buffer[8:12])[0]
return (off, buf, hdr, bytestostring(data), guid, attr)
def find_smmc(self, start, end):
chunk_sz = 1024 * 8 #8KB chunks
phys_address = start
found_at = 0
while phys_address <= end:
buffer = self.cs.mem.read_physical_mem(phys_address, chunk_sz)
buffer = bytestostring(buffer)
offset = buffer.find('smmc')
if offset != -1:
found_at = phys_address + offset
break
phys_address += chunk_sz
return found_at
def __str__(self):
schecksum = ('{:04X}h ({:04X}h) *** checksum mismatch ***'.format(
self.Checksum,
self.CalcSum)) if self.CalcSum != self.Checksum else (
'{:04X}h'.format(self.Checksum))
_s = "\n{}{} +{:08X}h {{{}}}: ".format(self.indent,
type(self).__name__,
self.Offset, self.Guid)
_s += "Size {:08X}h, Attr {:08X}h, HdrSize {:04X}h, ExtHdrOffset {:08X}h, Checksum {}".format(
self.Size, self.Attributes, self.HeaderSize, self.ExtHeaderOffset,
schecksum)
_s += super(EFI_FV, self).__str__()
return bytestostring(_s)
def run(self, module_argv):
# Log the start of the test
self.logger.start_test('Current Processor Information:')
self.res = ModuleResult.INFORMATION
# Determine number of threads to check
thread_count = 1
if not self.cs.helper.is_efi():
thread_count = self.cs.msr.get_cpu_thread_count()
for thread in range(thread_count):
# Handle processor binding so we are allways checking processor 0
# for this example. No need to do this in UEFI Shell.
if not self.cs.helper.is_efi():
self.cs.helper.set_affinity(thread)
# Display thread
self.logger.log('[*] Thread {:04d}'.format(thread))
# Get processor brand string
brand = ''
for eax_val in [0x80000002, 0x80000003, 0x80000004]:
regs = self.cs.cpu.cpuid(eax_val, 0)
for i in range(4):
brand += bytestostring(struct.pack('<I', regs[i]))
brand = brand.rstrip('\x00')
self.logger.log('[*] Processor: {}'.format(brand))
# Get processor version information
(eax, ebx, ecx, edx) = self.cs.cpu.cpuid(0x01, 0x00)
stepping = eax & 0xF
model = (eax >> 4) & 0xF
family = (eax >> 8) & 0xF
if family == 0x0F or family == 0x06:
model = ((eax >> 12) & 0xF0) | model
if family == 0x0F:
family = ((eax >> 20) & 0xFF) | family
self.logger.log(
'[*] Family: {:02X} Model: {:02X} Stepping: {:01X}'.
format(family, model, stepping))
# Get microcode revision
microcode_rev = self.cs.read_register_field('IA32_BIOS_SIGN_ID',
'Microcode',
cpu_thread=thread)
self.logger.log(
'[*] Microcode: {:08X}'.format(microcode_rev))
self.logger.log('[*]')
self.logger.log_information_check('Processor information displayed')
return self.res
def mem_search(self):
buffer = self.cs.mem.read_physical_mem(self.phys_address, self.length)
buffer = bytestostring(buffer)
offset = buffer.find(self.value)
if (offset != -1):
self.logger.log(
'[CHIPSEC] Search buffer from memory: PA = 0x{:016X}, len = 0x{:X}, target address= 0x{:X}..'
.format(self.phys_address, self.length,
self.phys_address + offset))
else:
self.logger.log(
'[CHIPSEC] Search buffer from memory: PA = 0x{:016X}, len = 0x{:X}, can not find the target in the searched range..'
.format(self.phys_address, self.length))
def AddElement(self, cmd, args, ret):
try:
margs = '({})'.format(','.join(str(i) for i in args))
except:
margs = str(args)
if isinstance(ret, bytes):
ret = bytestostring(ret)
if str(cmd) in self.data:
if margs in self.data[str(cmd)]:
#using insert opposed to append so that it creates last in first out when using pop command within getElement
self.data[str(cmd)][margs].insert(0, str(ret))
else:
self.data[str(cmd)][margs] = [str(ret)]
else:
self.data[str(cmd)] = {margs: [str(ret)]}
def vmem_read(self):
self.logger.log(
'[CHIPSEC] Reading buffer from memory: VA = 0x{:016X}, len = 0x{:X}.'
.format(self.virt_address, self.size))
try:
buffer = self._vmem.read_virtual_mem(self.virt_address, self.size)
except (TypeError, OSError):
self.logger.error('Error mapping VA to PA.')
return
if self.buf_file:
write_file(self.buf_file, buffer)
self.logger.log("[CHIPSEC] Written 0x{:X} bytes to '{}'".format(
len(buffer), self.buf_file))
else:
print_buffer(bytestostring(buffer))
def _find_RSDP_in_EBDA(self):
rsdp_pa = None
rsdp = None
if logger().HAL: logger().log( "[acpi] searching RSDP in EBDA.." )
ebda_ptr_addr = 0x40E
ebda_addr = struct.unpack('<H', self.cs.mem.read_physical_mem( ebda_ptr_addr, 2 ))[0] << 4
if ebda_addr > 0x400 and ebda_addr < 0xA0000:
membuf = self.cs.mem.read_physical_mem(ebda_addr, 0xA0000 - ebda_addr)
pos = bytestostring(membuf).find( ACPI_RSDP_SIG )
if -1 != pos:
rsdp_pa = ebda_addr + pos
rsdp = self.read_RSDP(rsdp_pa)
if rsdp.is_RSDP_valid():
if logger().HAL: logger().log( "[acpi] found RSDP in EBDA at: 0x{:016X}".format(rsdp_pa) )
else:
rsdp_pa = None
return rsdp, rsdp_pa
def vmem_search(self):
try:
buffer = self._vmem.read_virtual_mem(self.virt_address, self.size)
except (TypeError, OSError):
self.logger.error('Error mapping VA to PA.')
return
buffer = bytestostring(buffer)
offset = buffer.find(self.value)
self.logger.log("[CHIPSEC] Search buffer for '{}':".format(self.value))
self.logger.log(' VA = 0x{:016X}, len = 0x{:X}'.format(
self.virt_address, self.size))
if offset != -1:
self.logger.log(
'[CHIPSEC] Target address = 0x{:X}.'.format(self.virt_address +
offset))
else:
self.logger.log(
'[CHIPSEC] Could not find the target in the searched range.')
def set_EFI_variable( self, name, guid, data, datasize, attrs ):
var = bytes(0) if data is None else data
var_len = len(var) if datasize is None else datasize
if isinstance(attrs, (str, bytes)):
attrs_data = "{message:\x00<{fill}}".format(message=bytestostring(attrs), fill=8)[:8]
attrs = struct.unpack("Q", stringtobytes(attrs_data))[0]
if attrs is None:
if self.SetFirmwareEnvironmentVariable is not None:
if logger().DEBUG: logger().log( "[helper] -> SetFirmwareEnvironmentVariable( name='{}', GUID='{}', length=0x{:X} )..".format(name, "{{{}}}".format(guid), var_len) )
ntsts = self.SetFirmwareEnvironmentVariable( name, "{{{}}}".format(guid), var, var_len )
else:
if self.SetFirmwareEnvironmentVariableEx is not None:
if logger().DEBUG: logger().log( "[helper] -> SetFirmwareEnvironmentVariableEx( name='{}', GUID='{}', length=0x{:X}, attrs=0x{:X} )..".format(name, "{{{}}}".format(guid), var_len, attrs) )
ntsts = self.SetFirmwareEnvironmentVariableEx( name, "{{{}}}".format(guid), var, var_len, attrs )
if 0 != ntsts:
status = 0 # EFI_SUCCESS
else:
status = kernel32.GetLastError()
if logger().DEBUG: logger().error( 'SetFirmwareEnvironmentVariable[Ex] returned error: {}'.format(WinError()) )
#raise WinError(errno.EIO, "Unable to set EFI variable")
return status
def get_string_list(self, raw_data):
ret_val = []
if logger().HAL: logger().log('Getting strings from structure')
raw_data_size = len(raw_data)
header = self.get_header(raw_data)
if header is None:
return None
if header.Length + SMBIOS_STRUCT_TERM_SIZE > raw_data_size:
if logger().HAL:
logger().log('- Data buffer too small for structure')
return None
if header.Length + SMBIOS_STRUCT_TERM_SIZE == raw_data_size:
if logger().HAL: logger().log('+ No strings in this structure')
return ret_val
index = 0
tmp_offset = header.Length
while tmp_offset + index + 1 < raw_data_size:
(value, ) = struct.unpack_from('=B', raw_data[tmp_offset + index:])
if value == 0:
if logger().HAL:
logger().log(
'+ Unpacking string of size {:d}'.format(index))
(string, ) = struct.unpack_from('={:d}s'.format(index),
raw_data[tmp_offset:])
string = bytestostring(string)
if logger().HAL: logger().log('+ Found: {:s}'.format(string))
ret_val.append(string)
tmp_offset += index + 1
index = 0
continue
index += 1
if logger().HAL:
logger().log('+ Found {:d} strings'.format(len(ret_val)))
return ret_val