def mem_writeval(self):
try:
width = get_option_width(self.length) if is_option_valid_width(
self.length) else int(self.length, 16)
except ValueError:
self.logger.error(
"Must specify <length> argument in 'mem writeval' as one of {}"
.format(CMD_OPTS_WIDTH))
return
if width not in (0x1, 0x2, 0x4):
self.logger.error(
"Must specify <length> argument in 'mem writeval' as one of {}"
.format(CMD_OPTS_WIDTH))
return
self.logger.log(
'[CHIPSEC] Writing {:X}-byte value 0x{:X} to PA 0x{:016X}..'.
format(width, self.write_data, self.phys_address))
if 0x1 == width:
self.cs.mem.write_physical_mem_byte(self.phys_address,
self.write_data)
elif 0x2 == width:
self.cs.mem.write_physical_mem_word(self.phys_address,
self.write_data)
elif 0x4 == width:
self.cs.mem.write_physical_mem_dword(self.phys_address,
self.write_data)
def mem_readval(self):
width = 0x4
value = 0x0
if self.length:
try:
width = get_option_width(self.length) if is_option_valid_width(
self.length) else int(self.length, 16)
except ValueError:
self.logger.error("[CHIPSEC] Bad length given '{}'".format(
self.length))
return
if width not in (0x1, 0x2, 0x4):
self.logger.error(
"Must specify <length> argument in 'mem readval' as one of {}".
format(CMD_OPTS_WIDTH))
return
self.logger.log(
'[CHIPSEC] Reading {:X}-byte value from PA 0x{:016X}..'.format(
width, self.phys_address))
if 0x1 == width:
value = self.cs.mem.read_physical_mem_byte(self.phys_address)
elif 0x2 == width:
value = self.cs.mem.read_physical_mem_word(self.phys_address)
elif 0x4 == width:
value = self.cs.mem.read_physical_mem_dword(self.phys_address)
self.logger.log('[CHIPSEC] Value = 0x{:X}'.format(value))
def vmem_writeval(self):
if chipsec_util.is_option_valid_width(self.length):
width = chipsec_util.get_option_width(self.length)
else:
try:
width = int(self.length, 16)
except ValueError:
width = 0
self.logger.log(
'[CHIPSEC] Writing {:X}-byte value 0x{:X} to VA 0x{:016X}..'.
format(width, self.value, self.virt_address))
try:
if 0x1 == width:
self._vmem.write_virtual_mem_byte(self.virt_address,
self.value)
elif 0x2 == width:
self._vmem.write_virtual_mem_word(self.virt_address,
self.value)
elif 0x4 == width:
self._vmem.write_virtual_mem_dword(self.virt_address,
self.value)
else:
self.logger.error(
"Must specify <length> argument in 'mem writeval' as one of {}"
.format(chipsec_util.CMD_OPTS_WIDTH))
except (TypeError, OSError):
self.logger.error('Error mapping VA to PA.')
def vmem_readval(self):
width = 0x4
value = 0x0
if self.length is not None:
if chipsec_util.is_option_valid_width(self.length):
width = chipsec_util.get_option_width(self.length)
else:
try:
width = int(self.length, 16)
except:
width = 0
self.logger.log(
'[CHIPSEC] Reading {:X}-byte value from VA 0x{:016X}.'.format(
width, self.virt_address))
try:
if 0x1 == width:
value = self._vmem.read_virtual_mem_byte(self.virt_address)
elif 0x2 == width:
value = self._vmem.read_virtual_mem_word(self.virt_address)
elif 0x4 == width:
value = self._vmem.read_virtual_mem_dword(self.virt_address)
else:
self.logger.error(
"Must specify <length> argument in 'mem readval' as one of {}"
.format(chipsec_util.CMD_OPTS_WIDTH))
return
except (TypeError, OSError):
self.logger.error('Error mapping VA to PA.')
return
self.logger.log('[CHIPSEC] value = 0x{:X}'.format(value))
class PortIOCommand(BaseCommand):
"""
>>> chipsec_util io list
>>> chipsec_util io <io_port> <width> [value]
Examples:
>>> chipsec_util io list
>>> chipsec_util io 0x61 1
>>> chipsec_util io 0x430 byte 0x0
"""
def requires_driver(self):
# No driver required when printing the util documentation
if len(self.argv) < 3:
return False
return True
def run(self):
if len(self.argv) < 3:
print PortIOCommand.__doc__
return
try:
_iobar = chipsec.hal.iobar.iobar( self.cs )
except chipsec.hal.iobar.IOBARRuntimeError, msg:
print msg
return
op = self.argv[2]
if ( 'list' == op ):
_iobar.list_IO_BARs()
return
t = time.time()
if len(self.argv) < 3:
print PortIOCommand.__doc__
return
io_port = int(self.argv[2],16)
width = 0x1
if len(self.argv) > 3:
width = chipsec_util.get_option_width(self.argv[3]) if chipsec_util.is_option_valid_width(self.argv[3]) else int(self.argv[3],16)
if 5 == len(self.argv):
value = int(self.argv[4], 16)
self.logger.log( "[CHIPSEC] OUT 0x%04X <- 0x%08X (size = 0x%02x)" % (io_port, value, width) )
if 0x1 == width: self.cs.io.write_port_byte( io_port, value )
elif 0x2 == width: self.cs.io.write_port_word( io_port, value )
elif 0x4 == width: self.cs.io.write_port_dword( io_port, value )
else:
if 0x1 == width: value = self.cs.io.read_port_byte( io_port )
elif 0x2 == width: value = self.cs.io.read_port_word( io_port )
elif 0x4 == width: value = self.cs.io.read_port_dword( io_port )
self.logger.log( "[CHIPSEC] IN 0x%04X -> 0x%08X (size = 0x%02x)" % (io_port, value, width) )
self.logger.log( "[CHIPSEC] (io) time elapsed %.3f" % (time.time()-t) )
def pci_write(self):
width = get_option_width(self.size) if is_option_valid_width(self.size) else int(self.size, 16)
if 1 == width: self.cs.pci.write_byte ( self.bus, self.device, self.function, self.offset, self.value )
elif 2 == width: self.cs.pci.write_word ( self.bus, self.device, self.function, self.offset, self.value )
elif 4 == width: self.cs.pci.write_dword( self.bus, self.device, self.function, self.offset, self.value )
else:
self.logger.error( "Width should be one of {}".format(CMD_OPTS_WIDTH) )
return
self.logger.log( "[CHIPSEC] Write 0x{:X} to PCI {:02X}:{:02X}.{:02X} + 0x{:02X}".format(self.value, self.bus, self.device, self.function, self.offset) )
def run(self):
if len(self.argv) < 3:
print(PortIOCommand.__doc__)
return
try:
_iobar = iobar.IOBAR(self.cs)
except iobar.IOBARRuntimeError as msg:
print(msg)
return
op = self.argv[2]
if ('list' == op):
_iobar.list_IO_BARs()
return
t = time.time()
if len(self.argv) < 3:
print(PortIOCommand.__doc__)
return
io_port = int(self.argv[2], 16)
width = 0x1
if len(self.argv) > 3:
width = chipsec_util.get_option_width(
self.argv[3]) if chipsec_util.is_option_valid_width(
self.argv[3]) else int(self.argv[3], 16)
if 5 == len(self.argv):
value = int(self.argv[4], 16)
self.logger.log(
"[CHIPSEC] OUT 0x{:04X} <- 0x{:08X} (size = 0x{:02X})".format(
io_port, value, width))
if 0x1 == width: self.cs.io.write_port_byte(io_port, value)
elif 0x2 == width: self.cs.io.write_port_word(io_port, value)
elif 0x4 == width: self.cs.io.write_port_dword(io_port, value)
else:
self.logger.log(
"Invalid write size requested. 1,2,4 supported")
return
else:
if 0x1 == width: value = self.cs.io.read_port_byte(io_port)
elif 0x2 == width: value = self.cs.io.read_port_word(io_port)
elif 0x4 == width: value = self.cs.io.read_port_dword(io_port)
else:
self.logger.log("Invalid read size requested. 1,2,4 supported")
return
self.logger.log(
"[CHIPSEC] IN 0x{:04X} -> 0x{:08X} (size = 0x{:02X})".format(
io_port, value, width))
self.logger.log(
"[CHIPSEC] (io) time elapsed {:.3f}".format(time.time() - t))
def pci_read(self):
width = 4
if self.size is not None:
width = get_option_width(self.size) if is_option_valid_width(self.size) else int(self.size, 16)
if 1 == width: pci_value = self.cs.pci.read_byte (self.bus, self.device, self.function, self.offset)
elif 2 == width: pci_value = self.cs.pci.read_word (self.bus, self.device, self.function, self.offset)
elif 4 == width: pci_value = self.cs.pci.read_dword(self.bus, self.device, self.function, self.offset)
else:
self.logger.error( "Width should be one of {}".format(CMD_OPTS_WIDTH) )
return
self.logger.log( "[CHIPSEC] PCI {:02X}:{:02X}.{:02X} + 0x{:02X}: 0x{:X}".format(self.bus, self.device, self.function, self.offset, pci_value) )
class MemCommand(BaseCommand):
"""
>>> chipsec_util mem <op> <physical_address> <length> [value|buffer_file]
>>>
>>> <physical_address> : 64-bit physical address
>>> <op> : read|readval|write|writeval|allocate|pagedump
>>> <length> : byte|word|dword or length of the buffer from <buffer_file>
>>> <value> : byte, word or dword value to be written to memory at <physical_address>
>>> <buffer_file> : file with the contents to be written to memory at <physical_address>
Examples:
>>> chipsec_util mem <op> <physical_address> <length> [value|file]
>>> chipsec_util mem readval 0xFED40000 dword
>>> chipsec_util mem read 0x41E 0x20 buffer.bin
>>> chipsec_util mem writeval 0xA0000 dword 0x9090CCCC
>>> chipsec_util mem write 0x100000000 0x1000 buffer.bin
>>> chipsec_util mem write 0x100000000 0x10 000102030405060708090A0B0C0D0E0F
>>> chipsec_util mem allocate 0x1000
>>> chipsec_util mem pagedump 0xFED00000 0x100000
"""
def requires_driver(self):
# No driver required when printing the util documentation
if len(self.argv) < 3:
return False
return True
def run(self):
size = 0x100
if len(self.argv) < 3:
print MemCommand.__doc__
return
op = self.argv[2]
t = time.time()
if 'allocate' == op and 4 == len(self.argv):
size = int(self.argv[3], 16)
(va, pa) = self.cs.mem.alloc_physical_mem(size)
self.logger.log(
'[CHIPSEC] Allocated %X bytes of physical memory: VA = 0x%016X, PA = 0x%016X'
% (size, va, pa))
elif 'pagedump' == op and len(self.argv) > 3:
start = long(self.argv[3], 16)
length = long(
self.argv[4],
16) if len(self.argv) > 4 else chipsec.defines.BOUNDARY_4KB
end = start + length
dump_region_to_path(chipsec.file.get_main_dir(), start, end)
elif 'read' == op:
phys_address = int(self.argv[3], 16)
size = int(self.argv[4], 16) if len(self.argv) > 4 else 0x100
self.logger.log(
'[CHIPSEC] reading buffer from memory: PA = 0x%016X, len = 0x%X..'
% (phys_address, size))
buffer = self.cs.mem.read_physical_mem(phys_address, size)
if len(self.argv) > 5:
buf_file = self.argv[5]
chipsec.file.write_file(buf_file, buffer)
self.logger.log("[CHIPSEC] written 0x%X bytes to '%s'" %
(len(buffer), buf_file))
else:
print_buffer(buffer)
elif 'readval' == op:
phys_address = int(self.argv[3], 16)
width = 0x4
if len(self.argv) > 4:
width = chipsec_util.get_option_width(
self.argv[4]) if chipsec_util.is_option_valid_width(
self.argv[4]) else int(self.argv[4], 16)
self.logger.log(
'[CHIPSEC] reading %X-byte value from PA 0x%016X..' %
(width, phys_address))
if 0x1 == width:
value = self.cs.mem.read_physical_mem_byte(phys_address)
elif 0x2 == width:
value = self.cs.mem.read_physical_mem_word(phys_address)
elif 0x4 == width:
value = self.cs.mem.read_physical_mem_dword(phys_address)
self.logger.log('[CHIPSEC] value = 0x%X' % value)
elif 'write' == op:
phys_address = int(self.argv[3], 16)
if len(self.argv) > 4:
size = int(self.argv[4], 16)
else:
self.logger.error(
"must specify <length> argument in 'mem write'")
return
if len(self.argv) > 5:
buf_file = self.argv[5]
if not os.path.exists(buf_file):
#buffer = buf_file.decode('hex')
try:
buffer = bytearray.fromhex(buf_file)
except ValueError, e:
self.logger.error("incorrect <value> specified: '%s'" %
buf_file)
self.logger.error(str(e))
return
self.logger.log(
"[CHIPSEC] read 0x%X hex bytes from command-line: %s'"
% (len(buffer), buf_file))
else:
buffer = chipsec.file.read_file(buf_file)
self.logger.log(
"[CHIPSEC] read 0x%X bytes from file '%s'" %
(len(buffer), buf_file))
if len(buffer) < size:
self.logger.error(
"number of bytes read (0x%X) is less than the specified <length> (0x%X)"
% (len(buffer), size))
return
self.logger.log(
'[CHIPSEC] writing buffer to memory: PA = 0x%016X, len = 0x%X..'
% (phys_address, size))
self.cs.mem.write_physical_mem(phys_address, size, buffer)
else:
self.logger.error(
"must specify <buffer>|<file> argument in 'mem write'")
return
elif 'writeval' == op:
phys_address = int(self.argv[3], 16)
if len(self.argv) > 4:
width = chipsec_util.get_option_width(
self.argv[4]) if chipsec_util.is_option_valid_width(
self.argv[4]) else int(self.argv[4], 16)
else:
self.logger.error(
"must specify <length> argument in 'mem writeval' as one of %s"
% chipsec_util.CMD_OPTS_WIDTH)
return
if len(self.argv) > 5:
value = int(self.argv[5], 16)
else:
self.logger.error(
"must specify <value> argument in 'mem writeval'")
return
self.logger.log(
'[CHIPSEC] writing %X-byte value 0x%X to PA 0x%016X..' %
(width, value, phys_address))
if 0x1 == width:
self.cs.mem.write_physical_mem_byte(phys_address, value)
elif 0x2 == width:
self.cs.mem.write_physical_mem_word(phys_address, value)
elif 0x4 == width:
self.cs.mem.write_physical_mem_dword(phys_address, value)
def run(self):
size = 0x100
if len(self.argv) < 3:
print MemCommand.__doc__
return
op = self.argv[2]
t = time.time()
if 'allocate' == op and 4 == len(self.argv):
size = int(self.argv[3], 16)
(va, pa) = self.cs.mem.alloc_physical_mem(size)
self.logger.log(
'[CHIPSEC] Allocated %X bytes of physical memory: VA = 0x%016X, PA = 0x%016X'
% (size, va, pa))
elif 'pagedump' == op and len(self.argv) > 3:
start = long(self.argv[3], 16)
length = long(
self.argv[4],
16) if len(self.argv) > 4 else chipsec.defines.BOUNDARY_4KB
end = start + length
dump_region_to_path(chipsec.file.get_main_dir(), start, end)
elif 'read' == op:
phys_address = int(self.argv[3], 16)
size = int(self.argv[4], 16) if len(self.argv) > 4 else 0x100
self.logger.log(
'[CHIPSEC] reading buffer from memory: PA = 0x%016X, len = 0x%X..'
% (phys_address, size))
buffer = self.cs.mem.read_physical_mem(phys_address, size)
if len(self.argv) > 5:
buf_file = self.argv[5]
chipsec.file.write_file(buf_file, buffer)
self.logger.log("[CHIPSEC] written 0x%X bytes to '%s'" %
(len(buffer), buf_file))
else:
print_buffer(buffer)
elif 'readval' == op:
phys_address = int(self.argv[3], 16)
width = 0x4
if len(self.argv) > 4:
width = chipsec_util.get_option_width(
self.argv[4]) if chipsec_util.is_option_valid_width(
self.argv[4]) else int(self.argv[4], 16)
self.logger.log(
'[CHIPSEC] reading %X-byte value from PA 0x%016X..' %
(width, phys_address))
if 0x1 == width:
value = self.cs.mem.read_physical_mem_byte(phys_address)
elif 0x2 == width:
value = self.cs.mem.read_physical_mem_word(phys_address)
elif 0x4 == width:
value = self.cs.mem.read_physical_mem_dword(phys_address)
self.logger.log('[CHIPSEC] value = 0x%X' % value)
elif 'write' == op:
phys_address = int(self.argv[3], 16)
if len(self.argv) > 4:
size = int(self.argv[4], 16)
else:
self.logger.error(
"must specify <length> argument in 'mem write'")
return
if len(self.argv) > 5:
buf_file = self.argv[5]
if not os.path.exists(buf_file):
#buffer = buf_file.decode('hex')
try:
buffer = bytearray.fromhex(buf_file)
except ValueError, e:
self.logger.error("incorrect <value> specified: '%s'" %
buf_file)
self.logger.error(str(e))
return
self.logger.log(
"[CHIPSEC] read 0x%X hex bytes from command-line: %s'"
% (len(buffer), buf_file))
else:
buffer = chipsec.file.read_file(buf_file)
self.logger.log(
"[CHIPSEC] read 0x%X bytes from file '%s'" %
(len(buffer), buf_file))
if len(buffer) < size:
self.logger.error(
"number of bytes read (0x%X) is less than the specified <length> (0x%X)"
% (len(buffer), size))
return
self.logger.log(
'[CHIPSEC] writing buffer to memory: PA = 0x%016X, len = 0x%X..'
% (phys_address, size))
self.cs.mem.write_physical_mem(phys_address, size, buffer)
else:
self.logger.error(
"must specify <buffer>|<file> argument in 'mem write'")
return
def run(self):
if len(self.argv) < 3:
print PCICommand.__doc__
return
op = self.argv[2]
t = time.time()
if ( 'enumerate' == op ):
self.logger.log( "[CHIPSEC] Enumerating available PCIe devices.." )
print_pci_devices( self.cs.pci.enumerate_devices() )
self.logger.log( "[CHIPSEC] (pci) time elapsed %.3f" % (time.time()-t) )
return
elif ( 'dump' == op ):
if len(self.argv) == 3:
self.logger.log( "[CHIPSEC] dumping configuration of available PCI devices.." )
self.cs.pci.print_pci_config_all()
elif len(self.argv) > 5:
bus = int(self.argv[3],16)
device = int(self.argv[4],16)
function = int(self.argv[5],16)
self.logger.log( "[CHIPSEC] PCI device %02X:%02X.%02X configuration:" % (bus,device,function) )
cfg_buf = self.cs.pci.dump_pci_config( bus, device, function )
pretty_print_hex_buffer( cfg_buf )
else:
print PCICommand.__doc__
return
elif ( 'xrom' == op ):
if len(self.argv) < 5:
self.logger.log( "[CHIPSEC] enumerating PCI expansion ROMs.." )
xrom_addr = int(self.argv[3],16) if len(self.argv) == 4 else None
_xroms = self.cs.pci.enumerate_xroms( True, True, xrom_addr )
self.logger.log( "[CHIPSEC] found %d PCI expansion ROMs" % len(_xroms) )
if len(_xroms) > 0: print_pci_XROMs( _xroms )
elif len(self.argv) > 5:
bus = int(self.argv[3],16)
device = int(self.argv[4],16)
function = int(self.argv[5],16)
xrom_addr = int(self.argv[6],16) if len(self.argv) > 6 else None
self.logger.log( "[CHIPSEC] locating PCI expansion ROM (XROM) of %02X:%02X.%02X..." % (bus,device,function) )
exists,xrom = self.cs.pci.find_XROM( bus, device, function, True, True, xrom_addr )
if exists:
self.logger.log( "[CHIPSEC] found XROM of %02X:%02X.%02X" % (bus,device,function) )
if xrom is not None:
self.logger.log( "[CHIPSEC] XROM enabled = %d, base = 0x%08X, size = 0x%08X" % (xrom.en,xrom.base,xrom.size) )
if xrom.header is not None: self.logger.log( "[CHIPSEC] XROM header: %s" % xrom.header )
else:
self.logger.log( "[CHIPSEC] coudn't find XROM of %02X:%02X.%02X" % (bus,device,function) )
else:
print PCICommand.__doc__
return
else:
if len(self.argv) < 6:
print PCICommand.__doc__
return
bus = int(self.argv[2],16)
device = int(self.argv[3],16)
function = int(self.argv[4],16)
offset = int(self.argv[5],16)
width = 4
if len(self.argv) > 6:
width = chipsec_util.get_option_width(self.argv[6]) if chipsec_util.is_option_valid_width(self.argv[6]) else int(self.argv[6],16)
if 8 == len(self.argv):
value = int(self.argv[7], 16)
self.logger.log( "[CHIPSEC] write 0x%X to PCI %02X:%02X.%02X + 0x%02X" % (value, bus, device, function, offset) )
if 1 == width: self.cs.pci.write_byte ( bus, device, function, offset, value )
elif 2 == width: self.cs.pci.write_word ( bus, device, function, offset, value )
elif 4 == width: self.cs.pci.write_dword( bus, device, function, offset, value )
else: self.logger.error( "width should be one of %s" % chipsec_util.CMD_OPTS_WIDTH )
else:
if 1 == width: pci_value = self.cs.pci.read_byte (bus, device, function, offset)
elif 2 == width: pci_value = self.cs.pci.read_word (bus, device, function, offset)
elif 4 == width: pci_value = self.cs.pci.read_dword(bus, device, function, offset)
else:
self.logger.error( "width should be one of %s" % chipsec_util.CMD_OPTS_WIDTH )
return
self.logger.log( "[CHIPSEC] PCI %02X:%02X.%02X + 0x%02X: 0x%X" % (bus, device, function, offset, pci_value) )
self.logger.log( "[CHIPSEC] (pci) time elapsed %.3f" % (time.time()-t) )
def run(self):
if len(self.argv) < 3:
print PCICommand.__doc__
return
op = self.argv[2]
t = time.time()
if ('enumerate' == op):
self.logger.log("[CHIPSEC] Enumerating available PCIe devices..")
print_pci_devices(self.cs.pci.enumerate_devices())
self.logger.log("[CHIPSEC] (pci) time elapsed %.3f" %
(time.time() - t))
return
elif ('dump' == op):
if len(self.argv) == 3:
self.logger.log(
"[CHIPSEC] dumping configuration of available PCI devices.."
)
self.cs.pci.print_pci_config_all()
elif len(self.argv) > 5:
bus = int(self.argv[3], 16)
device = int(self.argv[4], 16)
function = int(self.argv[5], 16)
self.logger.log(
"[CHIPSEC] PCI device %02X:%02X.%02X configuration:" %
(bus, device, function))
cfg_buf = self.cs.pci.dump_pci_config(bus, device, function)
pretty_print_hex_buffer(cfg_buf)
else:
print PCICommand.__doc__
return
elif ('xrom' == op):
if len(self.argv) < 5:
self.logger.log("[CHIPSEC] enumerating PCI expansion ROMs..")
xrom_addr = int(self.argv[3], 16) if len(
self.argv) == 4 else None
_xroms = self.cs.pci.enumerate_xroms(True, True, xrom_addr)
self.logger.log("[CHIPSEC] found %d PCI expansion ROMs" %
len(_xroms))
if len(_xroms) > 0: print_pci_XROMs(_xroms)
elif len(self.argv) > 5:
bus = int(self.argv[3], 16)
device = int(self.argv[4], 16)
function = int(self.argv[5], 16)
xrom_addr = int(self.argv[6],
16) if len(self.argv) > 6 else None
self.logger.log(
"[CHIPSEC] locating PCI expansion ROM (XROM) of %02X:%02X.%02X..."
% (bus, device, function))
exists, xrom = self.cs.pci.find_XROM(bus, device, function,
True, True, xrom_addr)
if exists:
self.logger.log("[CHIPSEC] found XROM of %02X:%02X.%02X" %
(bus, device, function))
if xrom is not None:
self.logger.log(
"[CHIPSEC] XROM enabled = %d, base = 0x%08X, size = 0x%08X"
% (xrom.en, xrom.base, xrom.size))
if xrom.header is not None:
self.logger.log("[CHIPSEC] XROM header: %s" %
xrom.header)
else:
self.logger.log(
"[CHIPSEC] coudn't find XROM of %02X:%02X.%02X" %
(bus, device, function))
else:
print PCICommand.__doc__
return
elif ('cmd' == op):
cmd_mask = 0xFFFF
pci_class = None
pci_sub_class = None
if len(self.argv) >= 4:
cmd_mask = int(self.argv[3], 16)
if len(self.argv) >= 5:
pci_class = int(self.argv[4], 16)
if len(self.argv) >= 6:
pci_sub_class = int(self.argv[5], 16)
self.logger.log('BDF | VID:DID | CMD | CLS | Sub CLS')
self.logger.log('------------------------------------------')
for (b, d, f, vid, did) in self.cs.pci.enumerate_devices():
dev_cls = self.cs.pci.read_byte(b, d, f, PCI_HDR_CLS_OFF)
if pci_class is not None and (dev_cls != pci_class):
continue
dev_sub_cls = self.cs.pci.read_byte(b, d, f,
PCI_HDR_SUB_CLS_OFF)
if pci_sub_class is not None and (dev_sub_cls !=
pci_sub_class):
continue
cmd_reg = self.cs.pci.read_word(b, d, f, PCI_HDR_CMD_OFF)
if (cmd_reg & cmd_mask) == 0:
continue
self.logger.log(
'{:02X}:{:02X}.{:X} | {:04X}:{:04X} | {:04X} | {:02X} | {:02X}'
.format(b, d, f, vid, did, cmd_reg, dev_cls, dev_sub_cls))
else:
if len(self.argv) < 6:
print PCICommand.__doc__
return
bus = int(self.argv[2], 16)
device = int(self.argv[3], 16)
function = int(self.argv[4], 16)
offset = int(self.argv[5], 16)
width = 4
if len(self.argv) > 6:
width = chipsec_util.get_option_width(
self.argv[6]) if chipsec_util.is_option_valid_width(
self.argv[6]) else int(self.argv[6], 16)
if 8 == len(self.argv):
value = int(self.argv[7], 16)
self.logger.log(
"[CHIPSEC] write 0x%X to PCI %02X:%02X.%02X + 0x%02X" %
(value, bus, device, function, offset))
if 1 == width:
self.cs.pci.write_byte(bus, device, function, offset,
value)
elif 2 == width:
self.cs.pci.write_word(bus, device, function, offset,
value)
elif 4 == width:
self.cs.pci.write_dword(bus, device, function, offset,
value)
else:
self.logger.error("width should be one of %s" %
chipsec_util.CMD_OPTS_WIDTH)
else:
if 1 == width:
pci_value = self.cs.pci.read_byte(bus, device, function,
offset)
elif 2 == width:
pci_value = self.cs.pci.read_word(bus, device, function,
offset)
elif 4 == width:
pci_value = self.cs.pci.read_dword(bus, device, function,
offset)
else:
self.logger.error("width should be one of %s" %
chipsec_util.CMD_OPTS_WIDTH)
return
self.logger.log("[CHIPSEC] PCI %02X:%02X.%02X + 0x%02X: 0x%X" %
(bus, device, function, offset, pci_value))
self.logger.log("[CHIPSEC] (pci) time elapsed %.3f" %
(time.time() - t))
def run(self):
if len(self.argv) < 3:
print PCICommand.__doc__
return
op = self.argv[2]
t = time.time()
if ('enumerate' == op):
self.logger.log("[CHIPSEC] Enumerating available PCIe devices..")
print_pci_devices(self.cs.pci.enumerate_devices())
self.logger.log("[CHIPSEC] (pci) time elapsed %.3f" %
(time.time() - t))
return
elif ('dump' == op):
if len(self.argv) == 3:
self.logger.log(
"[CHIPSEC] dumping configuration of available PCI devices.."
)
self.cs.pci.print_pci_config_all()
elif len(self.argv) > 5:
bus = int(self.argv[3], 16)
device = int(self.argv[4], 16)
function = int(self.argv[5], 16)
self.logger.log(
"[CHIPSEC] PCI device %02X:%02X.%02X configuration:" %
(bus, device, function))
cfg_buf = self.cs.pci.dump_pci_config(bus, device, function)
pretty_print_hex_buffer(cfg_buf)
else:
print PCICommand.__doc__
return
elif ('xrom' == op):
if len(self.argv) < 5:
self.logger.log("[CHIPSEC] enumerating PCI expansion ROMs..")
xrom_addr = int(self.argv[3], 16) if len(
self.argv) == 4 else None
_xroms = self.cs.pci.enumerate_xroms(True, True, xrom_addr)
self.logger.log("[CHIPSEC] found %d PCI expansion ROMs" %
len(_xroms))
if len(_xroms) > 0: print_pci_XROMs(_xroms)
elif len(self.argv) > 5:
bus = int(self.argv[3], 16)
device = int(self.argv[4], 16)
function = int(self.argv[5], 16)
xrom_addr = int(self.argv[6],
16) if len(self.argv) > 6 else None
self.logger.log(
"[CHIPSEC] locating PCI expansion ROM (XROM) of %02X:%02X.%02X..."
% (bus, device, function))
exists, xrom = self.cs.pci.find_XROM(bus, device, function,
True, True, xrom_addr)
if exists:
self.logger.log("[CHIPSEC] found XROM of %02X:%02X.%02X" %
(bus, device, function))
if xrom is not None:
self.logger.log(
"[CHIPSEC] XROM enabled = %d, base = 0x%08X, size = 0x%08X"
% (xrom.en, xrom.base, xrom.size))
if xrom.header is not None:
self.logger.log("[CHIPSEC] XROM header: %s" %
xrom.header)
else:
self.logger.log(
"[CHIPSEC] coudn't find XROM of %02X:%02X.%02X" %
(bus, device, function))
else:
print PCICommand.__doc__
return
else:
if len(self.argv) < 6:
print PCICommand.__doc__
return
bus = int(self.argv[2], 16)
device = int(self.argv[3], 16)
function = int(self.argv[4], 16)
offset = int(self.argv[5], 16)
width = 4
if len(self.argv) > 6:
width = chipsec_util.get_option_width(
self.argv[6]) if chipsec_util.is_option_valid_width(
self.argv[6]) else int(self.argv[6], 16)
if 8 == len(self.argv):
value = int(self.argv[7], 16)
self.logger.log(
"[CHIPSEC] write 0x%X to PCI %02X:%02X.%02X + 0x%02X" %
(value, bus, device, function, offset))
if 1 == width:
self.cs.pci.write_byte(bus, device, function, offset,
value)
elif 2 == width:
self.cs.pci.write_word(bus, device, function, offset,
value)
elif 4 == width:
self.cs.pci.write_dword(bus, device, function, offset,
value)
else:
self.logger.error("width should be one of %s" %
chipsec_util.CMD_OPTS_WIDTH)
else:
if 1 == width:
pci_value = self.cs.pci.read_byte(bus, device, function,
offset)
elif 2 == width:
pci_value = self.cs.pci.read_word(bus, device, function,
offset)
elif 4 == width:
pci_value = self.cs.pci.read_dword(bus, device, function,
offset)
else:
self.logger.error("width should be one of %s" %
chipsec_util.CMD_OPTS_WIDTH)
return
self.logger.log("[CHIPSEC] PCI %02X:%02X.%02X + 0x%02X: 0x%X" %
(bus, device, function, offset, pci_value))
self.logger.log("[CHIPSEC] (pci) time elapsed %.3f" %
(time.time() - t))
def run(self):
size = 0x100
if len(self.argv) < 3:
print MemCommand.__doc__
return
op = self.argv[2]
t = time.time()
if 'allocate' == op and 4 == len(self.argv):
size = int(self.argv[3],16)
(va, pa) = self.cs.mem.alloc_physical_mem( size )
self.logger.log( '[CHIPSEC] Allocated %X bytes of physical memory: VA = 0x%016X, PA = 0x%016X' % (size, va, pa) )
elif 'pagedump' == op and len(self.argv) > 3:
start = long(self.argv[3],16)
length = long(self.argv[4],16) if len(self.argv) > 4 else chipsec.defines.BOUNDARY_4KB
end = start + length
dump_region_to_path( chipsec.file.get_main_dir(), start, end )
elif 'read' == op:
phys_address = int(self.argv[3],16)
size = int(self.argv[4],16) if len(self.argv) > 4 else 0x100
self.logger.log( '[CHIPSEC] reading buffer from memory: PA = 0x%016X, len = 0x%X..' % (phys_address, size) )
buffer = self.cs.mem.read_physical_mem( phys_address, size )
if len(self.argv) > 5:
buf_file = self.argv[5]
chipsec.file.write_file( buf_file, buffer )
self.logger.log( "[CHIPSEC] written 0x%X bytes to '%s'" % (len(buffer), buf_file) )
else:
print_buffer( buffer )
elif 'readval' == op:
phys_address = int(self.argv[3],16)
width = 0x4
if len(self.argv) > 4:
width = chipsec_util.get_option_width(self.argv[4]) if chipsec_util.is_option_valid_width(self.argv[4]) else int(self.argv[4],16)
self.logger.log( '[CHIPSEC] reading %X-byte value from PA 0x%016X..' % (width, phys_address) )
if 0x1 == width: value = self.cs.mem.read_physical_mem_byte ( phys_address )
elif 0x2 == width: value = self.cs.mem.read_physical_mem_word ( phys_address )
elif 0x4 == width: value = self.cs.mem.read_physical_mem_dword( phys_address )
self.logger.log( '[CHIPSEC] value = 0x%X' % value )
elif 'write' == op:
phys_address = int(self.argv[3],16)
if len(self.argv) > 4:
size = int(self.argv[4],16)
else:
self.logger.error( "must specify <length> argument in 'mem write'" )
return
if len(self.argv) > 5:
buf_file = self.argv[5]
if not os.path.exists( buf_file ):
#buffer = buf_file.decode('hex')
try:
buffer = bytearray.fromhex(buf_file)
except ValueError, e:
self.logger.error( "incorrect <value> specified: '%s'" % buf_file )
self.logger.error( str(e) )
return
self.logger.log( "[CHIPSEC] read 0x%X hex bytes from command-line: %s'" % (len(buffer), buf_file) )
else:
buffer = chipsec.file.read_file( buf_file )
self.logger.log( "[CHIPSEC] read 0x%X bytes from file '%s'" % (len(buffer), buf_file) )
if len(buffer) < size:
self.logger.error( "number of bytes read (0x%X) is less than the specified <length> (0x%X)" % (len(buffer),size) )
return
self.logger.log( '[CHIPSEC] writing buffer to memory: PA = 0x%016X, len = 0x%X..' % (phys_address, size) )
self.cs.mem.write_physical_mem( phys_address, size, buffer )
else:
self.logger.error( "must specify <buffer>|<file> argument in 'mem write'" )
return
def mem(argv):
"""
>>> chipsec_util mem <op> <physical_address> <length> [value|buffer_file]
>>>
>>> <physical_address> : 64-bit physical address
>>> <op> : read|readval|write|writeval|allocate
>>> <length> : byte|word|dword or length of the buffer from <buffer_file>
>>> <value> : byte, word or dword value to be written to memory at <physical_address>
>>> <buffer_file> : file with the contents to be written to memory at <physical_address>
Examples:
>>> chipsec_util mem <op> <physical_address> <length> [value|file]
>>> chipsec_util mem readval 0xFED40000 dword
>>> chipsec_util mem read 0x41E 0x20 buffer.bin
>>> chipsec_util mem writeval 0xA0000 dword 0x9090CCCC
>>> chipsec_util mem write 0x100000000 0x1000 buffer.bin
>>> chipsec_util mem write 0x100000000 0x10 000102030405060708090A0B0C0D0E0F
>>> chipsec_util mem allocate 0x1000
"""
phys_address = 0
size = 0x100
if 3 > len(argv):
print mem.__doc__
return
op = argv[2]
t = time.time()
if 'allocate' == op and 4 == len(argv):
size = int(argv[3],16)
(va, pa) = chipsec_util._cs.mem.alloc_physical_mem( size )
logger().log( '[CHIPSEC] Allocated %X bytes of physical memory: VA = 0x%016X, PA = 0x%016X' % (size, va, pa) )
elif 'read' == op:
phys_address = int(argv[3],16)
size = int(argv[4],16) if len(argv) > 4 else 0x100
logger().log( '[CHIPSEC] reading buffer from memory: PA = 0x%016X, len = 0x%X..' % (phys_address, size) )
buffer = chipsec_util._cs.mem.read_physical_mem( phys_address, size )
if len(argv) > 5:
buf_file = argv[5]
chipsec.file.write_file( buf_file, buffer )
logger().log( "[CHIPSEC] written 0x%X bytes to '%s'" % (len(buffer), buf_file) )
else:
print_buffer( buffer )
elif 'readval' == op:
phys_address = int(argv[3],16)
width = 0x4
if len(argv) > 4:
width = chipsec_util.get_option_width(argv[4]) if chipsec_util.is_option_valid_width(argv[4]) else int(argv[4],16)
logger().log( '[CHIPSEC] reading value from memory: PA = 0x%016X, width = 0x%X..' % (phys_address, size) )
if 0x1 == width: value = chipsec_util._cs.mem.read_physical_mem_byte ( phys_address )
elif 0x2 == width: value = chipsec_util._cs.mem.read_physical_mem_word ( phys_address )
elif 0x4 == width: value = chipsec_util._cs.mem.read_physical_mem_dword( phys_address )
logger().log( '[CHIPSEC] value = 0x%X' % value )
elif 'write' == op:
phys_address = int(argv[3],16)
if len(argv) > 4:
size = int(argv[4],16)
else:
logger().error( "must specify <length> argument in 'mem write'" )
return
if len(argv) > 5:
buf_file = argv[5]
if not os.path.exists( buf_file ):
#buffer = buf_file.decode('hex')
try:
buffer = bytearray.fromhex(buf_file)
except ValueError, e:
logger().error( "incorrect <value> specified: '%s'" % buf_file )
logger().error( str(e) )
return
logger().log( "[CHIPSEC] read 0x%X hex bytes from command-line: %s'" % (len(buffer), buf_file) )
else:
buffer = chipsec.file.read_file( buf_file )
logger().log( "[CHIPSEC] read 0x%X bytes from file '%s'" % (len(buffer), buf_file) )
if len(buffer) < size:
logger().error( "number of bytes read (0x%X) is less than the specified <length> (0x%X)" % (len(buffer),size) )
return
logger().log( '[CHIPSEC] writing buffer to memory: PA = 0x%016X, len = 0x%X..' % (phys_address, size) )
chipsec_util._cs.mem.write_physical_mem( phys_address, size, buffer )
else:
logger().error( "must specify <buffer>|<file> argument in 'mem write'" )
return
op = argv[2]
if ( 'list' == op ):
_iobar.list_IO_BARs()
return
t = time.time()
if len(argv) < 3:
print port_io.__doc__
return
io_port = int(argv[2],16)
width = 0x1
if len(argv) > 3:
width = chipsec_util.get_option_width(argv[3]) if chipsec_util.is_option_valid_width(argv[3]) else int(argv[3],16)
if 5 == len(argv):
value = int(argv[4], 16)
logger().log( "[CHIPSEC] OUT 0x%04X <- 0x%08X (size = 0x%02x)" % (io_port, value, width) )
if 0x1 == width: chipsec_util._cs.io.write_port_byte( io_port, value )
elif 0x2 == width: chipsec_util._cs.io.write_port_word( io_port, value )
elif 0x4 == width: chipsec_util._cs.io.write_port_dword( io_port, value )
else:
if 0x1 == width: value = chipsec_util._cs.io.read_port_byte( io_port )
elif 0x2 == width: value = chipsec_util._cs.io.read_port_word( io_port )
elif 0x4 == width: value = chipsec_util._cs.io.read_port_dword( io_port )
logger().log( "[CHIPSEC] IN 0x%04X -> 0x%08X (size = 0x%02x)" % (io_port, value, width) )
logger().log( "[CHIPSEC] (io) time elapsed %.3f" % (time.time()-t) )
def run(self):
try:
_vmem = virtmem.VirtMemory(self.cs)
except:
return
size = 0x100
if len(self.argv) < 3:
print (VMemCommand.__doc__)
return
op = self.argv[2]
if 'allocate' == op and 4 == len(self.argv):
size = int(self.argv[3],16)
(va, pa) = _vmem.alloc_virtual_mem( size )
self.logger.log( '[CHIPSEC] Allocated {:X} bytes of virtual memory: VA = 0x{:016X}, PA = 0x{:016X}'.format(size, va, pa) )
elif 'search' == op and len(self.argv) > 5:
virt_address = int(self.argv[3],16)
size = int(self.argv[4],16)
buffer = _vmem.read_virtual_mem( virt_address, size )
buffer = chipsec.defines.bytestostring(buffer)
offset = buffer.find(self.argv[5])
if offset != -1:
self.logger.log( '[CHIPSEC] search buffer from memory: VA = 0x{:016X}, len = 0x{:X}, target address= 0x{:X}..'.format(virt_address, size, virt_address + offset) )
else:
self.logger.log( '[CHIPSEC] search buffer from memory: VA = 0x{:016X}, len = 0x{:X}, can not find the target in the searched range..'.format(virt_address, size) )
elif 'read' == op:
virt_address = int(self.argv[3],16)
size = int(self.argv[4],16) if len(self.argv) > 4 else 0x100
self.logger.log( '[CHIPSEC] reading buffer from memory: VA = 0x{:016X}, len = 0x{:X}..'.format(virt_address, size) )
buffer = _vmem.read_virtual_mem( virt_address, size )
if len(self.argv) > 5:
buf_file = self.argv[5]
chipsec.file.write_file( buf_file, buffer )
self.logger.log( "[CHIPSEC] written 0x{:X} bytes to '{}'".format(len(buffer), buf_file) )
else:
print_buffer( chipsec.defines.bytestostring(buffer) )
elif 'readval' == op:
virt_address = int(self.argv[3],16)
width = 0x4
if len(self.argv) > 4:
width = chipsec_util.get_option_width(self.argv[4]) if chipsec_util.is_option_valid_width(self.argv[4]) else int(self.argv[4],16)
self.logger.log( '[CHIPSEC] reading {:X}-byte value from VA 0x{:016X}..'.format(width, virt_address) )
if 0x1 == width: value = _vmem.read_virtual_mem_byte ( virt_address )
elif 0x2 == width: value = _vmem.read_virtual_mem_word ( virt_address )
elif 0x4 == width: value = _vmem.read_virtual_mem_dword( virt_address )
self.logger.log( '[CHIPSEC] value = 0x{:X}'.format(value) )
elif 'write' == op:
virt_address = int(self.argv[3],16)
if len(self.argv) > 4:
size = int(self.argv[4],16)
else:
self.logger.error( "must specify <length> argument in 'mem write'" )
return
if len(self.argv) > 5:
buf_file = self.argv[5]
if not os.path.exists( buf_file ):
#buffer = buf_file.decode('hex')
try:
buffer = bytearray.fromhex(buf_file)
except ValueError as e:
self.logger.error( "incorrect <value> specified: '{}'".format(buf_file) )
self.logger.error( str(e) )
return
self.logger.log( "[CHIPSEC] read 0x{:X} hex bytes from command-line: {}'".format(len(buffer), buf_file) )
else:
buffer = chipsec.file.read_file( buf_file )
self.logger.log( "[CHIPSEC] read 0x{:X} bytes from file '{}'".format(len(buffer), buf_file) )
if len(buffer) < size:
self.logger.error( "number of bytes read (0x{:X}) is less than the specified <length> (0x{:X})".format(len(buffer),size) )
return
self.logger.log( '[CHIPSEC] writing buffer to memory: VA = 0x{:016X}, len = 0x{:X}..'.format(virt_address, size) )
_vmem.write_virtual_mem( virt_address, size, buffer )
else:
self.logger.error( "must specify <buffer>|<file> argument in 'mem write'" )
return
elif 'writeval' == op:
virt_address = int(self.argv[3],16)
if len(self.argv) > 4:
width = chipsec_util.get_option_width(self.argv[4]) if chipsec_util.is_option_valid_width(self.argv[4]) else int(self.argv[4],16)
else:
self.logger.error( "must specify <length> argument in 'mem writeval' as one of {}".format(chipsec_util.CMD_OPTS_WIDTH) )
return
if len(self.argv) > 5:
value = int(self.argv[5],16)
else:
self.logger.error( "must specify <value> argument in 'mem writeval'" )
return
self.logger.log( '[CHIPSEC] writing {:X}-byte value 0x{:X} to VA 0x{:016X}..'.format(width, value, virt_address) )
if 0x1 == width: _vmem.write_virtual_mem_byte ( virt_address, value )
elif 0x2 == width: _vmem.write_virtual_mem_word ( virt_address, value )
elif 0x4 == width: _vmem.write_virtual_mem_dword( virt_address, value )
elif 'getphys' == op:
virt_address = int(self.argv[3],16)
pa = _vmem.va2pa( virt_address )
if pa != None:
self.logger.log( '[CHIPSEC] Allocated {:X} bytes of virtual memory: VA = 0x{:016X}, PA = 0x{:016X}'.format(size, virt_address, pa) )
else:
print (VMemCommand.__doc__)
return
% (len(buffer), size))
return
logger().log(
'[CHIPSEC] writing buffer to memory: PA = 0x%016X, len = 0x%X..'
% (phys_address, size))
chipsec_util._cs.mem.write_physical_mem(phys_address, size, buffer)
else:
logger().error(
"must specify <buffer>|<file> argument in 'mem write'")
return
elif 'writeval' == op:
phys_address = int(argv[3], 16)
if len(argv) > 4:
width = chipsec_util.get_option_width(
argv[4]) if chipsec_util.is_option_valid_width(
argv[4]) else int(argv[4], 16)
else:
logger().error(
"must specify <length> argument in 'mem writeval' as one of %s"
% chipsec_util.CMD_OPTS_WIDTH)
return
if len(argv) > 5:
value = int(argv[5], 16)
else:
logger().error("must specify <value> argument in 'mem writeval'")
return
logger().log('[CHIPSEC] writing %X-byte value 0x%X to PA 0x%016X..' %
(width, value, phys_address))
if 0x1 == width:
def run(self):
size = 0x100
if len(self.argv) < 3:
print(MemCommand.__doc__)
return
op = self.argv[2]
t = time.time()
if 'allocate' == op and 4 == len(self.argv):
size = int(self.argv[3], 16)
(va, pa) = self.cs.mem.alloc_physical_mem(size)
self.logger.log(
'[CHIPSEC] Allocated {:X} bytes of physical memory: VA = 0x{:016X}, PA = 0x{:016X}'
.format(size, va, pa))
elif 'search' == op and len(self.argv) > 5:
phys_address = int(self.argv[3], 16)
size = int(self.argv[4], 16)
buffer = self.cs.mem.read_physical_mem(phys_address, size)
buffer = chipsec.defines.bytestostring(buffer)
offset = buffer.find(self.argv[5])
if offset != -1:
self.logger.log(
'[CHIPSEC] search buffer from memory: PA = 0x{:016X}, len = 0x{:X}, target address= 0x{:X}..'
.format(phys_address, size, 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(phys_address, size))
elif 'pagedump' == op and len(self.argv) > 3:
start = int(self.argv[3], 16)
length = int(
self.argv[4],
16) if len(self.argv) > 4 else chipsec.defines.BOUNDARY_4KB
end = start + length
self.dump_region_to_path(chipsec.file.get_main_dir(), start, end)
elif 'read' == op:
phys_address = int(self.argv[3], 16)
size = int(self.argv[4], 16) if len(self.argv) > 4 else 0x100
self.logger.log(
'[CHIPSEC] reading buffer from memory: PA = 0x{:016X}, len = 0x{:X}..'
.format(phys_address, size))
buffer = self.cs.mem.read_physical_mem(phys_address, size)
if len(self.argv) > 5:
buf_file = self.argv[5]
chipsec.file.write_file(buf_file, buffer)
self.logger.log(
"[CHIPSEC] written 0x{:X} bytes to '{}'".format(
len(buffer), buf_file))
else:
print_buffer(chipsec.defines.bytestostring(buffer))
elif 'readval' == op:
phys_address = int(self.argv[3], 16)
width = 0x4
if len(self.argv) > 4:
width = chipsec_util.get_option_width(
self.argv[4]) if chipsec_util.is_option_valid_width(
self.argv[4]) else int(self.argv[4], 16)
self.logger.log(
'[CHIPSEC] reading {:X}-byte value from PA 0x{:016X}..'.format(
width, phys_address))
if 0x1 == width:
value = self.cs.mem.read_physical_mem_byte(phys_address)
elif 0x2 == width:
value = self.cs.mem.read_physical_mem_word(phys_address)
elif 0x4 == width:
value = self.cs.mem.read_physical_mem_dword(phys_address)
self.logger.log('[CHIPSEC] value = 0x{:X}'.format(value))
elif 'write' == op:
phys_address = int(self.argv[3], 16)
if len(self.argv) > 4:
size = int(self.argv[4], 16)
else:
self.logger.error(
"must specify <length> argument in 'mem write'")
return
if len(self.argv) > 5:
buf_file = self.argv[5]
if not os.path.exists(buf_file):
#buffer = buf_file.decode('hex')
try:
buffer = bytearray.fromhex(buf_file)
except ValueError as e:
self.logger.error(
"incorrect <value> specified: '{}'".format(
buf_file))
self.logger.error(str(e))
return
self.logger.log(
"[CHIPSEC] read 0x{:X} hex bytes from command-line: {}'"
.format(len(buffer), buf_file))
else:
buffer = chipsec.file.read_file(buf_file)
self.logger.log(
"[CHIPSEC] read 0x{:X} bytes from file '{}'".format(
len(buffer), buf_file))
if len(buffer) < size:
self.logger.error(
"number of bytes read (0x{:X}) is less than the specified <length> (0x{:X})"
.format(len(buffer), size))
return
self.logger.log(
'[CHIPSEC] writing buffer to memory: PA = 0x{:016X}, len = 0x{:X}..'
.format(phys_address, size))
self.cs.mem.write_physical_mem(phys_address, size, buffer)
else:
self.logger.error(
"must specify <buffer>|<file> argument in 'mem write'")
return
elif 'writeval' == op:
phys_address = int(self.argv[3], 16)
if len(self.argv) > 4:
width = chipsec_util.get_option_width(
self.argv[4]) if chipsec_util.is_option_valid_width(
self.argv[4]) else int(self.argv[4], 16)
else:
self.logger.error(
"must specify <length> argument in 'mem writeval' as one of {}"
.format(chipsec_util.CMD_OPTS_WIDTH))
return
if len(self.argv) > 5:
value = int(self.argv[5], 16)
else:
self.logger.error(
"must specify <value> argument in 'mem writeval'")
return
self.logger.log(
'[CHIPSEC] writing {:X}-byte value 0x{:X} to PA 0x{:016X}..'.
format(width, value, phys_address))
if 0x1 == width:
self.cs.mem.write_physical_mem_byte(phys_address, value)
elif 0x2 == width:
self.cs.mem.write_physical_mem_word(phys_address, value)
elif 0x4 == width:
self.cs.mem.write_physical_mem_dword(phys_address, value)
else:
print(MemCommand.__doc__)
return
self.logger.log(
"[CHIPSEC] (mem) time elapsed {:.3f}".format(time.time() - t))
def run(self):
if len(self.argv) < 3:
print PCICommand.__doc__
return
op = self.argv[2]
t = time.time()
if ( 'enumerate' == op ):
self.logger.log( "[CHIPSEC] Enumerating available PCIe devices.." )
print_pci_devices( self.cs.pci.enumerate_devices() )
self.logger.log( "[CHIPSEC] (pci) time elapsed %.3f" % (time.time()-t) )
return
elif ( 'dump' == op ):
if len(self.argv) == 3:
self.logger.log( "[CHIPSEC] dumping configuration of available PCI devices.." )
self.cs.pci.print_pci_config_all()
elif len(self.argv) > 5:
bus = int(self.argv[3],16)
device = int(self.argv[4],16)
function = int(self.argv[5],16)
self.logger.log( "[CHIPSEC] PCI device %02X:%02X.%02X configuration:" % (bus,device,function) )
cfg_buf = self.cs.pci.dump_pci_config( bus, device, function )
pretty_print_hex_buffer( cfg_buf )
else:
print PCICommand.__doc__
return
elif ( 'xrom' == op ):
if len(self.argv) < 5:
self.logger.log( "[CHIPSEC] enumerating PCI expansion ROMs.." )
xrom_addr = int(self.argv[3],16) if len(self.argv) == 4 else None
_xroms = self.cs.pci.enumerate_xroms( True, True, xrom_addr )
self.logger.log( "[CHIPSEC] found %d PCI expansion ROMs" % len(_xroms) )
if len(_xroms) > 0: print_pci_XROMs( _xroms )
elif len(self.argv) > 5:
bus = int(self.argv[3],16)
device = int(self.argv[4],16)
function = int(self.argv[5],16)
xrom_addr = int(self.argv[6],16) if len(self.argv) > 6 else None
self.logger.log( "[CHIPSEC] locating PCI expansion ROM (XROM) of %02X:%02X.%02X..." % (bus,device,function) )
exists,xrom = self.cs.pci.find_XROM( bus, device, function, True, True, xrom_addr )
if exists:
self.logger.log( "[CHIPSEC] found XROM of %02X:%02X.%02X" % (bus,device,function) )
if xrom is not None:
self.logger.log( "[CHIPSEC] XROM enabled = %d, base = 0x%08X, size = 0x%08X" % (xrom.en,xrom.base,xrom.size) )
if xrom.header is not None: self.logger.log( "[CHIPSEC] XROM header: %s" % xrom.header )
else:
self.logger.log( "[CHIPSEC] coudn't find XROM of %02X:%02X.%02X" % (bus,device,function) )
else:
print PCICommand.__doc__
return
elif ('cmd' == op):
cmd_mask = 0xFFFF
pci_class = None
pci_sub_class = None
if len(self.argv) >= 4:
cmd_mask = int(self.argv[3],16)
if len(self.argv) >= 5:
pci_class = int(self.argv[4],16)
if len(self.argv) >= 6:
pci_sub_class = int(self.argv[5],16)
self.logger.log('BDF | VID:DID | CMD | CLS | Sub CLS')
self.logger.log('------------------------------------------')
for (b, d, f, vid, did) in self.cs.pci.enumerate_devices():
dev_cls = self.cs.pci.read_byte(b, d, f, PCI_HDR_CLS_OFF)
if pci_class is not None and (dev_cls != pci_class):
continue
dev_sub_cls = self.cs.pci.read_byte(b, d, f, PCI_HDR_SUB_CLS_OFF)
if pci_sub_class is not None and (dev_sub_cls != pci_sub_class):
continue
cmd_reg = self.cs.pci.read_word(b, d, f, PCI_HDR_CMD_OFF)
if (cmd_reg & cmd_mask) == 0:
continue
self.logger.log('{:02X}:{:02X}.{:X} | {:04X}:{:04X} | {:04X} | {:02X} | {:02X}'.format(b, d, f, vid, did, cmd_reg, dev_cls, dev_sub_cls))
else:
if len(self.argv) < 6:
print PCICommand.__doc__
return
bus = int(self.argv[2],16)
device = int(self.argv[3],16)
function = int(self.argv[4],16)
offset = int(self.argv[5],16)
width = 4
if len(self.argv) > 6:
width = chipsec_util.get_option_width(self.argv[6]) if chipsec_util.is_option_valid_width(self.argv[6]) else int(self.argv[6],16)
if 8 == len(self.argv):
value = int(self.argv[7], 16)
self.logger.log( "[CHIPSEC] write 0x%X to PCI %02X:%02X.%02X + 0x%02X" % (value, bus, device, function, offset) )
if 1 == width: self.cs.pci.write_byte ( bus, device, function, offset, value )
elif 2 == width: self.cs.pci.write_word ( bus, device, function, offset, value )
elif 4 == width: self.cs.pci.write_dword( bus, device, function, offset, value )
else: self.logger.error( "width should be one of %s" % chipsec_util.CMD_OPTS_WIDTH )
else:
if 1 == width: pci_value = self.cs.pci.read_byte (bus, device, function, offset)
elif 2 == width: pci_value = self.cs.pci.read_word (bus, device, function, offset)
elif 4 == width: pci_value = self.cs.pci.read_dword(bus, device, function, offset)
else:
self.logger.error( "width should be one of %s" % chipsec_util.CMD_OPTS_WIDTH )
return
self.logger.log( "[CHIPSEC] PCI %02X:%02X.%02X + 0x%02X: 0x%X" % (bus, device, function, offset, pci_value) )
self.logger.log( "[CHIPSEC] (pci) time elapsed %.3f" % (time.time()-t) )
