def obtain_corrupted_program(): # Obtain a program and corrupt it instructions = ElfioTextDisassembleReader("data/helloworld_elfiodissasembly.disam").read()[1] collector = MetadataCollector() collector.collect(instructions) corruptor = RandomCorruptor(30.0, 5, True) corruptor.save_corrupted_program = False program = [CAPSInstruction(x.encoding, x.address) for x in instructions] program = corruptor.corrupt(from_instruction_list_to_dict(program)) return instructions, program
def test_count(self): ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'data/helloworld_elfiodissasembly.disam') program = ElfioTextDisassembleReader(ARM_SIMPLE).read_instructions() fc = InstructionPartFrequencyCounter() fc.count(program) self.assertTrue(fc.reg_frequency[AReg.R0], 33) self.assertTrue(fc.reg_frequency[AReg.R1], 17) self.assertTrue(fc.cond_frequency[14], 115) self.assertTrue(fc.opcode_frequency[23], 9)
def test_read(self): fns, instructions = ElfioTextDisassembleReader( "data/helloworld_elfiodissasembly.disam").read() # Some smoke to start with for inst in instructions: self.assertFalse(inst.ignore) self.assertEqual(instructions[0].encoding, 0xe92d4008) # push {r3, lr} self.assertEqual(instructions[2].encoding, 0xe52de004) # str lr, [sp, #-4]! self.assertEqual(instructions[len(instructions) - 2].encoding, 0xe8bd8800) # pop {fp, pc} self.assertEqual(instructions[len(instructions) - 1].encoding, 0xe92d4008) # push {r3, lr} self.assertGreater(len(fns), 10) self.assertEqual(len(instructions), 143)
def test_corrupted_collect(self): # TODO: This is an smoke test # Load the program instructions = ElfioTextDisassembleReader( self.ASM_LONG_PATH).read_instructions() # Corrupt the program ll = len(instructions) packet_count = ll / 32 cc = PacketCorruptor(packet_count, ll, packets_lost=[3]) instructions = cc.corrupt(from_instruction_list_to_dict(instructions)) # Collect some metrics in the corrupted program c = CorruptedProgramMetadataCollector() c.collect(instructions) # Some very soft tests self.assertGreater(len(c.address_with_cond), 0) self.assertGreater(len(c.address_with_reg), 0) self.assertGreater(len(c.address_with_op), 0)
import os import random from semantic_codec.architecture.disassembler_readers import ElfioTextDisassembleReader from semantic_codec.distributed.qos_functions import DistributedQoS _qos = DistributedQoS("10.0.0.83:5555", 'basic_math') ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/basicmath_small.disam') program = ElfioTextDisassembleReader(ARM_SIMPLE).read_instructions() #converts the text into a list of characters #RLE final = "" #string of encoded text last_char = program[0] counter = 0 #keeps track of i's location first_of_a_kind = 0 #keeps track of the location of where the set started for i in program: if i != last_char: #if a different character was found final += str(counter - first_of_a_kind) + last_char first_of_a_kind = counter counter += 1 last_char = i final_s = list(final) #Replacements begin counter = 0 #keeps track of how many times a set of characters has been replaced (to skip the characters that have been replaced already) final_result = "" for i in range(0, (len(final_s) - 1)): if i%2 == 0: #makes sure that i is an even number (this means that an integer value will be found in the list) if counter == 0: try:
# Check Arguments expected_num_args = 3 if len(sys.argv) != expected_num_args: print('Usage: <source_file> <output_file>') exit(1) # Read the file to be stored without the loss packets input_file = os.path.realpath(os.path.join(os.getcwd(), sys.argv[1])) try: f = open(input_file) except: print('Unable to find source: {}'.format(input_file)) exit(1) # Parse the dissasembly text try: original_program = ElfioTextDisassembleReader( input_file).read_functions() original_program, fns = from_functions_to_list_and_addr( original_program) original_program = [inst.encoding for inst in original_program] except: print('Unable to parse source file, is it a valid dissasembly?') exit(1) # Interleave the file using the SP algorithm bits_per_interlave = 2 packet_size = 16 packet_count = len( original_program ) * 4 / packet_size # <- Total bytes in data divided by packet_size # Build the 2D interleave order
if __name__ == "__main__": use_packets = True use_file = False recovered_program = None corruptor = None # ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/dissasembly.armasm') #ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/helloworld_elfiodissasembly.txt') #ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/fft.disam') #ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/dijkstra_small.disam') #ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/crc32.disam') #ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/bitcount.disam') ARM_SIMPLE = os.path.join(os.path.dirname(__file__), 'tests/data/basicmath_small.disam') #original_program = TextDisassembleReader(ARM_SIMPLE).read_functions() original_program = ElfioTextDisassembleReader(ARM_SIMPLE).read_functions() if not use_file: if use_packets: ll = 0 for f in original_program: ll += len(f.instructions) packet_count = ll / 32 lost = [3] print( '[INFO:] Program Size: {} bytes -- Loss: {} -- Packet count: {}' .format(ll * 4, 16 * len(lost) * 2, packet_count)) corruptor = PacketCorruptor(packet_count, ll, packets_lost=lost) else: corruptor = RandomCorruptor(30.0, 3, True) else: