def main(options): """ Read the specified memory region and record statistics """ # Initilize our experiment client = MemorySensorPhysical(options.target, cache_timeout=0, use_threading=True) READ_SIZE = int(options.read_size)*85 start_addr = options.startaddr # Read memory offset = 0 read_rates = [] total_read = 0 count = 0 output = open(options.output_file, "w+") output.write("Memory Address,Bytes Read,Time Elapsed,Bytes/Second\n") for addr in xrange(start_addr,2**30, READ_SIZE): try: time_start = time.time() data = client.read(addr, READ_SIZE) time_elapsed = (time.time() - time_start) total_read += len(data) count += 1 rate = (len(data)/time_elapsed) print "Addr: 0x%08X, Read: %d bytes, %f bytes/sec" % (addr, len(data), rate) output.write("0x%08X,%d,%f,%f\n" % (addr, len(data), time_elapsed, rate)) read_rates.append(rate) except: import traceback traceback.print_exc() # Just finish up break output.close()
def main(options): """ Read the specified memory region and record statistics """ # Initilize our experiment client = MemorySensorPhysical(options.target, cache_timeout=0, use_threading=True) READ_SIZE = int(options.read_size) * 85 start_addr = options.startaddr # Read memory offset = 0 read_rates = [] total_read = 0 count = 0 output = open(options.output_file, "w+") output.write("Memory Address,Bytes Read,Time Elapsed,Bytes/Second\n") for addr in xrange(start_addr, 2**30, READ_SIZE): try: time_start = time.time() data = client.read(addr, READ_SIZE) time_elapsed = (time.time() - time_start) total_read += len(data) count += 1 rate = (len(data) / time_elapsed) print "Addr: 0x%08X, Read: %d bytes, %f bytes/sec" % ( addr, len(data), rate) output.write("0x%08X,%d,%f,%f\n" % (addr, len(data), time_elapsed, rate)) read_rates.append(rate) except: import traceback traceback.print_exc() # Just finish up break output.close()
def __init__(self, base, config, layered=False, **kwargs): addrspace.BaseAddressSpace.__init__(self, base, config, **kwargs) self.as_assert(base == None or layered, 'Must be first address space') if config.LOPHI_CACHE: logger.info("LO-PHI Cache ENABLED.") cache_timeout = 1 else: cache_timeout = 0 if config.LOCATION.startswith("lophi://"): location = config.LOCATION[8:] self.client = MemorySensorPhysical(location, cache_timeout=cache_timeout) elif config.LOCATION.startswith("vmi://"): location = config.LOCATION[6:] self.client = MemorySensorVirtual(location, cache_timeout=cache_timeout) self.dtb = self.get_cr3() else: raise ( "Not a valid LO-PHI URN. (lophi:// for physical and vmi:// for virtual)" ) self.fname = location self.name = location self.cache = False self.cache_data = {} self.address = 0 if config.RAM_SIZE is None: print "ERROR/LO-PHI: No RAM size defined. (e.g. --ram_size=12GB)" sys.exit(0) self.size = self.parse_byte_amount(config.RAM_SIZE) self.config = config self._exclusions = sorted( []) # no info about the HW, nothing to exclude
def import_from_config(config_file, config_type=None): """ This will import our config file into a LoPhiConfig or Machine class for each item in the config This is only done for physical machines. Virtual machines are handled by libvirt. @param config_file: Config file on disk @param config_type: Type of config file to parse controller, machine, sensor @return: List of classes of the appropriate type in dictionary referenced by their name """ if config_type is None: logger.error("ERROR: Must specify type of config to import.") return None Config = ConfigParser.ConfigParser() Config.read(config_file) config_list = {} for config in Config.sections(): name = config logging.debug("Intializing config for %s..." % name) config = None if config_type == "machine": # Create our config config = MachineConfig(name, Config) # What type of machine? config_list[name] = PhysicalMachine(config) elif config_type == "controller": config = ControllerConfig(name, Config) config_list[name] = config elif config_type == "sensor": # These will only be physical sensors # Virtual sensors are all derived from the VM name sensor_type = int(Config.get(name, "type")) if sensor_type == G.SENSOR_TYPES.NETWORK: interface = Config.get(name, "interface") else: sensor_ip = Config.get(name, "ip") sensor_port = int(Config.get(name, "port")) if sensor_type == G.SENSOR_TYPES.CONTROL: config_list[name] = ControlSensorPhysical(sensor_ip, sensor_port, name=name) elif sensor_type == G.SENSOR_TYPES.DISK: config_list[name] = DiskSensorPhysical(sensor_ip, sensor_port, name=name) elif sensor_type == G.SENSOR_TYPES.MEMORY: config_list[name] = MemorySensorPhysical(sensor_ip, sensor_port, name=name) elif sensor_type == G.SENSOR_TYPES.CPU: config_list[name] = CPUSensorPhysical(sensor_ip, sensor_port, name=name) elif sensor_type == G.SENSOR_TYPES.NETWORK: config_list[name] = NetworkSensorPhysical(interface, name=name) else: logging.error("Unrecognized sensor type. (%d)" % sensor_type) elif config_type == "images": # Setup an empty map config_list = { G.MACHINE_TYPES.PHYSICAL: {}, G.MACHINE_TYPES.KVM: {}, G.MACHINE_TYPES.XEN: {} } if Config.has_section("physical"): for (profile, image) in Config.items("physical"): config_list[G.MACHINE_TYPES.PHYSICAL][ profile.lower()] = image if Config.has_section("virtual"): for (profile, image) in Config.items("virtual"): config_list[G.MACHINE_TYPES.KVM][profile.lower()] = image config_list[G.MACHINE_TYPES.XEN][profile.lower()] = image else: logging.error("Unknown config file. (%s)" % (config_type)) return None logging.debug(config_list) return config_list
def main(options): if options.replay_file is not None: cap_reader = CaptureReader(options.replay_file) for (ts, data) in cap_reader: print "Time: ", ts, "s" print MemorySensorPacket(data) return if options.sensor_type == G.MACHINE_TYPES.PHYSICAL: client = MemorySensorPhysical(options.target, cache_timeout=0, use_threading=False) else: client = MemorySensorVirtual(options.target) READ_SIZE = int(options.read_size) start_addr = options.startaddr # Create our output file try: os.makedirs(os.path.dirname(options.output)) except: pass try: mcap_writer = None if options.loop_forever == True: logger.debug("Creating capture file.") options.output += ".mcap" mcap_writer = CaptureWriter(options.output) mcap_writer.start() else: logger.debug("Creating dump file.") options.output += ".mfd" output_file = open(options.output, "w+") except: print "ERROR: Could not open output file." sys.exit(0) # Read memory count = 0 start = time.time() sensor_packet = MemorySensorPacket() while True: try: # Get memory from remote system # Read memory data = client.read(start_addr, READ_SIZE) # Write to file? if not options.loop_forever: output_file.write(data) else: sensor_packet.address = start_addr sensor_packet.data = data sensor_packet.length = READ_SIZE mcap_writer.put(sensor_packet) # Just read once? if not options.loop_forever: break else: print "Completed read #%d" % count count += 1 except: # Just finish up break end = time.time() # Do we have an mcap file to close? if mcap_writer is not None: mcap_writer.stop() else: # Close output file output_file.close() print "Memory dump (%d bytes) written to %s. Took %s seconds." % ( len(data), options.output, end - start)
def main(options): if options.replay_file is not None: cap_reader = CaptureReader(options.replay_file) for (ts, data) in cap_reader: print "Time: ", ts, "s" print MemorySensorPacket(data) return if options.sensor_type == G.MACHINE_TYPES.PHYSICAL: client = MemorySensorPhysical(options.target, cache_timeout=0, use_threading=False) else: client = MemorySensorVirtual(options.target) READ_SIZE = int(options.read_size) start_addr = options.startaddr # Create our output file try: os.makedirs(os.path.dirname(options.output)) except: pass try: mcap_writer = None if options.loop_forever == True: logger.debug("Creating capture file.") options.output += ".mcap" mcap_writer = CaptureWriter(options.output) mcap_writer.start() else: logger.debug("Creating dump file.") options.output += ".mfd" output_file = open(options.output, "w+") except: print "ERROR: Could not open output file." sys.exit(0) # Read memory count = 0 start = time.time() sensor_packet = MemorySensorPacket() while True: try: # Get memory from remote system # Read memory data = client.read(start_addr, READ_SIZE) # Write to file? if not options.loop_forever: output_file.write(data) else: sensor_packet.address = start_addr sensor_packet.data = data sensor_packet.length = READ_SIZE mcap_writer.put(sensor_packet) # Just read once? if not options.loop_forever: break else: print "Completed read #%d"%count count += 1 except: # Just finish up break end = time.time() # Do we have an mcap file to close? if mcap_writer is not None: mcap_writer.stop() else: # Close output file output_file.close() print "Memory dump (%d bytes) written to %s. Took %s seconds." % (len(data),options.output,end-start)