def test_function(self):
# Test for all inputs
it = itertools.product([0, 1], [0, 1], [0, 1])
for x in it:
src = sources.digital_source_circuit(x)
a = adders.full_adder_circuit()
circuit.connect_circuits(src, a, {0: 0, 1: 1, 2: 2})
num = int("".join(map(str, a.evaluate())), 2)
self.assertEqual(sum(x), num)
def test_many_to_one(self):
a = base.ComponentBase('a', 3)
b = base.ComponentBase('b', 0)
c = base.ComponentBase('c', 0)
d = base.ComponentBase('d', 0)
c1 = circuit.Circuit('c1', 0, 3)
c2 = circuit.Circuit('c2', 3, 0)
c1._outputs = [b, c, d]
c2._inputs = [[(a, 0)], [(a, 1)], [(a, 2)]]
circuit.connect_circuits(c1, c2, {0: 0, 1: 1, 2: 2})
self.assertEqual([b, c, d], a._input_bits)
def test_many_to_many(self):
a = base.ComponentBase('a', 0)
b = base.ComponentBase('b', 0)
c = base.ComponentBase('c', 2)
d = base.ComponentBase('d', 2)
c1 = circuit.Circuit('c1', 0, 4)
c2 = circuit.Circuit('c2', 4, 0)
c1._outputs = [a, b, a, b]
c2._inputs = [[(c, 0)], [(d, 0)], [(c, 1)], [(d, 1)]]
circuit.connect_circuits(c1, c2, {0: 0, 1: 1, 2: 2, 3: 3})
self.assertEqual([a, a], c._input_bits)
self.assertEqual([b, b], d._input_bits)
def test_one_to_one(self):
a = base.ComponentBase('a', 0)
b = base.ComponentBase('b', 0)
c = base.ComponentBase('c', 1)
d = base.ComponentBase('d', 1)
c1 = circuit.Circuit('c1', 0, 2)
c2 = circuit.Circuit('c2', 2, 0)
c1._outputs = [a, b]
c2._inputs = [[(c, 0)], [(d, 0)]]
circuit.connect_circuits(c1, c2, {0: 0, 1: 1})
self.assertEqual([a], c._input_bits)
self.assertEqual([b], d._input_bits)
def test_function(self):
# Test all possible operations up to 8 bits
for l in xrange(2, 9):
space = [[0, 1] for _ in xrange(0, l)]
it1 = itertools.product(*space)
for x in it1:
c = bitwise.bitwise_not_circuit(l)
n = int(''.join(map(lambda y: '0' if y else '1', x)), 2)
source_c = sources.digital_source_circuit(x)
circuit.connect_circuits(source_c, c,
{i: i for i in xrange(0, l)})
result = int(''.join(map(str, c.evaluate())), 2)
self.assertEqual(n, result)
def test_specific(self):
a = 0xE8A4602C
b = 0x98BADCFE
al = map(int, list(bin(a)[2:]))
bl = map(int, list(bin(b)[2:]))
while len(al) < 32:
al.insert(0, 0)
while len(bl) < 32:
bl.insert(0, 0)
src = sources.digital_source_circuit(al + bl)
adder = adders.ripple_adder_no_carry(32)
circuit.connect_circuits(src, adder, {i: i for i in xrange(0, 64)})
num = int("".join(map(str, adder.evaluate())), 2)
self.assertEqual((a + b) % (1 << 32), num)
def test_function(self):
# Test all possible operations up to 8 bits
for l in xrange(2, 9):
space = [[0, 1] for _ in xrange(0, l)]
it1 = itertools.product(*space)
it2 = itertools.product(*space)
for x in it1:
for y in it2:
c = bitwise.bitwise_and_circuit(l)
n1 = int(''.join(map(str, x)), 2)
n2 = int(''.join(map(str, y)), 2)
source_c = sources.digital_source_circuit(x + y)
circuit.connect_circuits(source_c, c,
{i: i for i in xrange(0, 2 * l)})
result = int(''.join(map(str, c.evaluate())), 2)
self.assertEqual(n1 & n2, result)
def test_function(self):
# Test for all inputs up to 8 bits
for l in xrange(2, 9):
space = [[0, 1] for _ in xrange(0, l)]
it1 = itertools.product(*space)
it2 = itertools.product(*space)
for x in it1:
for y in it2:
n1 = int("".join(map(str, x)), 2)
n2 = int("".join(map(str, y)), 2)
mapping = {i: i for i in xrange(0, 2 * l)}
src = sources.digital_source_circuit(x + y)
a = adders.ripple_adder_no_carry(l)
circuit.connect_circuits(src, a, mapping)
num = int("".join(map(str, a.evaluate())), 2)
self.assertEqual("%dAdd" % l, a.name)
self.assertEqual((n1 + n2) % (2 ** l), num)
def block_operation(chunk, h0, h1, h2, h3, h4, rounds=80):
"""
Returns (h0, h1, h2, h3, h4), the h-constants that result from running
the SHA-1 algorithm on one block.
"""
a, b, c, d, e = h0, h1, h2, h3, h4
w = create_words(chunk, rounds)
# Main loop here
for i in xrange(0, rounds):
if 0 <= i <= 19:
# f = (b and c) or ((not b) and d)
b_and_c = bitwise_and_circuit(32)
connect_circuits(b, b_and_c, {x: x for x in xrange(0, 32)})
connect_circuits(c, b_and_c, {x: x + 32 for x in xrange(0, 32)})
not_b = bitwise_not_circuit(32)
connect_circuits(b, not_b, {x: x for x in xrange(0, 32)})
not_b_and_d = bitwise_and_circuit(32)
connect_circuits(not_b, not_b_and_d, {x: x for x in xrange(0, 32)})
connect_circuits(d, not_b_and_d, {x: x + 32 for x in xrange(0, 32)})
f = bitwise_or_circuit(32)
connect_circuits(b_and_c, f, {x: x for x in xrange(0, 32)})
connect_circuits(not_b_and_d, f, {x: x + 32 for x in xrange(0, 32)})
k = digital_source_int_circuit(0x5A827999, 32)
elif 20 <= i <= 39:
# f = b xor c xor d
b_xor_c = bitwise_xor_circuit(32)
connect_circuits(b, b_xor_c, {x: x for x in xrange(0, 32)})
connect_circuits(c, b_xor_c, {x: x + 32 for x in xrange(0, 32)})
f = bitwise_xor_circuit(32)
connect_circuits(b_xor_c, f, {x: x for x in xrange(0, 32)})
connect_circuits(d, f, {x: x + 32 for x in xrange(0, 32)})
k = digital_source_int_circuit(0x6ED9EBA1, 32)
elif 40 <= i <= 59:
# f = (b and c) or (b and d) or (c and d)
b_and_c = bitwise_and_circuit(32)
connect_circuits(b, b_and_c, {x: x for x in xrange(0, 32)})
connect_circuits(c, b_and_c, {x: x + 32 for x in xrange(0, 32)})
b_and_d = bitwise_and_circuit(32)
connect_circuits(b, b_and_d, {x: x for x in xrange(0, 32)})
connect_circuits(d, b_and_d, {x: x + 32 for x in xrange(0, 32)})
c_and_d = bitwise_and_circuit(32)
connect_circuits(c, c_and_d, {x: x for x in xrange(0, 32)})
connect_circuits(d, c_and_d, {x: x + 32 for x in xrange(0, 32)})
bnc_or_bnd = bitwise_or_circuit(32)
connect_circuits(b_and_c, bnc_or_bnd, {x: x for x in xrange(0, 32)})
connect_circuits(b_and_d, bnc_or_bnd, {x: x + 32 for x in xrange(0, 32)})
f = bitwise_or_circuit(32)
connect_circuits(bnc_or_bnd, f, {x: x for x in xrange(0, 32)})
connect_circuits(c_and_d, f, {x: x + 32 for x in xrange(0, 32)})
k = digital_source_int_circuit(0x8F1BBCDC, 32)
elif 60 <= i <= 79:
# f = b xor c xor d
b_xor_c = bitwise_xor_circuit(32)
connect_circuits(b, b_xor_c, {x: x for x in xrange(0, 32)})
connect_circuits(c, b_xor_c, {x: x + 32 for x in xrange(0, 32)})
f = bitwise_xor_circuit(32)
connect_circuits(b_xor_c, f, {x: x for x in xrange(0, 32)})
connect_circuits(d, f, {x: x + 32 for x in xrange(0, 32)})
k = digital_source_int_circuit(0xCA62C1D6, 32)
else:
raise Exception("Invalid word index in main loop!")
# (a leftrotate 5) + f
temp = ripple_adder_no_carry(32)
connect_circuits(a, temp, {x: x - 5 for x in xrange(5, 32)})
connect_circuits(a, temp, {x: x + 27 for x in xrange(0, 5)})
connect_circuits(f, temp, {x: x + 32 for x in xrange(0, 32)})
# result + e
temp2 = ripple_adder_no_carry(32)
connect_circuits(temp, temp2, {x: x for x in xrange(0, 32)})
connect_circuits(e, temp2, {x: x + 32 for x in xrange(0, 32)})
# result + k
temp = ripple_adder_no_carry(32)
connect_circuits(temp2, temp, {x: x for x in xrange(0, 32)})
connect_circuits(k, temp, {x: x + 32 for x in xrange(0, 32)})
# result + w[i]
temp2 = ripple_adder_no_carry(32)
connect_circuits(temp, temp2, {x: x for x in xrange(0, 32)})
connect_circuits(w[i][0], temp2, {x: y for (x, y) in izip(w[i][1], xrange(32, 64))})
# temp = (a leftrotate 5) + f + e + k + w[i]
temp = temp2
e = d
d = c
c = left_rotate(b, 30)
b = a
a = temp
h0_add = ripple_adder_no_carry(32)
connect_circuits(h0, h0_add, {i: i for i in xrange(0, 32)})
connect_circuits(a, h0_add, {i: i + 32 for i in xrange(0, 32)})
h1_add = ripple_adder_no_carry(32)
connect_circuits(h1, h1_add, {i: i for i in xrange(0, 32)})
connect_circuits(b, h1_add, {i: i + 32 for i in xrange(0, 32)})
h2_add = ripple_adder_no_carry(32)
connect_circuits(h2, h2_add, {i: i for i in xrange(0, 32)})
connect_circuits(c, h2_add, {i: i + 32 for i in xrange(0, 32)})
h3_add = ripple_adder_no_carry(32)
connect_circuits(h3, h3_add, {i: i for i in xrange(0, 32)})
connect_circuits(d, h3_add, {i: i + 32 for i in xrange(0, 32)})
h4_add = ripple_adder_no_carry(32)
connect_circuits(h4, h4_add, {i: i for i in xrange(0, 32)})
connect_circuits(e, h4_add, {i: i + 32 for i in xrange(0, 32)})
return h0_add, h1_add, h2_add, h3_add, h4_add
def create_words(chunk, rounds=80):
w = [None] * rounds
for i in xrange(0, min(rounds, 16)):
w[i] = (chunk, xrange(i * 32, i * 32 + 32))
for i in xrange(16, min(rounds, 80)):
# w[i] = (w[i-3] xor w[i-8] xor w[i-14] xor w[i-16]) leftrotate 1
xtemp = bitwise_xor_circuit(32)
connect_circuits(w[i - 3][0], xtemp, {
x: y for (x, y) in izip(w[i - 3][1], xrange(0, 32))
})
connect_circuits(w[i - 8][0], xtemp, {
x: y for (x, y) in izip(w[i - 8][1], xrange(32, 64))
})
# result xor w[i - 14]
xtemp2 = bitwise_xor_circuit(32)
connect_circuits(xtemp, xtemp2, {x: x for x in xrange(0, 32)})
connect_circuits(w[i - 14][0], xtemp2, {
x: y for (x, y) in izip(w[i - 14][1], xrange(32, 64))
})
# result xor w[i - 16]
xtemp = bitwise_xor_circuit(32)
connect_circuits(xtemp2, xtemp, {x: x for x in xrange(0, 32)})
connect_circuits(w[i - 16][0], xtemp, {
x: y for (x, y) in izip(w[i - 16][1], xrange(32, 64))
})
# leftrotate 1
word = left_rotate(xtemp, 1)
w[i] = (word, xrange(0, 32))
return w
