def accbits_for_blocknum(accbits_str, blocknum): ''' Decodes the access bit string for block "blocknum". Returns the three access bits for the block or False if the inverted bits do not match the access bits. ''' bits = BitArray([0]) inverted = BitArray([0]) # Block 0 access bits if blocknum == 0: bits = BitArray([accbits_str[11], accbits_str[23], accbits_str[19]]) inverted = BitArray([accbits_str[7], accbits_str[3], accbits_str[15]]) # Block 0 access bits elif blocknum == 1: bits = BitArray([accbits_str[10], accbits_str[22], accbits_str[18]]) inverted = BitArray([accbits_str[6], accbits_str[2], accbits_str[14]]) # Block 0 access bits elif blocknum == 2: bits = BitArray([accbits_str[9], accbits_str[21], accbits_str[17]]) inverted = BitArray([accbits_str[5], accbits_str[1], accbits_str[13]]) # Sector trailer / Block 3 access bits elif blocknum == 3: bits = BitArray([accbits_str[8], accbits_str[20], accbits_str[16]]) inverted = BitArray([accbits_str[4], accbits_str[0], accbits_str[12]]) # Check the decoded bits inverted.invert() if bits.bin == inverted.bin: return bits else: return False
def enumeration_solver(T, K=None, S=None): """ Tries all the possible combinations of flipping: At each round are available len(S) - K + 1 possible flip positions ranging from 0 to len(S) - K """ from bitstring import BitArray S = BitArray(bin=S.replace('+', '1').replace('-', '0')) solution = '1' * len(S) if S.bin == solution: return 'Case #{}: {}\n'.format(T, 0) #print('Case {}'.format(S.bin)) cand = [S] flip_pos = range(len(S) - K + 1) flips = 1 explored = {S.bin} while flips > 0: #print('Round {} Candidates {}'.format(flips,len(cand))) new_cand = [] for c in cand: for f in flip_pos: flipped = BitArray(c) flipped.invert(range(f, f + K)) if flipped.bin == solution: return 'Case #{}: {}\n'.format(T, flips) if flipped.bin not in explored: new_cand.append(flipped) explored.add(flipped.bin) if len(new_cand) == 0: return 'Case #{}: IMPOSSIBLE\n'.format(T) cand = new_cand flips += 1
def numberToBinary(num, bits): """Convert int to binary array with lenght bits""" #print (f"Num: {num}") #Variables neg = False i = bits - 1 #Check if negative if (num < 0): neg = True num += 1 num = abs(num) #Convert to bits number = BitArray(bits) while num > 0: if num % 2 == 1: number[i] = 1 num = math.floor(num / 2) i -= 1 #Invert if negative if (neg == True): number.invert() #print (f"Number binary: {number.bin}") #print (f"Number int: {number.int}") return number
def test_for_strict_avalanche(): """ Function to apply the SAC test defined in https://eprint.iacr.org/2010/564.pdf. """ with open('key.txt', 'rb') as file: key = file.read() associated_data = generate_nonce(16).encode(encoding='utf-8') sample_size = 32768 plaintext_bit_size = 64 plaintext_byte_length = 8 algorithms = [ "ascon128.so", "ascon128a.so", "isap_a_128.so", "isap_k_128.so", "oribatida_128.so", "locus_64.so", "lotus_64.so", "spoc_64.so" ] print(algorithms) for alg in algorithms: print(alg) if "128" in alg: tagsize = 16 else: tagsize = 8 matrix = np.zeros( (plaintext_bit_size, plaintext_bit_size + (tagsize * 8)), dtype=int) for _ in range(0, sample_size): plaintext = random.getrandbits(plaintext_bit_size) nonce = generate_nonce(16).encode(encoding='utf-8') variant = "encryption_interfaces/" + alg original_cipher = encrypt( key, nonce, associated_data, plaintext.to_bytes(plaintext_byte_length, sys.byteorder), variant, tagsize) for bit_position in range(0, plaintext_bit_size): temp_plaintext = BitArray( plaintext.to_bytes(plaintext_byte_length, sys.byteorder)) temp_plaintext.invert(bit_position) nonce = generate_nonce(16).encode(encoding='utf-8') cipher = encrypt(key, nonce, associated_data, temp_plaintext.tobytes(), variant, tagsize) cipher_array = BitArray(cipher) ^ BitArray(original_cipher) for cipher_position in range( 0, plaintext_bit_size + (tagsize * 8)): matrix[bit_position][cipher_position] += int( cipher_array.bin[cipher_position]) flip_probabilty = 0.5 expected_count = sample_size * flip_probabilty with open('sac_results.txt', 'a') as f: f.write(variant + "\n") for row in range(0, (plaintext_bit_size)): for column in range(0, plaintext_bit_size + (tagsize * 8)): statistics, pvalue = chisquare([ int(matrix[row][column]), int(sample_size - matrix[row][column]) ], [expected_count, expected_count]) f.write(str(pvalue) + "\n") print("Values Stat & P-Value") print(statistics) print(str(pvalue))
def accbits_for_blocknum(accbits_str, blocknum): ''' Decodes the access bit string for block "blocknum". Returns the three access bits for the block or False if the inverted bits do not match the access bits. ''' bits = BitArray([0]) inverted = BitArray([0]) # Block 0 access bits if blocknum == 0: bits = BitArray([accbits_str[11], accbits_str[23], accbits_str[19]]) inverted = BitArray([accbits_str[7], accbits_str[3], accbits_str[15]]) # Block 0 access bits elif blocknum == 1: bits = BitArray([accbits_str[10], accbits_str[22], accbits_str[18]]) inverted = BitArray([accbits_str[6], accbits_str[2], accbits_str[14]]) # Block 0 access bits elif blocknum == 2: bits = BitArray([accbits_str[9], accbits_str[21], accbits_str[17]]) inverted = BitArray([accbits_str[5], accbits_str[1], accbits_str[13]]) # Sector trailer / Block 3 access bits elif blocknum in (3, 15): bits = BitArray([accbits_str[8], accbits_str[20], accbits_str[16]]) inverted = BitArray([accbits_str[4], accbits_str[0], accbits_str[12]]) # Check the decoded bits inverted.invert() if bits.bin == inverted.bin: return bits else: return False
def address_int_to_bin(self, address: int): if address > 15: return False address_binary = BitArray(uint=address, length=4) # All bits are sent inverted, so invert the address compared to the dip switches address_binary.invert() return address_binary
def mutation(self, children): for i in range(len(children)): if random.random() < self.mutation_prob: pos = random.randint(0, self.chromosome_length-1) chromosome = BitArray(children[i].chromosome) chromosome.invert(pos) fitness = self.calc_fitness(chromosome) children[i] = Individual(chromosome=chromosome, fitness=fitness) return children
def hamming_search(b, bit, radius, current_radius, H): if current_radius == 0: H[current_radius].append(b.copy()) if current_radius == radius: return for i in range(bit + 1, b.length): b2 = BitArray(b.copy()) b2.invert(i) H[current_radius + 1].append(b2.copy()) hamming_search(b2, i, radius, current_radius + 1, H)
def hamming_search(b, bit, radius, current_radius, H): if current_radius == 0: H[current_radius].append(b.copy()) if current_radius == radius: return for i in range(bit+1, b.length): b2 = BitArray(b.copy()) b2.invert(i) H[current_radius+1].append(b2.copy()) hamming_search(b2, i, radius, current_radius+1, H)
def _generate_keypair(keylength, error_rate): s = random.randint(0, 2 ** keylength - 1) correct_key = BitArray(uint=s, length=keylength) key = BitArray(correct_key) for i in range(0, len(key)): rand = random.randint(0, 100000) if rand < error_rate*100000: key.invert(i) return correct_key, key
def test_flipFloat(val): # fix random seed np.random.seed(4) faultValue = BitArray(float=val, length=32) bit = np.random.randint(0, faultValue.len) faultValue.invert(bit) tret = faultValue.float fret = torchFI.flipFloat(val, bit) return tret == fret
def flipFloat(val, bit=None, log=False): # Cast float to BitArray and flip (invert) random bit 0-31 faultValue = BitArray(float=val, length=32) if bit == None: bit = np.random.randint(0, faultValue.len) faultValue.invert(bit) if log: logInjectionBit("\tFlipping bit ", bit) logInjectionVal("\tOriginal: ", float(val), " Corrupted: ", faultValue.float) return faultValue.float, bit
def flipInt(val, size, bit=None, log=False): # Cast integer to BitArray and flip (invert) random bit 0-N val = int(val) faultValue = BitArray(int=val, length=size) if bit == None: bit = np.random.randint(0, faultValue.len) faultValue.invert(bit) if log: logInjectionBit("\tFlipping bit ", bit) logInjectionVal("\tOriginal: ", int(val), " Corrupted: ", faultValue.int) return faultValue.int, bit
def __call__(self, row): context = row.copy() for key, value in row.items(): # We need to stringify some types to make them properly comparable if key in self.key_list: # numbers # https://www.h-schmidt.net/FloatConverter/IEEE754.html if isinstance(value, (int, float, decimal.Decimal)): bits = BitArray(float=value, length=64) # invert the sign bit bits.invert(0) # invert negative numbers if value < 0: bits.invert(range(1, 64)) context[key] = bits.hex return self.key_spec.format(**context)
def part_1(): data = get_input() counts = get_bitcount_array(data) half = len(data) / 2 for index, i in enumerate(counts): if i < half: counts[index] = '0' else: counts[index] = '1' bits = BitArray(bin=''.join(counts)) gamma = bits.uint bits.invert() epsilon = bits.uint print(f"{gamma * epsilon}")
def encode(input_bytes: bytes) -> bytes: input_buff = BitArray(input_bytes) encoded_bits = BitArray([0] * 80) for idx in range(80): # calculate input bit position d3 = ((idx + 1) * 11) % 80 # get the input bit d1 = input_buff[d3] # invert every other bit if (idx & 1) == 1: d1 = ~d1 # set output bit if d1 & 1: encoded_bits.invert(idx) logging.debug(f'Encoded bytes: {encoded_bits.hex}') return encoded_bits.bytes
def int_to_vlv(number: int) -> bytes: """Calculate variable-length time from integer""" assert type(number) is int, "Input should be integer" assert number <= 4294967295, "Woah! Number too huge. Should be <= 4294967295 " # inputs below 127 don't change try: if number <= 127: return number.to_bytes(1, 'big') except OverflowError: print(number) # get input into bit array number = struct.pack( '>I', number) # must do big endian as midi values are read forward bits = BitArray(number) # remove 0s from beginning while bits[0] == 0: del (bits[0]) length = len(bits) # insert 0 at the beginning of the final byte, signifying it is the final byte bits.insert(1, length - 7) # insert 1s at beginning of each byte, shifting the rest left for pos in range(length)[length - 14::-7]: bits.insert(1, pos) bits.invert(pos) # pad 0s to complete the first byte while len(bits) % 8 != 0: bits.insert(1, 0) # make first bit 1 if not already if bits[0] is not True: bits.invert(0) return bits.bytes
def testInvertBit(self): a = BitArray('0b11110000') a.invert() self.assertEqual(a, '0x0f') a.invert(0) self.assertEqual(a, '0b00001110') a.invert(-1) self.assertEqual(a, '0b10001110')
def _mutate(self): new_val = BitArray(self._default_value).copy() start, end = self._start_end() new_val.invert(range(start, end)) self.set_current_value(Bits(new_val))
def change_one_bit(input): bitarray = BitArray(hex=input) bitarray.invert(0) newinput = bitarray.hex return newinput, bitarray
class Peer: def __init__(self, ip, port, client): self.ip = ip self.port = port self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.am_choking_peer = True self.peer_is_choking_client = True self.am_interested = False self.peer_is_interested = False self.buf = '' # Data buffer self.time_last_msg_received = time.time() self.time_last_msg_sent = 0.0 self.is_alive = False self.client = client self.bitfield = BitArray(length=client.num_pieces) self.msg_queue = Queue.Queue() self.outstanding_requests = [] self.request_q = [] def __repr__(self): return str((self.ip, self.port)) # This feels kind of cheap... def __cmp__(self, other): return len(self.request_q) - len(other.request_q) # WRAPPER METHODS FOR SOCKET - these are only necessary bc of handshake # TODO: refactor handshake into reactor def close(self): self.socket.close() def connect(self): logging.debug('Attempting to connect to peer %s', self) try: self.socket.connect((self.ip, self.port)) except Exception as e: logging.info('Failed to connect to peer %s', self) raise e else: logging.debug('You have connected to peer %s', self) def sendall(self, msg_bytes): self.socket.sendall(msg_bytes) def receive_data(self, amount_expected, block_size): logging.debug('Waiting for handshake') amount_received = 0 data = '' while amount_received < amount_expected: try: new_data = self.socket.recv(block_size) logging.info('Received %s bytes from peer', len(new_data)) amount_received += len(new_data) data += new_data except Exception as e: logging.debug('Problem with handshake socket') pass return data def send_message(self, message): bytes_to_send = Msg.get_buffer_from_message(message) self.sendall(bytes_to_send) def connect(self): logging.debug('Attempting to connect to peer %s', self) try: self.socket.settimeout(5.0) self.socket.connect((self.ip, self.port)) except Exception as e: logging.info('Failed to connect to peer %s', self) raise e else: logging.debug('You have connected to peer %s', self) def send_and_receive_handshake(self, handshake): try: logging.info('Sending handshake') # logging.info('handshake: %s', handshake) self.sendall(handshake) logging.info('Handshake sent, receiving data') peer_handshake = self.receive_data(68, 68) logging.info('Peer handshake received.') except Exception as e: raise e else: logging.debug('Returning peer handshake') return peer_handshake def verify_handshake(self, handshake, info_hash): # lenpstr - pstr - reserved - info hash - peer id (pstrlen, pstr, peer_hash, peer_id) = struct.unpack('B19s8x20s20s', handshake) self.peer_id = peer_id return peer_hash == info_hash # TODO: Clean up handling of block messages here to ONLY send block bytes def process_and_act_on_incoming_data(self, data): (messages, buf_remainder) = Msg.get_messages_from_buffer(self.buf + data) logging.debug('Converting %s bytes from buffer and %s bytes from reactor', len(self.buf), len(data)) self.act_on_messages(messages) self.update_buffer(buf_remainder) # TODO: Set up message queue to maximize bytes per trip over the servers. def act_on_messages(self, messages): message_actions = { -1: (self.keep_alive, []), # Use partial/bound functions for these 3 0: (self.peer_starts_choking_client, []), 1: (self.peer_stops_choking_client, []), 2: (self.peer_is_now_interested, []), 3: (self.peer_is_no_longer_interested, []), 4: (self.update_bitfield, ['piece_index']), 5: (self.setup_bitfield, ['buffer_to_send']), 6: (self.queue_up_block, ['block_info']), 7: (self.update_and_store_block, ['block_info', 'buffer_to_send']), 8: (self.clear_requests, ['block_info']), } for msg in messages: (message_action, message_params) = message_actions[msg.msg_id] message_args = [getattr(msg, param) for param in message_params] message_action(*message_args) self.update_time_last_msg_received() def update_buffer(self, buf): self.buf = buf def update_time_last_msg_received(self): self.time_last_msg_received = time.time() # TODO: Account for when peer is no longer alive and deal accordingly def update_time_last_msg_sent(self): self.time_last_msg_sent = time.time() def check_if_client_will_time_out(self): """ Check to see if client needs to send a keep alive message to avoid getting timedout. If its been over 60 seconds, send a keep alive message to peer. """ current_time = time.time() return (current_time - self.time_last_msg_sent) > 60.0 def send_keep_alive(self): logging.info('Sending keep alive message to %s', self) return KeepAliveMsg().get_buffer_from_message() # Upon message id -1 def keep_alive(self): self.time_last_msg_received = time.time() self.is_alive = True def check_is_still_alive(self): time_elapsed = time.time() - self.time_last_msg_received self.is_alive = time_elapsed < 120 # Timeout timer set at 2 mins return self.is_alive def destroy_peer(self): logging.info('Peer %s is now DEAD', self) for block_info in self.outstanding_requests: self.outstanding_requests.remove(block_info) self.client.request_block(block_info) for block_info in self.request_q: self.request_q.remove(block_info) self.client.request_block(block_info) self.is_alive = False def peer_starts_choking_client(self): self.peer_is_choking_client = True # TODO: Add check for choked status before sending new requests def peer_stops_choking_client(self): self.peer_is_choking_client = False if self.am_interested: logging.info('Peer unchoked, sending requests now') if len(self.request_q) > 0: self.flush_request_queue() else: # TODO: Trace code path here self.client.manage_requests(REQUESTS_PER_PEER) def peer_is_now_interested(self): self.peer_is_interested = True # Assuming we always unchoke when receiving interested message self.am_choking_peer = False self.add_to_message_queue(UnchokeMsg()) def peer_is_no_longer_interested(self): self.peer_is_interested = False # TODO: Update request q based on this information # When receiving bitfield def setup_bitfield(self, bitfield_buf): # TODO implement non-naive function for updating interested status bitfield = BitArray(bytes=bitfield_buf) self.bitfield = bitfield for piece_index, bit in enumerate(bitfield): if bit: self.client.add_peer_to_piece_peer_list(piece_index, self) self.am_interested = True self.add_to_message_queue(InterestedMsg()) self.client.manage_requests(1) # When receiving have message def update_bitfield(self, piece_index): if not self.bitfield[piece_index]: self.bitfield.invert(piece_index) self.client.add_peer_to_piece_peer_list(piece_index, self) else: raise PeerCommunicationError('Redundant "Have" message.') # After request def queue_up_block(self, block_info): assert not self.am_choking_peer block = self.client.get_block(block_info) self.add_to_message_queue(BlockMsg(block_info=block_info, block=block)) # After block message def update_and_store_block(self, block_info, block): self.outstanding_requests.remove(block_info) self.flush_request_queue() logging.debug('Storing block length %s beginning at index %s for piece %s', block_info[2], block_info[1], block_info[0]) logging.debug('Actual length of block: %s', len(block)) if self.client.torrent_state == 'endgame': piece = self.client.pieces[block_info[0]] piece.cancel_block(block_info, self) self.client.add_block(block_info, block) # After cancel message def clear_requests(self, block_info): pass def add_request_to_queue(self, block_info): if not self.peer_is_choking_client and \ len(self.outstanding_requests) < REQUESTS_PER_PEER: self.send_request_message(block_info) else: logging.info('Adding block %s to request q', block_info) self.request_q.insert(0, block_info) def send_cancel_message(self, block_info): self.add_to_message_queue(CancelMsg(block_info)) def send_request_message(self, block_info): self.outstanding_requests.append(block_info) logging.info('Sending request for block %s', block_info) self.add_to_message_queue(RequestMsg(block_info)) def flush_request_queue(self): '''Move requests from holding queue to reactor message queue''' logging.info('Can flush up to %s requests', REQUESTS_PER_PEER - len(self.outstanding_requests)) logging.info('Request q has %s blocks', len(self.request_q)) while len(self.outstanding_requests) < REQUESTS_PER_PEER and \ len(self.request_q) > 0: next_block_info = self.request_q.pop() logging.info('popped block %s off request q', next_block_info) self.send_request_message(next_block_info) # MESSAGE QUEUE def add_to_message_queue(self, msg): logging.info('adding message %s to queue', msg) self.msg_queue.put(msg) # TODO: Make time last msg sent update when its sent, not added to queue self.update_time_last_msg_sent() def get_from_message_queue(self): if self.msg_queue.empty(): raise Queue.Empty else: return self.msg_queue.get_nowait()
def element_calulator(Pulses): ch1 = [-1] ch2 = [-1] ch3 = [-1] ch4 = [-1] for arg in Pulses: if (arg.channel == 'ch1'): ch1.append(arg.start) ch1.append(arg.end) elif (arg.channel == 'ch2'): ch2.append(arg.start) ch2.append(arg.end) elif (arg.channel == 'ch3'): ch3.append(arg.start) ch3.append(arg.end) elif (arg.channel == 'ch4'): ch4.append(arg.start) ch4.append(arg.end) tot_length = max(max(ch1),max(ch2),max(ch3),max(ch4)) del ch1[0] del ch2[0] del ch3[0] del ch4[0] channel1 = BitArray(int=0, length=tot_length) channel2 = BitArray(int=0, length=tot_length) channel3 = BitArray(int=0, length=tot_length) channel4 = BitArray(int=0, length=tot_length) for x in range(len(ch1)): if (x%2 == 0): channel1.invert(range(ch1[x],ch1[x+1])) else: pass for x in range(len(ch2)): if (x%2 == 0): channel2.invert(range(ch2[x],ch2[x+1])) else: pass for x in range(len(ch3)): if (x%2 == 0): channel3.invert(range(ch3[x],ch3[x+1])) else: pass for x in range(len(ch4)): if (x%2 == 0): channel4.invert(range(ch4[x],ch4[x+1])) else: pass channel1 |= channel2 channel3 |= channel4 channel1 |= channel3 channel1.append('0b0') result = [] count = 0 test = BitArray(int = 0, length = 1) empty = test.find('0b1') while (channel1.len != 0): test = channel1.find('0b1') if (test == empty): break else: result.append(channel1.find('0b1')) result[count] = result[count][0] del channel1[0:result[count]] count = count + 1 test = channel1.find('0b0') if (test == empty): break else: result.append(channel1.find('0b0')) result[count] = result[count][0] del channel1[0:result[count]] count = count + 1 return result
"err_free_24_48_8": (24, 48, 8) } ERR_PERCENTS = { "err_percents_10_20_30": (.10, .20, .30), "err_percents_10_20_40": (.10, .20, .40), "err_percents_10_20_50": (.10, .20, .50), "err_percents_10_30_40": (.10, .30, .40), "err_percents_10_30_50": (.10, .30, .50), "err_percents_20_30_50": (.20, .30, .50), "err_percents_10_50_40": (.10, .50, .40) } for i in range(L): if i % 2 == 0: SAMPLE_ARR.invert(i) FILENAME = 'simulations.cvs' D_FRAME = [] def drop_uniform_errors(sample_arr, percent): ranges = range(L) i = 0 while i <= int(L * percent): i += 1 ch = random.choice(ranges) ranges.remove(ch) sample_arr.invert(ch) return sample_arr
def operatorConvert(op): """ Convert operator from symbol to binary 000 - addition 001 - subtraction 010 - multiplication 011 - division 100 - modulo 101 - power 110 - n choose k 111 - percent of x """ operator = BitArray(3) if op == '+': return operator elif op == '-': operator.invert(2) return operator elif op == '*': operator.invert(1) return operator elif op == '/': operator.invert([1, 2]) return operator elif op == 'mod': operator.invert(0) return operator elif op == '^': operator.invert([0, 2]) return operator elif op == 'nck': operator.invert([0, 1]) return operator elif op == '%': operator.invert([0, 1, 2]) return operator
class ScapySender(Sender): def __init__(self, headerSize, iface): super().__init__(headerSize, iface) self.IP_DST_ADDRESS = "127.0.0.1" self.UDP_PORT = 26381 self.baseTrame = BitArray(bytes(Ether() / IP(dst=self.IP_DST_ADDRESS) / UDP(sport=self.UDP_PORT, dport=self.UDP_PORT + 1))) self.crc32_func = crcmod.mkCrcFun( 0x104c11db7, initCrc=0, xorOut=0xFFFFFFFF) # preparing checksum computation neededArtificialHeader = headerSize - len(self.baseTrame.bytes) - 4 if neededArtificialHeader > 0: headerToAppend = neededArtificialHeader * 'X' self.baseTrame.append(BitArray(bytes(Raw(headerToAppend)))) elif neededArtificialHeader < 0: exit( "The minimal number of bytes your system send to use UDP over IP over Ether is greater than the headerSize you specified:\nspecified: " + str(headerSize) + '\nmin: ' + str( headerSize - neededArtificialHeader)) def send(self): """send loaded packet""" sendp(Raw(self.trame.bytes), verbose=0, iface=self.iface) return self.totalSize # sendErroned is not supposed to alter target payload. to ecnonomise the # copy we just flip back altered bits at the end self.flipBit(int(self.totalSize / 2)) return self.totalSize def setPayload(self, payload): self.flippedBit = [] self.payloadSize = len(payload) payload = Raw(load=payload) self.trame = BitArray(self.baseTrame) self.trame.append(BitArray(bytes(payload))) self.initialCheckSum = self.getFCS() self.trame.append(BitArray(self.initialCheckSum.to_bytes(4, 'little'))) self.initialTrame = BitArray(self.trame) self.computeTotalSize() ''' compute total frame ethernet checksum ''' def getFCS(self): currentChecksum = self.crc32_func(self.trame.bytes) return currentChecksum def computeTotalSize(self): self.totalSize = len(self.trame.bytes) ''' invert the bit at position i in the frame ''' def flipBit(self, position): self.trame.invert(position) # needed for bitwise stuff section ''' reset the frame to match the initial one ''' def resetTrame(self): self.trame = BitArray(self.initialTrame) ''' return true if the current frame checksum match the initial one ''' def checkIfErronned(self): currentCheksum = self.crc32_func( self.trame.bytes[ :- 4]) # ignoring initialchecksum return (currentCheksum != self.initialCheckSum)
def main(): #parser = argparse.ArgumentParser() #parser.add_argument('-d', dest='device', action='store', default="/dev/ttyAMA0", help="Serial device path", required=True) #parser.add_argument('-o', dest='output', action='store', default=None, help="Output file", required=False) #parser.add_argument('-s', dest='stdout', default=1, required=False, help="Print output to stdout") #args = parser.parse_args() #if args.device == None: if 1: GPIO.setmode(GPIO.BOARD) GPIO.setup(bcda0,GPIO.IN) #AZ0 Red BCD0 GPIO.setup(bcda1,GPIO.IN) #AZ1 Blue BCD1 GPIO.setup(bcda2,GPIO.IN) #AZ2 Green BCD2 GPIO.setup(bcda3,GPIO.IN) #AZ3 Yellow BCD3 GPIO.setup(bcdb0,GPIO.IN) #AZ0 Red BCD0 GPIO.setup(bcdb1,GPIO.IN) #AZ1 Blue BCD1 GPIO.setup(bcdb2,GPIO.IN) #AZ2 Green BCD2 GPIO.setup(bcdb3,GPIO.IN) #AZ3 Yellow BCD3 GPIO.setup(bcdc0,GPIO.IN) #AZ0 Red BCD0 GPIO.setup(bcdc1,GPIO.IN) #AZ1 Blue BCD1 GPIO.setup(bcdc2,GPIO.IN) #AZ2 Green BCD2 GPIO.setup(bcdc3,GPIO.IN) #AZ3 Yellow BCD3 digit1 = 0 digit2 = 0 digit3 = 0 while (1): bcd = BitArray('0b0000') if GPIO.input(bcda0): bcd.invert(3) if GPIO.input(bcda1): bcd.invert(2) if GPIO.input(bcda2): bcd.invert(1) if GPIO.input(bcda3): bcd.invert(0) digit1=bcd.uint if digit1 > 9: digit1=0 bcd = BitArray('0b0000') if GPIO.input(bcdb0): bcd.invert(3) if GPIO.input(bcdb1): bcd.invert(2) if GPIO.input(bcdb2): bcd.invert(0) if GPIO.input(bcdb3): bcd.invert(1) digit2=bcd.uint if digit2 > 9: digit2=0 bcd = BitArray('0b0000') if GPIO.input(bcdc0): bcd.invert(3) if GPIO.input(bcdc1): bcd.invert(2) if GPIO.input(bcdc2): bcd.invert(0) if GPIO.input(bcdc3): bcd.invert(1) digit3=bcd.uint if digit3 > 9: digit3=0 bearing = digit1*100 + digit2*10 + digit3 print bearing else: print ("Too many parameters") parser.print_help()
class Client(object): def __init__(self, torrent): self.torrent = torrent self.torrent_state = 'random' self.reactor = Reactor() self.reactor_activated = False self.peer_id = '-TZ-0000-00000000000' self.peers = [] self.decode_torrent_and_setup_pieces() self.handshake = self.build_handshake() self.setup_tracker() self.stitcher = Stitcher(self) self.setup_peers() def decode_torrent_and_setup_pieces(self): f = open(self.torrent, 'r') metainfo = B.bdecode(f.read()) data = metainfo['info'] # Un-bencoded dictionary self.info_hash = H.sha1(B.bencode(data)).digest() self.announce_url = self.find_http_announce_url(metainfo) #self.announce_url = 'http://tracker.ccc.de:6969/announce' self.file_name = data['name'] # Dir name if multi, otherwise file name self.piece_length = data['piece length'] if 'files' in data: # Multifile torrent self.setup_multi_file_info(data) else: self.setup_single_file_info(data) self.setup_download_directory() self.check_if_dload_file_exists() self.setup_pieces(self.piece_length, data['pieces']) def find_http_announce_url(self, metainfo): print metainfo.keys() # print metainfo['announce-list'] if self.is_http_url(metainfo['announce']): return metainfo['announce'] elif 'announce-list' in metainfo.keys(): for url in metainfo['announce-list']: url = url[0] if self.is_http_url(url): print url return url raise SystemExit('UDP announce urls are not supported. Currently only HTTP is supported.') def is_http_url(self, url): return 'http://' in url def setup_multi_file_info(self, metainfo): self.is_multi_file = True self.files = metainfo['files'] # dictionary of file lengths + paths self.file_length = sum([file_dict['length'] for file_dict in self.files]) # file_length = total # bytes to dload def setup_single_file_info(self, metainfo): self.is_multi_file = False self.file_length = metainfo['length'] def build_handshake(self): logging.info('Building handshake') pstr = 'BitTorrent protocol' handshake = struct.pack('B' + str(len(pstr)) + 's8x20s20s', # 8x => reserved null bytes len(pstr), pstr, self.info_hash, self.peer_id ) assert handshake != None assert len(handshake) == 49 + len(pstr) logging.info('Handshake constructed.') return handshake def setup_tracker(self): self.tracker = Tracker(self, self.announce_url) def setup_peers(self): peer_ips = self.tracker.send_request_and_parse_response() self.connect_to_peers(peer_ips) def connect_to_peers(self, peer_tuples): peers = [Peer(ip, port, self) for ip, port in peer_tuples] logging.debug('Attempting to connect to peers %s', peer_tuples) for peer in peers: try: if peer.ip == self.get_self_ip(): logging.info('Skipping peer; cannot connect to self') continue peer.connect() peer_handshake = peer.send_and_receive_handshake(self.handshake) logging.debug('Handshake returned.') if peer.verify_handshake(peer_handshake, self.info_hash): logging.debug('Handshake verified. Adding peer to peer list') self.add_peer(peer) if not self.reactor_activated: self.activate_reactor() self.reactor_activated = True except IOError as e: logging.warning('Error in construct_peers! %s', e) self.manage_requests(5) def get_self_ip(self): # http://stackoverflow.com/questions/166506/finding-local-ip-addresses-using-pythons-stdlib/166520#166520 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('8.8.8.8', 80)) ip = s.getsockname()[0] s.close() return ip def add_peer(self, peer): logging.info('Adding peer %s to peer list (in add_peer)', peer) self.peers.append(peer) self.reactor.add_peer_socket(peer) def activate_reactor(self): logging.debug('Activating reactor.') self.reactor.get_data() def process_raw_hash_list(self, hash_list, size): tmp_hash = '' piece_hashes = [] for char in hash_list: if len(tmp_hash) < size: tmp_hash = tmp_hash + char else: piece_hashes.append(tmp_hash) tmp_hash = char piece_hashes.append(tmp_hash) return piece_hashes def setup_pieces(self, length, hash_bytes): hash_list = self.process_raw_hash_list(hash_bytes, 20) logging.info('setting up pieces for file length, %s', length) pieces = [] self.num_pieces = len(hash_list) logging.info('dividing up file into %s pieces', self.num_pieces) self.bitfield = BitArray(self.num_pieces) last_piece_length = self.file_length - (self.num_pieces - 1) * length for i in range(self.num_pieces): if i == self.num_pieces - 1: length = last_piece_length pieces.append(Piece(self, i, length, hash_list[i], self.dload_dir)) self.pieces = pieces self.piece_queue = PieceQueue(pieces) def setup_download_directory(self): dir_name = self.torrent if dir_name.endswith('.torrent'): dir_name = dir_name[:-8] self.dload_dir = os.path.join(os.path.abspath(os.curdir), dir_name) try: os.makedirs(self.dload_dir) except OSError: if not os.path.isdir(self.dload_dir): raise SystemExit('Cannot create directory to download torrent files into. Please check if a file named ' + dir_name + ' exists') # raise OSError('Cannot create directory to download torrent files to.') def check_if_dload_file_exists(self): file_path = os.path.join(self.dload_dir, self.file_name) if os.path.exists(file_path): raise SystemExit('This file has already been downloaded.') # Do something to cancel the rest of the setup def add_piece_to_queue(self, piece): self.piece_queue.put(piece) def add_piece_to_bitfield(self, index): if not self.bitfield[index]: self.bitfield.invert(index) self.manage_requests() else: logging.warning('Should never get save same piece more than once!') def add_peer_to_piece_peer_list(self, piece_index, peer): # print 'Adding piece', piece_index, 'to peer', peer self.pieces[piece_index].add_peer_to_peer_list(peer) def manage_requests(self, num_pieces=1): logging.info('Sending more piece requests') logging.info('Piece queue has %s pieces', self.piece_queue.length()) if not self.piece_queue.empty(): self.manage_piece_queue_state(); for i in xrange(num_pieces): self.request_next_piece(); logging.info('Cleaning up piece queue') else: # Count outstanding requests to decide when to go into endgame self.torrent_state = 'endgame' self.start_endgame() def start_endgame(self): self.blasted_requests = [] for i in xrange(ENDGAME_MAX_BLASTS): self.send_endgame_request() def send_endgame_request(self): block_info = self.select_outstanding_request() if block_info: self.blasted_requests.append(block_info) self.pieces(block_info[0]).request_block_endgame(block_info) def select_outstanding_request(self): # TODO: Use filter instead of picking at random peers_with_requests = filter(lambda peer: len(peer.outstanding_requests) > 0, self.peers) if len(peers_with_requests): peer = random.choice(peers_with_requests) block_info = random.choice(peer.outstanding_requests) return block_info def manage_piece_queue_state(self): # This should probably only get called occasionally logging.debug('Have received %s pieces, need %s more', self.bitfield.count(1), self.bitfield.count(0)) if self.bitfield.count(1) > PIECE_THRESHOLD and self.piece_queue.length() > PIECE_THRESHOLD: self.piece_queue.update_piece_order() self.torrent_state = 'rarest_first' # DISPATCHES TO PIECE def request_block(self, block_info): piece_index = block_info[0] self.pieces[piece_index].request_block(block_info) def request_next_piece(self): next_piece = self.piece_queue.get_next_piece(self.torrent_state) logging.info('Requesting piece %s', next_piece) if next_piece: try: next_piece.request_all_blocks() except IndexError as e: self.piece_queue.put(next_piece) logging.error(e) def add_block(self, block_info, block): (piece_index, begin, block_length) = block_info logging.info('Writing block of length %s at index %s for piece %s', block_length, begin, piece_index) piece = self.pieces[piece_index] logging.info('Piece has index %s', piece.index) piece.add_block(begin, block) self.tracker.update_download_stats(block_length) if self.torrent_state == 'endgame' and block_info in self.blasted_requests: piece = self.pieces[block_info[0]] piece.cancel_block(block_info, self) if self.bitfield.count(0) > 0: self.send_endgame_request() if self.num_pieces - self.bitfield.count(1) == 0: self.finalize_download() def finalize_download(self): logging.info('Finalizing download') if not self.tracker.is_download_complete(): raise SystemExit('Download didnt complete. Shutting down.') self.stitch_files() self.tracker.send_completed_msg_to_tracker_server() logging.info('Shutting down connection with peers') for peer in self.peers: peer.close() print 'Quitting client' logging.info('Download completed. Quitting client.') sys.exit() def stitch_files(self): print 'stitching...' logging.info('Wrote all pieces, stitching them together') self.stitcher.stitch() logging.info('Stitching completed.') def finalize_piece(self, piece): if piece.check_info_hash(): logging.debug('Yay! Correct info hash!') self.add_piece_to_bitfield(piece_index) else: logging.debug('Incorrect infohash, starting over with piece %s', piece_index) piece.reset()
def main(): file = open(sys.argv[1], "rb") msg = ConstBitStream(file) s_in = BitArray() aux = BitArray() keys = [''] s_out = '' s_in.append(msg.read(1)) aux = s_in.copy() aux.invert(0) count = 0 #Encontrar o tamanho do padding while (s_in.bin) != aux.bin: try: count += 1 s_in.clear() s_in.append(msg.read(1)) except ReadError: break padding = BitArray() padding.append(s_in) s_in = BitArray() #Com o tamanho encontrar o padding correspondente padding.append(msg.read(count - 1)) while True: n_bits = ceil(log2(len(keys))) try: s_in.append(msg.read(n_bits + 1)) except ReadError: break y = s_in[:-1] b = s_in[-1:] if Bits(y) == Bits(''): pos = 0 else: pos = y.uint s_out = s_out + (str(keys[pos]) + b.bin) keys.append(str(keys[pos]) + str(Bits(b).bin)) s_in = BitArray() output = BitArray('0b' + s_out) output.append(padding) with open(sys.argv[2], 'wb') as f_out: output.tofile(f_out) file.close()
def make_mistake(data, position): temp_data = BitArray(data) temp_data.invert(pos=position) return temp_data.tobytes()
for (index_bits, fill_perc) in sets: size = pow(2, index_bits) fill_count = round(fill_perc * size / 100) inv_count = size - fill_count if fill_perc > 50 else fill_count # slower method # registry.invert(range(0, fill_count)) # random.shuffle(registry) if fill_perc == 50: registry = BitArray(os.urandom(size // 8)) filled = registry.count(1) if filled > fill_count: registry.invert() filled = size - filled else: filled = 0 registry = BitArray(length=size) for _ in range(index_bits): registry.set(1, random.choices(range(0, size), k=(inv_count - filled))) filled = registry.count(1) if inv_count - filled < 10: break while filled < inv_count: pos = random.randrange(size) if not registry[pos]: registry.set(1, pos)
Divisor.bin, sep="") if counter != REGSIZE - 1: #Shift the Remainder register left 1 bit Rem.int <<= 1 print( 'shift remainder register left 1 bit, setting the new least significant bit to 0:\n', Rem.bin, '-', Quotient.bin, '-', Divisor.bin, sep="") print('Result of division w/o checking sign:\n', Rem.bin, '-', Quotient.bin, '-', Divisor.bin, sep="") if MINUS: print('Result should be minus:') Quotient.invert() Quotient.int += 1 Rem = BitArray(Rem[:REGSIZE]) Rem.invert() Rem.int += 1 print('Result with checking sign:\nQuotient:', Quotient.int, '+ Remainder:', Rem[:REGSIZE].int)