def main(): parser = argparse.ArgumentParser() parser.add_argument( '--name', '-n', type=str, default='net_seg', required=True, help= 'Name this client/slave announces to the server. Needs to match on server side.' ) parser.add_argument( '--ip', '-ip', type=str, default='', required=False, help= 'Name this client/slave announces to the server. Needs to match on server side.' ) parser.add_argument('-viz', action='store_true', help="Activate this to enable visualization output") args = parser.parse_args() size = (480, 640) logger.info("Starting engine") engine = create_engine() logger.info("Starting Latent Engine") latent_engine = create_latent_engine() debg = debugger() # Setup Engine broker_data = { "size": size, "engine": engine, "latent_engine": latent_engine, "viz": args.viz, "debugger": debg } if args.ip: config.BROKER_IP = args.ip else: config.BROKER_IP = utils.find_master(args.name) # Defined userdata pkg we give to MMQT logger.info("Broker: Connecting") client = mqtt.Client(userdata=broker_data) client.connect(config.BROKER_IP, config.BROKER_PORT, keepalive=60) logger.info("Initialize IMG Client Functions") init_img_topic(client) # Endless loop that keeps sending all sensor properties and updates once # per loop the actuator logger.info("Entering Forever Loop") client.loop_forever() client.disconnect()
from debugger import debugger print("start debugger...") dbg=debugger() dbg.attach(2776) #dbg.write_process_memory(1243628,b'\x00\x01\x02\x03') print(dbg.read_process_memory(1243624,8)) input() dbg.detach()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-viz', action='store_true', help="Activate this to enable visualization output") parser.add_argument('-b', action='store_true', help="Activate this to enable broadcasting") parser.add_argument( '-p_rec', type=str, help= 'Path to store recorded images. If defined, it automatically actives saving.' ) parser.add_argument( '--jetson', '-j', action='store_true', help= "This parameter should be set if run from a Jetson board with internal camera" ) parser.add_argument( '--expected_slaves', '-es', required=True, nargs='+', type=str, help= "The (list) of clients which need to connect to the server before processing can start." ) parser.add_argument('--interface_robot', '-ir', required=True, type=str, help="Interface to which ev3 is connect.") parser.add_argument('--interface_netseg', '-in', required=True, type=str, help="Interface to which ev3 is connect.") parser.add_argument('--angle', '-a', required=False, type=int, default=16, help="Interface to which ev3 is connect.") args = parser.parse_args() network_code = True if args.b: if not utils.master_announcement(args.expected_slaves, args.interface_netseg, message_delay=3, repeats=2): pass if not utils.master_announcement(args.expected_slaves, args.interface_robot, message_delay=3, repeats=2): pass # else: config.BROKER_IP = utils.find_interface_ip(args.interface_netseg) # sleep shortly so every service can get ready...ye sucks time.sleep(2) # Start the MMQT Messaging system logger.info("MMQT Broker: Initalization") broker = Broker.Broker(config.BROKER_IP, config.BROKER_PORT, broker_data={"seg_q": seg_q}) logger.info("Broker: Connecting") broker.connect() broker.init_img_topic() broker.start_listen() controller = Controller.RobotController(broker) robot = EV3Robot(controller, jetson_mode=args.jetson) logger.info("Initializing Robot") robot.startup() # Set up engines logger.info("Starting Segmentation Engine") #segment_engine = create_engine() segment_engine = None logger.info("Starting Latent Engine") #latent_engine = create_latent_engine() latent_engine = None logger.info("Setting up tracker Engine") marker_tracker = MarkerTracker.MarkerTracker() ####################################################### # ALL THE OTHER CODE FOR EXPLORATION AND SHIT IN HERE # ####################################################### robot.cam["ps3_one"].open() robot.cam["jetson_onboard"].open() # #### Get images logger.info("Starting Environment Exploration Phase") # path = '/home/nvidia/Documents/Ach8/Raw_ims/' count = 1 markerIDs = set() brick_exp_frames = [] for round_num in range(args.angle): robot.controller.turn_in_place(+28, 1000) # start = time.time() # elapsed = time.time() - start for i in range(6): frame = robot.cam["ps3_one"].read() frame2 = robot.cam["jetson_onboard"].read() if i % 2 == 0: brick_exp_frames.append(frame) # brick_exp_frames.append(frame2) ids = marker_tracker.update(frame2) logger.debug("ids: " + str(ids)) for id in ids: markerIDs.add(id[0]) # name = str(count).zfill(4) # cv2.imwrite(path + name + '.png', frame) # count += 1 # while elapsed < 0.5: # for i in range(7): # frame = robot.cam["ps3_one"].read() # frame2 = robot.cam["jetson_onboard"].read() # ids = marker_tracker.update(frame2) # logger.debug("ids: " + str(ids)) # for id in ids: # markerIDs.add(id[0]) # name = str(count).zfill(4) # cv2.imwrite(path + name + '.png', frame) # count += 1 # elapsed = time.time() - start robot.cam["jetson_onboard"].close() robot.cam["ps3_one"].close() ##### Set up engines if not network_code: logger.info("Starting Segmentation Engine") # segment_engine = create_small_engine() segment_engine = create_engine() logger.info("Starting Latent Engine") # latent_engine = create_small_latent_engine() latent_engine = create_latent_engine() else: segment_engine = None latent_engine = None ##### Get latents num_latent_var = 32 all_latents = np.empty([1, num_latent_var]) # for j, im_filename in enumerate(sorted(os.listdir(path))): for j, frame in enumerate(brick_exp_frames): # logger.debug("Reading image from "+ path + im_filename) logger.debug("Computing latents for frame %d", j) # frame = cv2.imread(path + im_filename, cv2.IMREAD_COLOR) if network_code: reset_seg_q() robot.controller.broker.net_segment_image(frame, compute_latent=True, occlude=True) most_recent_segmentation = seg_q.get() latents = utils.decode_list_of_numpy_arrays( most_recent_segmentation["latents"]) logger.debug(str(latents)) coords = most_recent_segmentation["coords"] else: latents, coords, small_ims, mask, elapsed = image_to_latents( frame, segment_engine, latent_engine, scale=1, occlude=False, mask_image=False) for i, latent in enumerate(latents): all_latents = np.concatenate((all_latents, latents[i]), axis=0) #print("image " + str(j) + " / " + str(len(os.listdir(path))) + " elapsed: " + str(elapsed) + " num objects: " + str(len(latents))) latents = np.array(all_latents) logger.debug(str(latents.shape[0]) + " scans of bricks.") logger.debug(str(latents.shape) + "latent dim.") #np.save('/home/nvidia/Documents/Ach8/latents', latents) if latents.shape[0] < 3 * len(markerIDs): logger.error( "WARNING NOT ENOUGH BRICK SCANS FOUND FOR GOOD ESTIMATION") n_components = len(markerIDs) logger.debug("Found %d boxes.", n_components) dbg = debugger() gmm = mixture.GaussianMixture(n_components=n_components, covariance_type='full') gmm.fit(latents) # logger.info("All_analysis finished, elapsed: " + str(time.time() - tot_analysis_start)) ####################################################### # ACTUAL BRICK SORTING COMES NOW # ####################################################### logger.info("Starting Brick Sorting Loop") while True: try: logger.debug("reseting Search-and-Reach Brick loop function") delattr(search_and_reach_brick, "track_count") delattr(search_and_reach_brick, "prev_x") delattr(search_and_reach_brick, "prev_y") except: pass logger.info("Starting Search-and-Reach Brick Phase") robot.cam["ps3_one"].open() picking_bricks = True robot.controller.lower_gripper() # Get the net segmenter ready for processing # # This list will keep images of the tracked brick which we will use later to compute the mean latent feature tracked_brick_small_ims = [] # This list can be used to store all frames since the last tracking update through segmentation for playback frames_since_last_seg = [] # Read first frame frame = robot.cam["ps3_one"].read() # send it to the net_seg logger.debug("SRB: Send initial image to network segmenter") reset_seg_q() robot.controller.broker.net_segment_image(frame, compute_latent=False, return_mask=True, scale=0.5, occlude=True) # wait for results most_recent_segmentation = seg_q.get() logger.debug(most_recent_segmentation.keys()) # and start tracker for closest brick logger.debug("SRB: Instantiate tracker for closest brick.") if most_recent_segmentation["coords"]: active_trackers, new_boxes = multitracking.instantiate_trackers( utils.decode_numpy_array(most_recent_segmentation["mask"]), frame, track_closest=True) tracked_brick_small_ims.append( multitracking.get_img_from_bbox(frame, new_boxes[0])) # Update tracker and send off next frame to keep the loop running! IMPORTANT! else: active_trackers = [] new_boxes = [] frame = robot.cam["ps3_one"].read() logger.debug( "SRB: Send second, loop starting image to network segmenter") robot.controller.broker.net_segment_image(frame, compute_latent=False, return_mask=True, scale=0.5, occlude=True) # active_trackers, new_boxes = multitracking.update_active_trackers(active_trackers, frame) # tracked_brick_small_ims.append(multitracking.get_img_from_bbox(frame, new_boxes[0])) # robot.controller.lift_gripper() while picking_bricks: running = True while running: logger.debug("SRB: starting main routine") tim = time.time() state = search_and_reach_brick(robot, segment_engine, latent_engine, config, active_trackers, new_boxes, tracked_brick_small_ims, frames_since_last_seg, visualize=args.viz, record=False) logger.info("SBR took: %f", time.time() - tim) if state == "lost": logger.debug("Lost track of brick, restarting search") elif state == "reached": running = False picking_bricks = False robot.controller.stop_main_motors() tbsi = len(tracked_brick_small_ims) logger.debug( "SRB: reached brick, computing latents from %d mini images", len(tracked_brick_small_ims)) brick_latents = [] for idx, im in enumerate( tracked_brick_small_ims): # TODO: RANDOM SAMPLE? logger.debug("SRB: reached brick, processing frame %d", idx) robot.controller.broker.net_segment_image(np.array(im), compute_latent=True, return_mask=False, final_latent=True, occlude=True) most_recent_segmentation = seg_q.get() if most_recent_segmentation["latents"]: brick_latents.append( utils.decode_numpy_array( most_recent_segmentation["latents"][0])) for idx, im in enumerate(tracked_brick_small_ims[-10:-1]): robot.controller.broker.net_segment_image(np.array( tracked_brick_small_ims[idx]), compute_latent=True, return_mask=False, final_latent=True, occlude=True) most_recent_segmentation = seg_q.get() if most_recent_segmentation["latents"]: brick_latents.append( utils.decode_numpy_array( most_recent_segmentation["latents"][0])) reset_seg_q() frame = robot.cam["ps3_one"].read() robot.controller.broker.net_segment_image(frame, compute_latent=True, return_mask=True, scale=0.5, occlude=True) # wait for results most_recent_segmentation = seg_q.get() logger.debug(most_recent_segmentation.keys()) # and start tracker for closest brick logger.debug("SRB: Instantiate tracker for closest brick.") if most_recent_segmentation["coords"]: active_trackers, new_boxes = multitracking.instantiate_trackers( utils.decode_numpy_array(most_recent_segmentation["mask"]), frame, track_closest=True) tracked_brick_small_ims.append( multitracking.get_img_from_bbox(frame, new_boxes[0])) robot.controller.broker.net_segment_image( tracked_brick_small_ims[0], compute_latent=True, return_mask=True, scale=0.5, occlude=True) brick_latents.append( utils.decode_numpy_array( most_recent_segmentation["latents"][0])) # for _ in range(5): # frame = robot.cam["ps3_one"].read() # robot.controller.broker.net_segment_image(frame, compute_latent=True, return_mask=False) # most_recent_segmentation = seg_q.get() # if most_recent_segmentation["latents"]: # brick_latents.append(utils.decode_numpy_array(most_recent_segmentation["latents"][0])) # delete the stuff del tracked_brick_small_ims[:] # ############################################################ # COMPUTE LATENT MEAN HERE # DECIDE WHICH CLUSTER! ############################################################ logger.debug(np.array(brick_latents).shape) bricks_latents_arry = np.array(brick_latents) print(np.array(brick_latents)) cluster_labels_mix = gmm.predict(bricks_latents_arry[:, 0, :]) logger.debug(bricks_latents_arry[:, 0, :].shape) logger.debug(cluster_labels_mix.shape) label, count = nps.mode(cluster_labels_mix, axis=0) label = label[0] logger.debug("desired label %s:", label) logger.debug(cluster_labels_mix) # label = int(np.mode(cluster_labels_mix)) logger.info("Starting PickUp") # robot.controller.move(60, 60) # time.sleep(0.2) for _ in range(30): frame = robot.cam["ps3_one"].read() #picking_bricks = not is_brick_in_gripper(robot, frame, segment_engine) picking_bricks = False if picking_bricks: logger.info("Oh no! I lost the brick!") robot.controller.move(-45, -45) time.sleep(0.5) robot.controller.open_gripper() robot.controller.lower_gripper() robot.cam["ps3_one"].close() robot.controller.lower_gripper() robot.controller.close_gripper() robot.controller.lift_gripper() # Brick is picked up # Robot moves towards box markerIDs_list = list(markerIDs) markerID = markerIDs_list[label] robot.cam["jetson_onboard"].open() running = True logger.info("Start looking for box with ID " + str(markerID) + " now!") while running: running = search_box(robot, marker_tracker, markerID) logger.debug("Running.") robot.controller.stop_main_motors() logger.info("Found box.") # robot.cam["jetson_onboard"].close() # Now actually track it! running = True # robot.cam["jetson_onboard"].open() logger.info("Driving to box " + str(markerID) + " now!") state = "first_cam" switched = False while running: last_state = state state = drive_to_box(robot, marker_tracker, markerID, args.viz, state) logger.debug("state=%s, des_box=%d, all_box=%s, small_ims_used=%d", state, markerID, markerIDs_list, tbsi) if state == "second_cam" and not switched: logger.debug("Box-Search: Switching to ps3 cam") robot.cam["jetson_onboard"].close() robot.cam["ps3_one"].open() robot.controller.move(65, 65) time.sleep(0.5) robot.controller.stop_main_motors() switched = True elif state == "lost": logger.debug("lost marker. backing up") robot.controller.move(-65, -65) time.sleep(0.5) robot.controller.stop_main_motors() time.sleep(0.5) running = True robot.cam["jetson_onboard"].open() robot.cam["ps3_one"].close() state = "first_cam" switched = False elif state == "inside_box": logger.debug("inside box") robot.cam["jetson_onboard"].close() robot.controller.move(60, 60) time.sleep(0.7) robot.controller.stop_main_motors() running = False # searching = True # while searching: # searching = search_home_base(robot, tracker, config, args.viz) if state == "inside_box": robot.controller.stop_main_motors() robot.controller.open_gripper() robot.controller.stop_main_motors() robot.cam["jetson_onboard"].close() robot.controller.open_gripper() logger.info("Looking for new work opportunities") robot.controller.move(-65, -65) time.sleep(4) robot.controller.stop_main_motors() robot.controller.move(80, -80) time.sleep(8) robot.controller.stop_main_motors() print("shutting down...im so sleepy")
import debugger debugger = debugger.debugger() pid = raw_input("Enter the PID of the process to attach to: ") debugger.attach(int(pid)) printf = debugger.func_resolve("msvcrt.dll", "printf") print "[*] Address of printf: 0x%08x" % printf debugger.bp_set_mem(printf, 10) debugger.run()
import datetime import os from subprocess import check_output from sys import exit from colorama import init, Fore import debugger import utilities import tools from pydbg.defines import * init(autoreset=True) currentTime = datetime.datetime.now() utils = utilities.Utilities.getInstance() dbg = debugger.debugger() class Parser: __instance = None @staticmethod def getInstance(): """ Static access method. """ if Parser.__instance is None: Parser() return Parser.__instance def __init__(self): Parser.__instance = self self.processName = "pywindbg" # Currently debugged process, 'pywindbg' to start out with
import debugger unpackIt = debugger.debugger() #packed_malware = input("Enter the path of the file to unpack: ") #unpackIt.load("C:\\Users\\rjimersonjr\\Documents\\GitHub\\helloWorldBinary\\helloWorldBinary\\Release\\helloWorldBinary.exe") path_to_dll = "C:\\Users\\rjimersonjr\\Documents\\GitHub\\malDLL\\malDLL\\Release\\dllToHook.dll" packed_malware = "C:\\Users\\rjimersonjr\\Documents\\GitHub\\helloWorldBinary\\helloWorldBinary\\Release\\helloWorldBinary.exe" unpackIt.load(packed_malware, path_to_dll)
import debugger debugger = debugger.debugger() debugger.load("C:\\WINDOWS\\system32\\calc.exe")
from vm import * from debugger import debugger v = Vm('challenge.bin') d = debugger(v) m = v.memory.memory for i in range(0, len(m)): try: print "%i: %s, %i" % (i, d.codes[m[i]], m[i]) except KeyError: print "%i: %s" % (i, m[i])
from debugger import debugger debugger = debugger() #debugger.load('C:\\Windows\\System32\\calc.exe') pid = input("Enter the PID process program: ") debugger.attach(int(pid)) LIST = debugger.enumerate_threads() # For each thread grab the value of each of the registers for thread in LIST: thread_context = debugger.get_thread_context(thread) print("[*] Dumping registers for thread ID: 0x%08x " % (thread)) print("[**] EIP: 0x%08x " % (thread_context.Eip)) print("[**] ESP: 0x%08x " % (thread_context.Esp)) print("[**] EBP: 0x%08x " % (thread_context.Ebp)) print("[**] EAX: 0x%08x " % (thread_context.Eax)) print("[**] EBX: 0x%08x " % (thread_context.Ebx)) print("[**] ECX: 0x%08x " % (thread_context.Ecx)) print("[**] EDX: 0x%08x " % (thread_context.Edx)) print("[*] END DUMP") debugger.detach()