def guess_keysize(data, n=3):
diffs = []
for i in keysize:
b1 = data[:i]
b2 = data[i:i*2]
b3 = data[i*2:i*3]
b4 = data[i*3:i*4]
dist = (hamming(b1, b2) + hamming(b2, b3) + hamming(b3, b4) + hamming(b4, b2)) / 4.
diff = (dist / float(i), i)
diffs.append(diff)
diffs = sorted(diffs)
print diffs
return [x[1] for x in diffs[:n]]
def motif_ham_score(pattern, dnas):
'''
'''
scores = []
k = len(pattern)
for dna in dnas:
scores.append(min([util.hamming(pattern, s) for s in util.kmer_gen(dna, k)]))
return sum(scores)
def test1():
s1 = b"this is a test"
s2 = b"wokka wokka!!!"
b1 = util.byte2bit(s1)
b2 = util.byte2bit(s2)
print ("-------------------beg test1-------------")
print (util.hamming(b1, b2))
print (util.bit2byte(b1).decode())
print (util.bit2byte(b2).decode())
print ("-------------------end test1-------------")
def test1():
s1 = b"this is a test"
s2 = b"wokka wokka!!!"
b1 = util.byte2bit(s1)
b2 = util.byte2bit(s2)
print("-------------------beg test1-------------")
print(util.hamming(b1, b2))
print(util.bit2byte(b1).decode())
print(util.bit2byte(b2).decode())
print("-------------------end test1-------------")
def approximate_pattern(text, pattern, d):
'''
get the starting positions of all patterns with at most d mismatches in the text
:param str text: the genome to be analyzed
:param str pattern: the pattern to be detected
:param int d: mismatches allowed
:return: a list of starting positions
:rtype: [`int`, ...]
'''
pos = []
for i, kmer in enumerate(util.kmer_gen(text, len(pattern))):
if util.hamming(pattern, kmer) <= d:
pos.append(i)
return pos
def guessKeySize(b): maxSize = 41 keySizeScore = [] for n in range(2, maxSize): score = 0.0 x = 2*n repeat = (len(b)//n)//4 for i in range(int(repeat)): bstr1 = b[(i*x):((i+1)*x)] bstr2 = b[((i+2)*x):((i+3)*x)] #print n, i, str1, str2 bit1 = util.byte2bit(bstr1) bit2 = util.byte2bit(bstr2) score += util.hamming(bit1, bit2) keySizeScore.append((n, float(score)/n/repeat)) return keySizeScore
def guessKeySize(b):
maxSize = 41
keySizeScore = []
for n in range(2, maxSize):
score = 0.0
x = 2 * n
repeat = (len(b) // n) // 4
for i in range(int(repeat)):
bstr1 = b[(i * x):((i + 1) * x)]
bstr2 = b[((i + 2) * x):((i + 3) * x)]
#print n, i, str1, str2
bit1 = util.byte2bit(bstr1)
bit2 = util.byte2bit(bstr2)
score += util.hamming(bit1, bit2)
keySizeScore.append((n, float(score) / n / repeat))
return keySizeScore
def diameter(self, label):
max_dists = []
for table in self:
buckets_containing_label = [
bucket
for bucket in self[0].values()
if any(map(lambda x: x.filter_label(label), bucket.points))
]
max_dist = 0
for pair in combinations(buckets_containing_label, 2):
dist = hamming(*map(lambda x: x.address, pair))
if dist > max_dist:
max_dist = dist
max_dists.append(max_dist)
return max_dists
def run(config):
'''Primary Audiocom functionality.'''
# Create the preamble to pre-pend to the transmission
preamble = Preamble(config)
# Create the sources
sources = {}
for i in range(len(config.channels)):
frequency = config.channels[i]
source = Source(config, i)
print("Channel: %d Hz" % frequency)
print("\n".join(["\t%s" % source]))
sources[frequency] = source
# Create a sender for each source, so we can process the bits to
# get the modulated samples. We combine all of the modulated
# samples into a single array by adding them.
baseband_samples = []
modulated_samples = []
for frequency in sources:
src = sources[frequency]
sender = Sender(frequency, preamble, config)
sender.set_source(src)
modulated_samples = util.add_arrays(sender.modulated_samples(),
modulated_samples)
baseband_samples = util.add_arrays(sender.bits_to_samples(src.payload),
baseband_samples)
print("sending %d samples" % len(modulated_samples))
# Create the channel
if config.bypass:
channel = AbstractChannel(config.bypass_noise, config.bypass_h)
else:
channel = AudioChannel(config)
# Transmit and receive data on the channel. The received samples
# (samples_rx) have not been processed in any way.
samples_rx = channel.xmit_and_recv(modulated_samples)
print('Received', len(samples_rx), 'samples')
for frequency in config.channels:
r = Receiver(frequency, preamble, config)
try:
# Call the main receiver function. The returned array of bits
# EXCLUDES the preamble.
bits = r.process(samples_rx)
# Push into a Sink so we can convert back to a useful payload
# (this step will become more useful when we're transmitting
# files or images instead of just bit arrays)
src = sources[frequency]
sink = Sink(src)
received_payload = sink.process(bits)
print("Received %d data bits" % len(received_payload))
if src.type == Source.TEXT:
print("Received text was:", sink.received_text)
if len(received_payload) > 0:
# Output BER
hd = util.hamming(received_payload, src.payload)
ber = float(hd) / len(received_payload)
print('BER:', ber)
else:
print('Could not recover transmission.')
except Exception as e:
# In general, this is a fatal exception. But we'd still like
# to look at the graphs, so we'll continue with that output
# print('*** ERROR: Could not detect preamble. ***')
print(repr(e))
if config.graphs == "time":
graphs.plot_samples(baseband_samples,
modulated_samples,
r.graph_info.received_samples,
stems=False)
elif config.graphs == "freq":
graphs.plot_sig_spectrum(modulated_samples,
r.graph_info.demod_samples)
elif config.graphs == "usr":
graphs.plot_usr(r.graph_info.demod_samples)
def pattern_pos(Text, Pattern, d = 0):
positions = []
for i in range(len(Text) - len(Pattern) + 1):
if hamming(Text[i : i + len(Pattern)], Pattern) <= d:
positions.append(i)
return positions
bytes = [ord(ch) for ch in base64.standard_b64decode(data)] print bytes[:64] NUM_BLOCKS = int(sys.argv[1]) distances = [] for keysize in range(2, 40): blocks = [] for i in range(NUM_BLOCKS): block = bytes[i * keysize:(i + 1) * keysize] blocks.append(block) total = 0 count = 0 for block1, block2 in itertools.combinations(blocks, 2): distance = hamming(block1, block2) total += distance / float(keysize) count += 1 avg = total / count # print keysize, avg distances.append((avg, keysize)) distances.sort() distances = distances[:3] print distances for distance, keysize in distances[:1]: print keysize blocks = [] start = 0
def run(config):
'''Primary Audiocom functionality.'''
# Create the preamble to pre-pend to the transmission
preamble = Preamble(config)
# Create the sources
sources = {}
for i in range(len(config.channels)):
frequency = config.channels[i]
source = Source(config, i)
print "Channel: %d Hz" % frequency
print "\n".join(["\t%s" % source])
sources[frequency] = source
# Create a sender for each source, so we can process the bits to
# get the modulated samples. We combine all of the modulated
# samples into a single array by adding them.
modulated_samples = []
for frequency in sources:
src = sources[frequency]
sender = Sender(frequency, preamble, config)
sender.set_source(src)
modulated_samples = util.add_arrays(sender.modulated_samples(), modulated_samples)
# Create the channel
if config.bypass:
channel = AbstractChannel(config.bypass_noise, config.bypass_h, config.bypass_lag)
else:
channel = AudioChannel(config)
# Transmit and receive data on the channel. The received samples
# (samples_rx) have not been processed in any way.
samples_rx = channel.xmit_and_recv(modulated_samples)
print 'Received', len(samples_rx), 'samples'
for frequency in config.channels:
r = Receiver(frequency, preamble, config)
try:
# Call the main receiver function. The returned array of bits
# EXCLUDES the preamble.
bits = r.process(samples_rx)
# Push into a Sink so we can convert back to a useful payload
# (this step will become more useful when we're transmitting
# files or images instead of just bit arrays)
src = sources[frequency]
sink = Sink(src)
received_payload = sink.process(bits)
print "Received %d data bits" % len(received_payload)
if src.type == Source.TEXT:
print "Received text was:", sink.received_text
if len(received_payload) > 0:
# Output BER
hd = util.hamming(received_payload, src.payload)
ber = float(hd)/len(received_payload)
print 'BER:', ber
else:
print 'Could not recover transmission.'
except Exception as e:
# In general, this is a fatal exception. But we'd still like
# to look at the graphs, so we'll continue with that output
print '*** ERROR: Could not detect preamble. ***'
print repr(e)
# Plot graphs if necessary
if config.graphs:
try:
len_demod = config.spb * (len(received_payload) + preamble.preamble_data_len())
except:
# If we didn't receive the payload, make a reasonable guess for the number of bits
# (won't work for filetype, where n_bits changes)
len_demod = config.spb * (config.n_bits + preamble.preamble_data_len())
if config.demod_type == Receiver.QUADRATURE:
filtered = r.graph_info.demod_samples
graphs.plot_sig_spectrum(samples_rx, filtered, "received samples", "filtered samples")
elif config.src_type == Source.U:
demod_samples = r.graph_info.demod_samples
plotrange = preamble.preamble_data_len()*config.spb
graphs.plot_samples(demod_samples[plotrange:len_demod], 'unit-step response', show=True)
else:
graphs.plot_graphs(r.graph_info.demod_samples[:len_demod], r.graph_info.hist_samples[:len_demod], config.spb, preamble)
from util import hamming, single_xor, encrypt_repeating_key_xor
print hamming('this is a test', 'wokka wokka!!!')
keysize = range(2, 41)
# return a list of the top n most likely keysizes
def guess_keysize(data, n=3):
diffs = []
for i in keysize:
b1 = data[:i]
b2 = data[i:i*2]
b3 = data[i*2:i*3]
b4 = data[i*3:i*4]
dist = (hamming(b1, b2) + hamming(b2, b3) + hamming(b3, b4) + hamming(b4, b2)) / 4.
diff = (dist / float(i), i)
diffs.append(diff)
diffs = sorted(diffs)
print diffs
return [x[1] for x in diffs[:n]]
def transpose(data, keysize):
blocks = []
for j in range(keysize):
b = []
for i in range(j, len(data), keysize):
b.append(data[i])
blocks.append(''.join(b))
return blocks
def solve_block(block):
letters = set(map(chr, range(65, 123)))
def pattern_pos(Text, Pattern, d=0):
positions = []
for i in range(len(Text) - len(Pattern) + 1):
if hamming(Text[i:i + len(Pattern)], Pattern) <= d:
positions.append(i)
return positions
def pattern_count(text, pattern, d=0):
return sum([util.hamming(kmer, pattern) <= d for kmer in util.kmer_gen(text, len(pattern))])
def run(config):
'''Primary Audiocom functionality.'''
# Create the preamble to pre-pend to the transmission
preamble = Preamble(config)
# Create a source
source = Source(config)
frequency = config.channel
print "Channel: %d Hz" % frequency
print "\n".join(["\t%s" % source])
# Create the Sender for this Source. Process the bits to get
# modulated samples.
sender = Sender(frequency, preamble, config)
sender.set_source(source)
modulated_samples = sender.modulated_samples()
# Create the channel
if config.bypass:
channel = AbstractChannel(config.bypass_noise, config.bypass_h)
else:
channel = AudioChannel(config)
# Transmit and receive data on the channel. The received samples
# (samples_rx) have not been processed in any way.
samples_rx = channel.xmit_and_recv(modulated_samples)
print 'Received', len(samples_rx), 'samples'
r = Receiver(frequency, preamble, config)
try:
# Call the main receiver function. The returned array of bits
# EXCLUDES the preamble.
bits = r.process(samples_rx)
# Push into a Sink so we can convert back to a useful payload
# (this step will become more useful when we're transmitting
# files or images instead of just bit arrays)
sink = Sink(source)
received_payload = sink.process(bits)
print "Received %d data bits" % len(received_payload)
if len(received_payload) > 0:
# Output BER
hd = util.hamming(received_payload, source.payload)
ber = float(hd)/len(received_payload)
print 'BER:', ber
else:
print 'Could not recover transmission.'
except Exception as e:
# In general, this is a fatal exception. But we'd still like
# to look at the graphs, so we'll continue with that output
print '*** ERROR: Could not detect preamble. ***'
# Plot graphs if necessary
if config.graphs:
try:
len_demod = config.spb * (len(received_payload) + preamble.preamble_data_len())
except:
# If we didn't receive the payload, make a reasonable guess for the number of bits
len_demod = config.spb * (config.n_bits + preamble.preamble_data_len())
if config.src_type == Source.U:
demod_samples = r.graph_info.demod_samples
plotrange = preamble.preamble_data_len()*config.spb
graphs.plot_samples(demod_samples[plotrange:len_demod], 'unit-step response', show=True)
else:
graphs.plot_graphs(r.graph_info.demod_samples[:len_demod], r.graph_info.hist_samples[:len_demod], config.spb, preamble)
