예제 #1
0
파일: shacal1.py 프로젝트: nc26676027/ArxPy
    def weight(self, output_diff):
        x, y, z = [d.val for d in self.input_diff]

        def eq(x, y, z):
            return (~x ^ y) & (~x ^ z)

        pr1 = eq(x, y, z)

        return PopCount(~pr1)
예제 #2
0
파일: shacal1.py 프로젝트: nc26676027/ArxPy
    def weight(self, output_diff):
        x, y, z = [d.val for d in self.input_diff]

        def eq(a, b):
            return ~a ^ b

        pr1 = ~x & eq(y, z)

        return PopCount(~pr1)
예제 #3
0
    def test_PopCountExtra(self, width, x, y, z):
        bvx = Constant(x % (2 ** width), width)
        hwx = PopCount(bvx)
        bvy = Constant(y % (2 ** width), width)
        hwy = PopCount(bvy)
        bvz = Constant(z % (2 ** width), width)
        hwz = PopCount(bvz)

        popsum2 = PopCountSum2(bvx, bvy)
        popsum3 = PopCountSum3(bvx, bvy, bvz)
        popdiff = PopCountDiff(bvx, bvy)

        self.assertEqual(
            int(hwx) + int(hwy),
            int(popsum2))
        self.assertEqual(
            int(hwx) + int(hwy) + int(hwz),
            int(popsum3))
        self.assertEqual(
            (int(hwx) - int(hwy)) % (2 ** popdiff.width),
            int(popdiff))
예제 #4
0
    def is_possible(self, output_diff):
        """Return whether the given output `XorDiff` is possible.

            >>> from arxpy.bitvector.core import Constant, Variable
            >>> from arxpy.bitvector.context import NotEvaluation
            >>> from arxpy.bitvector.printing import BvWrapPrinter
            >>> from arxpy.differential.difference import XorDiff
            >>> alpha = XorDiff(Constant(0, 16))
            >>> f = XDSimonRF(alpha)
            >>> f.is_possible(XorDiff(Constant(0, 16)))
            0b1
            >>> u, v = Variable("u", 16), Variable("v", 16)
            >>> f = XDSimonRF(XorDiff(u))
            >>> with NotEvaluation([PopCount]):
            ...     result = f.is_possible(XorDiff(v))
            >>> print(BvWrapPrinter().doprint(result))
            Ite(0xffff == u,
                0b0 == (PopCount(v ^ (u <<< 2))[0]),
                ==(0x0000,
                   |(~(u <<< 8) & (u <<< 1) & (u <<< 15) & (v ^ (u <<< 2) ^ ((v ^ (u <<< 2)) <<< 7)),
                     ~((u <<< 1) | (u <<< 8)) & (v ^ (u <<< 2))
            >>> result.xreplace({u: Constant(0, 16), v: Constant(0, 16)})
            0b1

        See `Derivative.is_possible` for more information.
        """
        a, b, c = self.op.a, self.op.b, self.op.c
        n = self.input_diff[0].val.width
        assert math.gcd(n, a - b) == 1 and a > b and n % 2 == 0

        alpha = self.input_diff[0].val
        Rol = RotateLeft
        varibits = Rol(alpha, a) | Rol(alpha, b)
        r = (2 * a - b) % n
        doublebits = (Rol(alpha, b) & (~Rol(alpha, a)) & Rol(alpha, r))

        beta = output_diff.val
        gamma = beta ^ Rol(alpha, c)

        def is_even(x):
            return BvComp(x[0], Constant(0, 1))

        case2 = BvComp(Constant(0, n), (gamma & (~varibits)) |
                       ((gamma ^ Rol(gamma, a - b)) & doublebits))

        condition = Ite(BvComp(alpha, ~Constant(0, n)),
                        is_even(PopCount(gamma)), case2)

        return condition
예제 #5
0
    def test_extraop(self, width, x):
        bv = Constant(x % (2 ** width), width)
        hw = PopCount(bv)
        rev = Reverse(bv)
        lz = LeadingZeros(bv)

        lz_bf = ""
        for i in bv.bin()[2:]:
            if i == "0":
                lz_bf += "1"
            else:
                break
        lz_bf += "0"*(bv.width - len(lz_bf))

        self.assertEqual(int(hw), bin(int(bv)).count("1"))
        self.assertEqual(rev.bin()[2:], bv.bin()[2:][::-1])
        self.assertEqual(lz.bin()[2:], lz_bf)
예제 #6
0
    def weight(self, output_diff):
        """Return the weight of a possible output `XorDiff`.

            >>> from arxpy.bitvector.core import Constant, Variable
            >>> from arxpy.bitvector.context import NotEvaluation
            >>> from arxpy.bitvector.printing import BvWrapPrinter
            >>> from arxpy.bitvector.extraop import PopCount
            >>> from arxpy.differential.difference import XorDiff
            >>> alpha = XorDiff(Constant(0, 16))
            >>> f = XDSimonRF(alpha)
            >>> f.weight(XorDiff(Constant(0, 16)))
            0b00000
            >>> alpha = XorDiff(Variable("u", 16))
            >>> f = XDSimonRF(alpha)
            >>> beta = XorDiff(Variable("v", 16))
            >>> with NotEvaluation([PopCount]):
            ...     print(BvWrapPrinter().doprint(f.weight(beta)))
            Ite(0xffff == u,
                0b01111,
                PopCount((~(u <<< 8) & (u <<< 1) & (u <<< 15)) ^ ((u <<< 1) | (u <<< 8)))

        See `Derivative.weight` for more information.
        """
        a, b = self.op.a, self.op.b
        n = self.input_diff[0].val.width

        alpha = self.input_diff[0].val
        Rol = RotateLeft
        varibits = Rol(alpha, a) | Rol(alpha, b)
        r = (2 * a - b) % n
        doublebits = (Rol(alpha, b) & (~Rol(alpha, a)) & Rol(alpha, r))

        hw = PopCount(varibits ^ doublebits)
        width = max((n - 1).bit_length(), hw.width)

        value = Ite(BvComp(alpha, ~Constant(0, n)), Constant(n - 1, width),
                    ZeroExtend(hw, width - hw.width))

        return value
예제 #7
0
파일: multi2.py 프로젝트: ranea/ArxPy
    def weight(self, output_diff):
        dx, dy = [d.val for d in self.input_diff]

        return PopCount(dx | dy)