Python Random.getrandbits方法代码示例

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
        def do_stuff(triple, alpha):
            random = Random(3423993)
            share_random = Random(random.getrandbits(128))

            paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
            gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, alpha)

            x2 = gen.generate_share(x1)
            y2 = gen.generate_share(y1)
            z2 = runtime._basic_multiplication(self.Zp(x1), y2, triple.a, triple.b, triple.c)
            d = runtime.open(z2)
            d.addCallback(check)
            return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
        def do_mult(triples, alpha):
            runtime.triples = triples
            random = Random(3423993)
            share_random = Random(random.getrandbits(128))
            paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
            gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, alpha)

            x2 = gen.generate_share(x1)
            y2 = gen.generate_share(y1)

            z2 = x2 * y2
            d = runtime.open(z2)
            d.addCallback(check)
            return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
 def test_encrypted_shares_decrypt_correctly(self, runtime):
     random = Random(3423993)
     modulus = 17
     secret = 7
     paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
     share = self._partial_share(Random(random.getrandbits(128)), runtime,
                                 GF(modulus), secret, paillier=paillier)
     def decrypt(share):
         decrypted_share = paillier.decrypt(share.enc_shares[runtime.id - 1])
         decrypted_shares = _convolute(runtime, decrypted_share)
         def test_sum(vals):
             self.assertEquals(secret, sum(vals) % modulus)
         runtime.schedule_callback(decrypted_shares, test_sum)
     runtime.schedule_callback(share, decrypt)
     return share

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
def seeds(starting, n_steps):
    random = Random(starting)

    result = []
    for _ in hrange(n_steps):
        result.append(random.getrandbits(64))
    return result

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
class PRNG():
    def __init__(self, seed):
        self._rng = Random(seed)

    def make_challenge(self, size):
        cfmt = '{0:0' + str(size) + 'b}'
        c = self._rng.getrandbits(size)
        return Challenge(cfmt.format(c))

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_sum_plus(self, runtime):
        """Test addition of two numbers."""

        def check(v):
            self.assertEquals(v, 11)

        random = Random(3423993)
        share_random = Random(random.getrandbits(128))

        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
        gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, self.alpha)

        x2 = gen.generate_share(2)
        y2 = gen.generate_share(9)
        z2 = x2 + y2
        d = runtime.open(z2)
        d.addCallback(check)
        return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_open_two_secret_share(self, runtime):
        """Test sharing and open of a number."""

        def check((a, b)):
            self.assertEquals(a, 6)
            self.assertEquals(b, 6)

        random = Random(3423993)
        share_random = Random(random.getrandbits(128))

        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
        gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, self.alpha)

        x = gen.generate_share(6)
        y = gen.generate_share(6)
        d = runtime.open_two_values(x, y)
        d.addCallback(check)
        return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_encrypted_real_share_open_correctly(self, runtime):
        random = Random(3423993)
        modulus = 17
        Zp = GF(modulus)
        bits_in_p = 5
        u_bound = 2**(4 * bits_in_p)
        alpha = 15
        
        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))

        share_random = Random(random.getrandbits(128))
        gen = TestShareGenerator(Zp, runtime, share_random, paillier, u_bound, alpha)
        share = gen.generate_share(7)
        def check(v):
            self.assertEquals(7, v)
        r = runtime.open(share)
        runtime.schedule_callback(r, check)
        return r

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_sub_constant_left(self, runtime):
        """Test subtraction of a public number and secret shared number."""

        y = 8

        def check(v):
            self.assertEquals(v, 3)

        random = Random(3423993)
        share_random = Random(random.getrandbits(128))

        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
        gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, self.alpha)

        x2 = gen.generate_share(5)
        z2 = y - x2
        d = runtime.open(x2)
        d.addCallback(check)
        return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_sum_constant_right(self, runtime):
        """Test addition of secret shared number and a public number."""

        y1 = 7

        def check(v):
            self.assertEquals(v, 15)

        random = Random(3423993)
        share_random = Random(random.getrandbits(128))

        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
        gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, self.alpha)

        x2 = gen.generate_share(8)
        z2 = x2 + y1
        d = runtime.open(z2)
        d.addCallback(check)
        return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
class TB(Module):
	def __init__(self, width=3):
		self.width = width
		self.submodules.gc = GrayCounter(self.width)
		self.prng = Random(7345)

	def do_simulation(self, s):
		print("{0:0{1}b} CE={2} bin={3}".format(s.rd(self.gc.q),
			self.width, s.rd(self.gc.ce), s.rd(self.gc.q_binary)))
		s.wr(self.gc.ce, self.prng.getrandbits(1))

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_constant_multiplication_constant_right(self, runtime):
        """Test multiplication of two numbers."""

        x1 = 6
        y1 = 7

        def check(v):
            self.assertEquals(v, self.Zp(x1 * y1))

        random = Random(3423993)
        share_random = Random(random.getrandbits(128))

        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
        gen = TestShareGenerator(self.Zp, runtime, share_random, paillier, self.u_bound, self.alpha)

        x2 = gen.generate_share(x1)

        z2 = runtime._cmul(x2, self.Zp(y1), self.Zp)
        d = runtime.open(z2)
        d.addCallback(check)
        return d

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def test_encrypted_random_real_shares_open_correctly(self, runtime):
        random = Random(3423993)
        modulus = 17
        Zp = GF(modulus)
        bits_in_p = 5
        u_bound = 2**(4 * bits_in_p)
        alpha = 15
        
        paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))

        share_random = Random(random.getrandbits(128))
        gen = TestShareGenerator(Zp, runtime, share_random, paillier, u_bound, alpha)
        shares = gen.generate_random_shares(7)
        expected_result = [9,16,7,12,3,5,6]
        results = []
        for inx, share in enumerate(shares):
            def check(v, expected_result):
                self.assertEquals(expected_result, v)
            r = runtime.open(share)
            results.append(r)
            runtime.schedule_callback(r, check, expected_result[inx])
        return gather_shares(results)

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
    def _pack_message(self, message, masked=False,
                      continuation=False, final=True, control_code=None):
        is_text = False
        if isinstance(message, six.text_type):
            message = message.encode('utf-8')
            is_text = True

        compress_bit = 0
        compressor = self._get_permessage_deflate_enc()
        if message and compressor:
            message = compressor.compress(message)
            message += compressor.flush(zlib.Z_SYNC_FLUSH)
            assert message[-4:] == b"\x00\x00\xff\xff"
            message = message[:-4]
            compress_bit = 1 << 6

        length = len(message)
        if not length:
            # no point masking empty data
            masked = False
        if control_code:
            if control_code not in (8, 9, 0xA):
                raise ProtocolError('Unknown control opcode.')
            if continuation or not final:
                raise ProtocolError('Control frame cannot be a fragment.')
            if length > 125:
                raise ProtocolError('Control frame data too large (>125).')
            header = struct.pack('!B', control_code | 1 << 7)
        else:
            opcode = 0 if continuation else ((1 if is_text else 2) | compress_bit)
            header = struct.pack('!B', opcode | (1 << 7 if final else 0))
        lengthdata = 1 << 7 if masked else 0
        if length > 65535:
            lengthdata = struct.pack('!BQ', lengthdata | 127, length)
        elif length > 125:
            lengthdata = struct.pack('!BH', lengthdata | 126, length)
        else:
            lengthdata = struct.pack('!B', lengthdata | length)
        if masked:
            # NOTE: RFC6455 states:
            # A server MUST NOT mask any frames that it sends to the client
            rand = Random(time.time())
            mask = [rand.getrandbits(8) for _ in six.moves.xrange(4)]
            message = RFC6455WebSocket._apply_mask(message, mask, length)
            maskdata = struct.pack('!BBBB', *mask)
        else:
            maskdata = b''

        return b''.join((header, lengthdata, maskdata, message))

# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import getrandbits [as 别名]
 def test_encrypted_random_shares_decrypt_correctly(self, runtime):
     random = Random(3423993)
     modulus = 17
     Zp = GF(modulus)
     paillier = ModifiedPaillier(runtime, Random(random.getrandbits(128)))
     shares = self._partial_random_shares(random, runtime, Zp, 7, paillier=paillier)
     expected_result = [9,16,7,12,3,5,6]
     for inx, share in enumerate(shares):
         def decrypt(share, expected_result):
             decrypted_share = paillier.decrypt(share.enc_shares[runtime.id - 1])
             decrypted_shares = _convolute(runtime, decrypted_share)
             def test_sum(vals, expected_result):
                 v = Zp(sum(vals))
                 self.assertEquals(expected_result, v)
             runtime.schedule_callback(decrypted_shares, test_sum, expected_result)
         runtime.schedule_callback(share, decrypt, expected_result[inx])
         
     return shares