Exemplo n.º 1
0
def rowxcol(row, col):
    """Multiply one row and one column."""
    row = row.reshape(4, 4)
    col = col.reshape(4, 8)
    ret = uint2exprs(0, 8)
    for i in range(4):
        for j in range(4):
            if row[i, j]:
                ret ^= xtime(col[i], j)
    return ret
Exemplo n.º 2
0
def rowxcol(row, col):
    """Multiply one row and one column."""
    row = row.reshape(4, 4)
    col = col.reshape(4, 8)
    ret = uint2exprs(0, 8)
    for i in range(4):
        for j in range(4):
            if row[i, j]:
                ret ^= xtime(col[i], j)
    return ret
Exemplo n.º 3
0
def test_uint2exprs():
    assert_raises(ValueError, uint2exprs, -1)
    assert_raises(ValueError, uint2exprs, 42, 4)
    assert str(uint2exprs(0)) == "farray([0])"
    assert str(uint2exprs(1)) == "farray([1])"
    assert str(uint2exprs(2)) == "farray([0, 1])"
    assert str(uint2exprs(3)) == "farray([1, 1])"
    assert str(uint2exprs(4)) == "farray([0, 0, 1])"
    assert str(uint2exprs(4, 4)) == "farray([0, 0, 1, 0])"
Exemplo n.º 4
0
def test_bin2gray():
    B = exprvars('B', 4)
    G = bin2gray(B)
    gnums = [G.vrestrict({B: uint2exprs(i, 4)}).to_uint() for i in range(16)]
    assert gnums == [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]
Exemplo n.º 5
0
def test_gray2bin():
    G = exprvars('G', 4)
    B = gray2bin(G)
    gnums = [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]
    bnums = [B.vrestrict({G: uint2exprs(i, 4)}).to_uint() for i in gnums]
    assert bnums == list(range(16))
Exemplo n.º 6
0
def xtime(b, n):
    """Repeated polynomial multiplication in GF(2^8)."""
    b = b.reshape(8)
    for _ in range(n):
        b = exprzeros(1) + b[:7] ^ uint2exprs(0x1b, 8) & b[7]*8
    return b
Exemplo n.º 7
0
_MA = [
    0x2311,
    0x1231,
    0x1123,
    0x3112,
]

_IMA = [
    0xebd9,
    0x9ebd,
    0xd9eb,
    0xbd9e,
]

# 16x16x8
SBOX = fcat(*[uint2exprs(x, 8) for x in _SBOX]).reshape(256, 8)
ISBOX = fcat(*[uint2exprs(x, 8) for x in _ISBOX]).reshape(256, 8)

# 255
RCON = fcat(*[uint2exprs(x, 8) for x in _RCON]).reshape(255, 8)

# 4x16
MA = fcat(*[uint2exprs(x, 16) for x in _MA]).reshape(4, 16)
IMA = fcat(*[uint2exprs(x, 16) for x in _IMA]).reshape(4, 16)

def subword(w):
    """
    Function used in the Key Expansion routine that takes a four-byte input word
    and applies an S-box to each of the four bytes to produce an output word.
    """
    w = w.reshape(4, 8)
Exemplo n.º 8
0
def test_farray():
    # expected shape volume to match items
    assert_raises(ValueError, farray, [X[0], X[1]], shape=((0, 42), ))
    # could not determine ftype parameter
    assert_raises(ValueError, farray, [])
    # expected ftype to be a type
    assert_raises(TypeError, farray, [X[0], X[1]], ftype=42)
    # expected ftype to match items
    assert_raises(ValueError, farray, [X[0], X[1]], ftype=BinaryDecisionDiagram)
    # expected ftype to be a property subclass of Function
    assert_raises(TypeError, farray, [], ftype=int)
    # expected a sequence of Function
    assert_raises(TypeError, farray, 42)
    assert_raises(TypeError, farray, [1, 2, 3, 4])
    # expected uniform dimensions
    assert_raises(ValueError, farray, [[a, b], [w, x, y, z], 42])
    assert_raises(ValueError, farray, [[a, b], [w, x, y, z]])
    # expected uniform types
    assert_raises(ValueError, farray, [[a, b], [c, bddvar('d')]])
    assert_raises(ValueError, farray, [[a, b], [bddvar('c'), bddvar('d')]])
    # _check_shape errors
    assert_raises(ValueError, farray, [a, b, c, d], shape=((-1, 3), ))
    assert_raises(ValueError, farray, [a, b, c, d], shape=((3, -1), ))
    assert_raises(ValueError, farray, [a, b, c, d], shape=((5, 1), ))
    assert_raises(TypeError, farray, [a, b, c, d], shape=(('foo', 'bar'), ))
    assert_raises(TypeError, farray, [a, b, c, d], shape=42)

    temp = farray([[a, b], [c, d]])
    assert str(temp) == """\
farray([[a, b],
        [c, d]])\
"""

    # __str__
    Z = exprvars('z', 2, 2, 2)
    assert str(Z) == """\
farray([[[z[0,0,0], z[0,0,1]],
         [z[0,1,0], z[0,1,1]]],

        [[z[1,0,0], z[1,0,1]],
         [z[1,1,0], z[1,1,1]]]])\
"""

    assert str(farray([], ftype=Expression)) == "farray([])"

    # __getitem__
    # expected <= M slice dimensions, got N
    assert_raises(ValueError, X.__getitem__, (2, 2))
    sel = exprvars('s', 2)
    assert str(X[sel]) == "Or(And(~s[0], ~s[1], x[0]), And(s[0], ~s[1], x[1]), And(~s[0], s[1], x[2]), And(s[0], s[1], x[3]))"
    assert str(X[:2][sel[0]]) == "Or(And(~s[0], x[0]), And(s[0], x[1]))"
    # expected clog2(N) bits
    assert_raises(ValueError, X.__getitem__, sel[0])
    # slice step not supported
    assert_raises(ValueError, X.__getitem__, slice(None, None, 2))
    # type error
    assert_raises(TypeError, X.__getitem__, 'foo')
    # norm_index
    assert X[-1] is X[3]
    assert_raises(IndexError, X.__getitem__, 42)
    # norm_indices
    assert X[-3:-1]._items == [X[-3], X[-2]]
    assert not X[-8:-10]._items
    assert not X[-10:-8]._items
    assert not X[8:10]._items
    assert not X[10:8]._items
    assert not X[3:1]._items

    # __setitem__
    Z = exprzeros(4, 4)
    Z[0,0] = X[0]
    assert Z._items[0] is X[0]
    # expected item to be a Function
    assert_raises(TypeError, Z.__setitem__, (0, 0), 42)
    Z[0,:] = X[:4]
    assert Z._items[0:4] == [X[0], X[1], X[2], X[3]]
    # expected item to be an farray
    assert_raises(TypeError, Z.__setitem__, (0, slice(None, None, None)), 42)
    # expected item.size = ...
    assert_raises(ValueError, Z.__setitem__, ..., X[:2])
    # slice step not supported
    assert_raises(ValueError, X.__setitem__, slice(None, None, 2), 42)
    # type error
    assert_raises(TypeError, X.__setitem__, 'foo', 42)

    # __add__
    assert (0 + X)._items[0].is_zero()
    assert (X + 0)._items[4].is_zero()
    assert (Y[0] + X)._items[0] is Y[0]
    assert (X + Y[0])._items[4] is Y[0]
    assert (X[:2] + Y[2:])._items == [X[0], X[1], Y[2], Y[3]]
    # expected Function or farray
    assert_raises(TypeError, X.__add__, 42)
    assert_raises(TypeError, X.__radd__, 42)

    A = exprvars('a', 2, 5, 6)
    B = exprvars('b', 2, 5, 6)
    C = exprvars('c', (1, 3), 5, 6)
    # regular MDA will retain shape
    assert (A+B).shape == ((0, 4), (0, 5), (0, 6))
    # irregular MDA will not
    assert (A+C).shape == ((0, 4*5*6), )

    # regular MDA will retain shape
    assert (A*2).shape == ((0, 4), (0, 5), (0, 6))
    # irregular MDA will not
    assert (C*2).shape == ((0, 4*5*6), )

    # __mul__
    # expected multiplier to be an int
    assert_raises(TypeError, X.__mul__, 'foo')
    # expected multiplier to be non-negative
    assert_raises(ValueError, X.__mul__, -2)
    assert (X[:2] * 2)._items == [X[0], X[1], X[0], X[1]]
    assert (2 * X[:2])._items == [X[0], X[1], X[0], X[1]]

    # offsets
    Z = exprzeros((1, 5), (17, 21))
    assert Z.offsets == (1, 17)

    # reshape
    assert Z.reshape(4, 4).shape == ((0, 4), (0, 4))
    # expected shape with equal volume
    assert_raises(ValueError, Z.reshape, 42, 42)

    # restrict
    assert str(X.vrestrict({X: '0101'})) == "farray([0, 1, 0, 1])"

    # compose
    assert X.compose({X[0]: Y[0]})._items[0] == Y[0]

    # to_uint / to_int
    assert uint2exprs(42).to_uint() == 42
    assert uint2exprs(42, 8).to_uint() == 42
    # expected all functions to be a constant (0 or 1) form
    assert_raises(ValueError, X.to_uint)
    # expected num >= 0
    assert_raises(ValueError, uint2exprs, -1)
    # overflow
    assert_raises(ValueError, uint2exprs, 42, 2)
    assert_raises(ValueError, int2exprs, 42, 2)
    assert int2exprs(-42).to_int() == -42
    assert int2exprs(-42, 8).to_int() == -42
    assert int2exprs(42).to_int() == 42
    assert int2exprs(42, 8).to_int() == 42

    # zext, sext
    assert X.zext(1)[4].is_zero()
    assert X.sext(1)[4] is X[3]

    # __invert__, __or__, __and__, __xor__
    assert str(~X) == "farray([~x[0], ~x[1], ~x[2], ~x[3]])"
    assert str(X | Y) == "farray([Or(x[0], y[0]), Or(x[1], y[1]), Or(x[2], y[2]), Or(x[3], y[3])])"
    assert str(X & Y) == "farray([And(x[0], y[0]), And(x[1], y[1]), And(x[2], y[2]), And(x[3], y[3])])"
    assert str(X ^ Y) == "farray([Xor(x[0], y[0]), Xor(x[1], y[1]), Xor(x[2], y[2]), Xor(x[3], y[3])])"
    # _op_shape
    # expected farray input
    assert_raises(TypeError, X.__or__, 42)
    Z = exprvars('z', 2, 2)
    assert str(X | Z) == "farray([Or(x[0], z[0,0]), Or(x[1], z[0,1]), Or(x[2], z[1,0]), Or(x[3], z[1,1])])"
    Z = exprvars('z', 2, 3)
    # expected operand sizes to match
    assert_raises(ValueError, X.__or__, Z)

    # lsh, rsh
    assert str(X.lsh(0)) == "(farray([x[0], x[1], x[2], x[3]]), farray([]))"
    assert str(X << 0) == "farray([x[0], x[1], x[2], x[3]])"
    assert str(X.lsh(2)) == "(farray([0, 0, x[0], x[1]]), farray([x[2], x[3]]))"
    assert str(X << 2) == "farray([0, 0, x[0], x[1]])"
    assert str(X << (2, Y[:2])) == "farray([y[0], y[1], x[0], x[1]])"
    assert str(X.rsh(0)) == "(farray([x[0], x[1], x[2], x[3]]), farray([]))"
    assert str(X >> 0) == "farray([x[0], x[1], x[2], x[3]])"
    assert str(X.rsh(2)) == "(farray([x[2], x[3], 0, 0]), farray([x[0], x[1]]))"
    assert str(X >> 2) == "farray([x[2], x[3], 0, 0])"
    assert str(X >> (2, Y[:2])) == "farray([x[2], x[3], y[0], y[1]])"
    assert_raises(TypeError, X.__lshift__, 'foo')
    assert_raises(ValueError, X.__lshift__, -1)
    assert_raises(ValueError, X.__lshift__, (2, Y))
    assert_raises(TypeError, X.__rshift__, 'foo')
    assert_raises(ValueError, X.__rshift__, -1)
    assert_raises(ValueError, X.__rshift__, (2, Y))

    # arsh
    assert str(X.arsh(0)) == "(farray([x[0], x[1], x[2], x[3]]), farray([]))"
    assert str(X.arsh(2)) == "(farray([x[2], x[3], x[3], x[3]]), farray([x[0], x[1]]))"
    assert_raises(ValueError, X.arsh, -1)

    # unary ops
    assert str(X.uor()) == "Or(x[0], x[1], x[2], x[3])"
    assert str(X.unor()) == "Not(Or(x[0], x[1], x[2], x[3]))"
    assert str(X.uand()) == "And(x[0], x[1], x[2], x[3])"
    assert str(X.unand()) == "Not(And(x[0], x[1], x[2], x[3]))"
    assert str(X.uxor()) == "Xor(x[0], x[1], x[2], x[3])"
    assert str(X.uxnor()) == "Not(Xor(x[0], x[1], x[2], x[3]))"

    # decode
    assert str(farray([], ftype=Expression).decode()) == "farray([1])"
    assert str(X[:2].decode()) == "farray([And(~x[0], ~x[1]), And(x[0], ~x[1]), And(~x[0], x[1]), And(x[0], x[1])])"
Exemplo n.º 9
0
def test_bin2gray():
    B = exprvars('B', 4)
    G = bin2gray(B)
    gnums = [G.vrestrict({B: uint2exprs(i, 4)}).to_uint() for i in range(16)]
    assert gnums == [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]
Exemplo n.º 10
0
def test_gray2bin():
    G = exprvars('G', 4)
    B = gray2bin(G)
    gnums = [0, 1, 3, 2, 6, 7, 5, 4, 12, 13, 15, 14, 10, 11, 9, 8]
    bnums = [B.vrestrict({G: uint2exprs(i, 4)}).to_uint() for i in gnums]
    assert bnums == list(range(16))
Exemplo n.º 11
0
def xtime(b, n):
    """Repeated polynomial multiplication in GF(2^8)."""
    b = b.reshape(8)
    for _ in range(n):
        b = exprzeros(1) + b[:7] ^ uint2exprs(0x1b, 8) & b[7] * 8
    return b
Exemplo n.º 12
0
_MA = [
    0x2311,
    0x1231,
    0x1123,
    0x3112,
]

_IMA = [
    0xebd9,
    0x9ebd,
    0xd9eb,
    0xbd9e,
]

# 16x16x8
SBOX = fcat(*[uint2exprs(x, 8) for x in _SBOX]).reshape(256, 8)
ISBOX = fcat(*[uint2exprs(x, 8) for x in _ISBOX]).reshape(256, 8)

# 255
RCON = fcat(*[uint2exprs(x, 8) for x in _RCON]).reshape(255, 8)

# 4x16
MA = fcat(*[uint2exprs(x, 16) for x in _MA]).reshape(4, 16)
IMA = fcat(*[uint2exprs(x, 16) for x in _IMA]).reshape(4, 16)


def subword(w):
    """
    Function used in the Key Expansion routine that takes a four-byte input word
    and applies an S-box to each of the four bytes to produce an output word.
    """
Exemplo n.º 13
0
def uint2bv(num, length=None):
    """Convert an unsigned integer to a BitVector."""
    warn("vexpr.uint2bv is deprecated. Use bfarray.uint2exprs instead.")
    return bfarray.uint2exprs(num, length)
Exemplo n.º 14
0
def uadd(S, A, B, aval, bval):
    N = len(A)
    R = S.vrestrict({A: uint2exprs(aval, N), B: uint2exprs(bval, N)})
    return R.to_uint()
Exemplo n.º 15
0
def uadd(S, A, B, aval, bval):
    N = len(A)
    R = S.vrestrict({A: uint2exprs(aval, N), B: uint2exprs(bval, N)})
    return R.to_uint()
Exemplo n.º 16
0
def uadd(s, a, b, aval, bval):
    n = len(a)
    r_ = s.vrestrict({a: uint2exprs(aval, n), b: uint2exprs(bval, n)})
    return r_.to_uint()