Python SystemRandom.getrandbits方法代码示例

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
def randomKey(entropy):
    """
    256 bit number from equally strong urandom, user entropy, and timer parts
    """
    if entropy.bit_length() < 250:
        print('Insufficient entropy parameter to generate key')
        return False
    from random import SystemRandom

    osrndi = SystemRandom()
    entstr = enc.encode(entropy, 16) + enc.encode(osrndi.getrandbits(512), 256) + str(clockrnd())
    osrnd = SystemRandom(entstr)
    privkey = 0
    while privkey < 1 or privkey > elip.N:
        privkey = enc.decode(hashlib.sha256(enc.encode(osrnd.getrandbits(512), 256)).digest(), 256) ^ osrnd.getrandbits(
            256)
        for lbit in xrange(clockrnd() % 64 + 64):
            clockstr = hex(clockrnd()) + str(clockrnd()) + entstr
            # Slice a moving 256 bit window out of SHA512
            clock32 = hashlib.sha512(clockstr).digest()[1 + (lbit % 29): 33 + (lbit % 29)]
            randhash = hashlib.sha512(enc.encode(osrnd.getrandbits(512), 256)).digest()[
                       0 + (lbit % 31): 32 + (lbit % 31)]
            privkey ^= enc.decode(randhash, 256) ^ enc.decode(clock32, 256) ^ osrndi.getrandbits(256)
            osrnd = SystemRandom(hashlib.sha512(clock32 + randhash + entstr).digest())  # reseed
    return privkey

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
def createPrime(bits):
   i = 2
   rand = SystemRandom()
   prime = rand.getrandbits(bits)
   while i <= sqrt(prime):
      if prime % i == 0:
         i = 1
         prime = rand.getrandbits(bits)
      i += 1
   return prime

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
def getPrime(bits):
   i = 2
   rand = SystemRandom()
   prime = rand.getrandbits(bits)
   primesqrt = sqrt(prime)
   while i <= primesqrt:
      if prime % i == 0:
         i = 1
         prime = rand.getrandbits(bits)
         primesqrt = sqrt(prime)
      i += 1
   return prime

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
def create_auth_key_test(connection, loop):
    from random import SystemRandom
    rand = SystemRandom()

    req_pq = scheme.req_pq(nonce=rand.getrandbits(128))
    print(req_pq)
    yield from connection.send_insecure_message(req_pq)
    response = yield from connection.get_ingress()
    resPQ = response.get_message()
    print(resPQ)

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

    def make_nonce(self, size):
        noncefmt = '{0:0' + str(size) / 4 + 'x}'
        nonce = self._rng.getrandbits(size)
        return noncefmt.format(nonce)

    def choose_index(max):
        SystemRandom().randint(1, max)

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
 def __init__(self, state=None, seq=DEFAULT_SEQUENCE):
   '''
   Initialize a new PCGRandom engine. If no seed is specified use urandom and
   if no sequene is specified use an arbitrary sequece
   '''
   self._rng_state = ffi.new("pcg32_random_t*");
   #If the state is none then get a random state from system entropy
   if state == None:
     system_random = SystemRandom()
     state = system_random.getrandbits(64)
   c_interface.pcg32_srandom_r(self._rng_state, state, seq)

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
    def create_auth_key(self):
        from random import SystemRandom
        rand = SystemRandom()

        req_pq = scheme.req_pq(nonce=rand.getrandbits(128))
        log.debug(req_pq)
        yield from self.connection.send_insecure_message(req_pq)
        response = yield from self.connection.get_ingress()
        resPQ = response.get_message()
        log.debug(resPQ)

        pq = int.from_bytes(resPQ.pq.data, 'big')

        p, q = prime.primefactors(pq, True)

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
class NUID(object):
    """
    NUID is an implementation of the approach for fast generation of
    unique identifiers used for inboxes in NATS.
    """

    def __init__(self):
        self._srand = SystemRandom()
        self._prand = Random(self._srand.randint(0, MaxInt))
        self._seq = self._prand.randint(0, MAX_SEQ)
        self._inc = MIN_INC + self._prand.randint(0, INC)
        self._prefix = b''
        self.randomize_prefix()

    def next(self):
        self._seq += self._inc
        if self._seq >= MAX_SEQ:
            self.randomize_prefix()
            self.reset_sequential()
        prefix = self._prefix[:]

        def _next():
            a = DIGITS[int(_next.l) % BASE]
            _next.l /= BASE
            return a

        _next.l = self._seq
        suffix = bytearray(_next() for i in range(SEQ_LENGTH))
        prefix.extend(suffix)
        return prefix

    def randomize_prefix(self):
        random_bytes = (self._srand.getrandbits(8)
                        for i in range(PREFIX_LENGTH))
        self._prefix = bytearray(DIGITS[c % BASE] for c in random_bytes)

    def reset_sequential(self):
        self._seq = self._prand.randint(0, MAX_SEQ)
        self._inc = MIN_INC + self._prand.randint(0, INC)

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
 def run_test_bits(self, r, level):
     """Test based on Norm distribution
         Xi ~ 1, or -1 with equal possibility
         X = (X1 + ... + Xn) / n
         E(Xi) = 0
         E(Xi^2)=  1
         Var(X) = Var(Xi)/n = 1 / n
         set n = 10000
         EX = 0
         Var(X) = 0.0001
     """ 
     sum = 0
     n = 1000
     r2 = SystemRandom()
     r.seed(r2.getrandbits(1024))
     sigma = 1 / sqrt(n)
     for i in range(n):
         sum = sum + r.getrandbits(1)
     diff = abs(n - 2 * sum) / n
     self._logger.debug('diff is {0} sigma'.format(diff/sigma))
     # 2 sigma , p = 95.45%
     # 3 sigma , p = 99.73%
     self.assertEqual(diff < level * sigma, True)

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
class Kopy(object):

    """
    Implementation of the kopy.io API
    """

    url = "https://kopy.io/documents/"
    verifyCert = False # kopy uses an invalid cert :'(

    keyLength = 256 / 8
    ivLength = 16
    blockSize = 16
    saltLength = 8
    passwordRandBytes = 100 # this must be > the length of an md5 hash (32 bytes)

    saltPadding = "Salted__" # this is half a block, and the salt is half a block
    ciphertextFormat = saltPadding + "{salt}{ciphertext}" # this is then b64'd

    documentFormat = {"data":None, "security":None, "keep":None}.copy
    # note that documentFormat is a method
    # TODO put in some intelligent defaults, like a scheme, maybe a user-agent
    # to declare a paste was made with kopycat. Then again, maybe not.

    docNotFound = "Document not found."
    cryptoSchemes = ["default", "encrypted"]

    def __init__(self):

        self.randomness = SystemRandom()

    def _randomBytes(self, length):
        """
        Return a specified number of bytes from the OSs random facility.
        """

        if length <= 0: raise Exception("length must be a positive integer.")
        return "".join([chr(self.randomness.getrandbits(8)) for i in range(length)])

    def _generateSalt(self):

        return self.generateRandomBytes(self.saltLength)

    def _parseCiphertext(self, ciphertext):

        output = b64decode(ciphertext)
        if not output.startswith(self.saltPadding):
            raise Exception("Bad salt padding.")
        if not len(output) % self.blockSize == 0:
            raise Exception("Message isn't sized correctly.")

        salt = output[len(self.saltPadding):self.blockSize]
        message = output[self.blockSize:]

        return salt, message

    def _formatCiphertext(self, salt, ciphertext):

        if len(salt) != self.saltLength:
            raise Exception("Bad salt.")
        if len(ciphertext) % self.blockSize != 0:
            raise Exception("Bad ciphertext.")

        return b64encode(self.ciphertextFormat.format(salt=salt,
                        ciphertext=ciphertext))

    def _newAES(self, key, iv):

        return AES.new(key, AES.MODE_CBC, iv)

    def _getAESArgs(self, passphrase, salt):
        """
        Generate the key and IV from a passphrase using OpenSSL's derivation method.
        """

        if len(salt) != 8: raise Exception("Bad salt.")
        return self.opensslKeyDerivation(passphrase, salt,
                                        self.keyLength, self.ivLength)

    def _composeDocument(self, document, encryption, keep):
        """
        Create a dictionary to represent the document, for requests.post()'s
        "data" parameter.
        """

        output = self.documentFormat()
        output["data"] = document
        output["keep"] = keep
        output["security"] = "encrypted" if encryption else "default"

        return output

    def _parseDocument(self, json):
        """
        Parse a JSON string into a native Python datastructure.
        """

        output = loads(json)
        return output

    def _postDocument(self, document, encryption=False, keep=600):
#.........这里部分代码省略.........

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
class Datacenter:
    DATA_VERSION = 4

    DCs = [
        "149.154.175.50",
        "149.154.167.51",
        "149.154.175.100",
        "149.154.167.91",
        "149.154.171.5",
    ]

    DCs_ipv6 = [
        "2001:b28:f23d:f001::a",
        "2001:67c:4e8:f002::a",
        "2001:b28:f23d:f003::a",
        "2001:67c:4e8:f004::a",
        "2001:b28:f23f:f005::a",
    ]

    DCs_test = [
        "149.154.175.10",
        "149.154.167.40",
        "149.154.175.117",
    ]

    DCs_test_ipv6 = [
        "2001:b28:f23d:f001::e",
        "2001:67c:4e8:f002::e",
        "2001:b28:f23d:f003::e",
    ]

    def __init__(self, dc_id, ipaddr, port, rsa_key):
        self.random = SystemRandom()

        self.session_id = None

        self.resPQ = None
        self.p_q_inner_data = None
        self.server_DH_params = None
        self.server_DH_inner_data = None
        self.client_DH_inner_data = None
        tmp_aes_key = None
        tmp_aes_iv = None
        self.set_client_DH_params_answer = None

        self.ipaddr = ipaddr
        self.port = port
        self.datacenter_id = dc_id
        self.auth_server_salt_set = []
        self._socket = socket()
        self._socket.connect((ipaddr, port))
        self._socket.settimeout(5.0)
        self.socket = self._socket.makefile(mode='rwb', buffering=0)
        self.message_queue = []

        self.last_msg_id = 0
        self.timedelta = 0
        self.number = 0

        self.authorized = False
        self.auth_key = MTProtoAuthKey()
        self.server_salt = None
        self.server_time = None

        self.MAX_RETRY = 5
        self.AUTH_MAX_RETRY = 5

        self.rsa_key = rsa_key

        self.b = self.random.getrandbits(2048)

        # Handshake
        self.create_auth_key()
        # self.test_api()

    def test_api(self):
        getNearestDc = tl.help_getNearestDc()
        print(getNearestDc)

        self.send_encrypted_message(getNearestDc.to_bytes())
        self.recv_encrypted_message()
        # nearestDc = tl.NearestDc(self.recv_plaintext_message(True))
        # print(nearestDc)

    """
    g = public (prime) base, known to Alice, Bob, and Eve. g = 5
    p = public (prime) number, known to Alice, Bob, and Eve. p = 23
    a = Alice's private key, known only to Alice. a = 6
    b = Bob's private key known only to Bob. b = 15
    """

    def _req_pq(self):
        nonce = tl.int128_c(self.random.getrandbits(128))
        request = tl.req_pq(nonce)
        # raise Exception()
        self.send_plaintext_message(request.to_bytes())
        res_pq = tl.ResPQ.from_stream(BytesIO(self.recv_plaintext_message()))

        # print(res_pq, ...)
        raise Exception()
#.........这里部分代码省略.........

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
    def generate(self):
        '''
        @summary Generate configuration file with different random seeds
        ''' 
        i=0
        while True:
            try:
                os.remove(self.baseFile[:-4]+'_'+str(i)+'.xml')
                i+=1
            except:
                break
        for dirname, dirnames, filenames in os.walk('.'):
            if dirname[-2:] == 'LO' or dirname[-2:] == 'UP':
                shutil.rmtree(dirname)


        f = Opener(self.baseFile)
        rootNode = f.getRootNode()
        GeneratorSeeds = rootNode.toElement().firstChildElement("Input").firstChildElement("PopulationManager").firstChildElement("Generator").firstChildElement("RandomizerInfo")
        SimulatorSeeds = rootNode.toElement().firstChildElement("Simulation").firstChildElement("RandomizerInfo")
        paramNode = rootNode.toElement().firstChildElement("System").firstChildElement("Parameters")
        EntryNodes = paramNode.elementsByTagName("Entry")
        threadsGenerator = self.spinBoxGenThread.value()
        threadsSimulator = self.spinBoxSimThread.value()

        elt = paramNode.firstChildElement("Entry")
        while elt.attribute("label") != "threads.simulator":
            elt = elt.nextSiblingElement("Entry")
        elt = elt.firstChild().toElement()
        elt.toElement().setAttribute("value", str(threadsSimulator))

        elt = paramNode.firstChildElement("Entry")
        while elt.attribute("label") != "threads.generator":
            elt = elt.nextSiblingElement("Entry")
        elt = elt.firstChild().toElement()
        elt.toElement().setAttribute("value", str(threadsGenerator))

        if self.checkBoxGen.isChecked():
            if threadsGenerator < GeneratorSeeds.childNodes().count():
                compteur = GeneratorSeeds.childNodes().count()-threadsGenerator
                while compteur !=0 :
                    GeneratorSeeds.removeChild(GeneratorSeeds.lastChild())
                    compteur = compteur -1
            else:
                compteur = threadsGenerator-GeneratorSeeds.childNodes().count()
                while compteur != 0 :
                    GeneratorSeeds.appendChild(GeneratorSeeds.ownerDocument().createElement("Randomizer"))
                    compteur = compteur -1
                
        if self.checkBoxSim.isChecked():
            if threadsSimulator < SimulatorSeeds.childNodes().count():
                compteur = SimulatorSeeds.childNodes().count()-threadsSimulator
                while compteur !=0 :
                    SimulatorSeeds.removeChild(SimulatorSeeds.lastChild())
                    compteur = compteur -1
            else:
                compteur = threadsSimulator-SimulatorSeeds.childNodes().count()
                while compteur != 0 :
                    SimulatorSeeds.appendChild(SimulatorSeeds.ownerDocument().createElement("Randomizer"))
                    compteur = compteur -1

        #Generator pseudo-random numbers for seeds
        fileNumber = 0
        tmpTextStream = QtCore.QTextStream()
        randomGenerator = SystemRandom()
        if self.comboBoxBits.currentIndex() == 0:
            bitLength = 64
            maxLong = 18446744073709551615 
        else:
            bitLength = 32 
            maxLong = 4294967295

        while fileNumber != self.spinBoxNumFile.value():
            if self.checkBoxGen.isChecked():
                for i in range(0,GeneratorSeeds.childNodes().count()):
                    currentRand = GeneratorSeeds.childNodes().item(i)
                    currentRand.toElement().setAttribute("state","")
                    try :
                        randomLong = randomGenerator.getrandbits(bitLength)
                    except NotImplementedError:
                        randomLong = randint(1,maxLong)
                    currentRand.toElement().setAttribute("seed",randomLong)
            if self.checkBoxSim.isChecked():
                for i in range(0,SimulatorSeeds.childNodes().count()):
                    currentRand = SimulatorSeeds.childNodes().item(i)
                    currentRand.toElement().setAttribute("state","")
                    try :
                        randomLong = randomGenerator.getrandbits(bitLength)
                    except NotImplementedError:
                        randomLong = randint(1,maxLong)
                    currentRand.toElement().setAttribute("seed",randomLong)
            fileP = QtCore.QFile(str(self.baseFile).rsplit(".")[0]+("_")+str(fileNumber)+".xml")
            fileP.open(QtCore.QIODevice.ReadWrite|QtCore.QIODevice.Truncate)
            tmpTextStream.setDevice(fileP)
            rootNode.save(tmpTextStream,5)
            fileP.close()
            fileNumber += 1
            self.counter += 1
            self.progressB.setValue(self.counter)

#.........这里部分代码省略.........

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
# SOFTWARE.

# Python2.5+
from flask import Flask, request, session, g, redirect, url_for, \
     abort, render_template, flash

from random import SystemRandom
from base64 import b64encode

import runner

rng = SystemRandom()

# configuration
DEBUG = False
SECRET_KEY = b64encode(str(rng.getrandbits(256)))
USERNAME = b64encode(str(rng.getrandbits(256)))
PASSWORD = b64encode(str(rng.getrandbits(256)))

app = Flask(__name__)
app.config.from_object(__name__)

@app.route('/', methods=['GET'])
def classify_upload():
    if request.method == 'GET':
        filename = request.args.get('fileid') or None
        if filename is not None:
            return runner.class_img(filename)

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
def _create_hash():
    rand = SystemRandom()
    return hashlib.sha512(str(rand.getrandbits(512))).hexdigest()

# 需要导入模块: from random import SystemRandom [as 别名]
# 或者: from random.SystemRandom import getrandbits [as 别名]
import csv
import cfg
from random import SystemRandom
from puf import Challenge
from database import database

device = database['1234']

rnd = SystemRandom()
with open('outputs/1234.out.csv', 'w') as out:
    csvout = csv.writer(out)
    for _ in range(2048):
        i = rnd.getrandbits(cfg.RSP_LEN)
        c = Challenge(('{0:0' + str(cfg.RSP_LEN) + 'b}')
                      .format(i))
        r = device.f(c)
        csvout.writerow(list(c.to01()) + [r])