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 _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)
