예제 #1
0
파일: gameapi.py 프로젝트: enj/color-game
    def __init__(self, known_pattern=None, session=db_session):
        '''Instantiates a color game based on a random color pattern.

        If known_pattern is specified, this color pattern is used to create the game
        instead of a random pattern.  This should only be used for testing purposes.

        If session is specified, this DB session is used instead of the standard session.

        :param known_pattern: a list (or tuple) of one-letter colors (default: None)
        :param session: the DB session (default: standard color game session)
        '''
        # Make sure to cleanup database resources on exit
        register(self._cleanup)

        # Set up DB session
        self.s = session

        if known_pattern is None:
            sr = SystemRandom()
            self.pattern = [sr.choice(colors_short) for _ in range(PATTERN_LENGTH)]
        else:
            self.pattern = known_pattern
        self.pattern_set = set(self.pattern)
        self.game = ColorGame(pattern=ColorPattern(self.pattern))
        self.s.add(self.game)
        self.s.commit()
예제 #2
0
    def generate_groups(self):
        """
        Generates the groups based on a randomization algorithm.
        :return: the generated groups: a list of lists (names)
        """

        if not self.names:
            raise AttributeError("Could not find names list. Try re-initializing Engine with valid filepath.")

        groups = []

        cryptogen = SystemRandom()
        cryptogen.shuffle(self.names)

        current_group = []
        for name in self.names:

            current_group.append(name)

            is_last_name = self.names.index(name) == len(self.names) - 1
            is_group_full = len(current_group) == self.group_size

            if is_group_full or is_last_name:
                groups.append(current_group)
                current_group = []

        logging.info("Created {} groups with max size {}.".format(len(groups), self.group_size))

        return groups
예제 #3
0
파일: __init__.py 프로젝트: micah/diceware
def get_passphrase(wordnum=6, specialsnum=1, delimiter='', lang='en',
                   capitalized=True, wordlist_fd=None):
    """Get a diceware passphrase.

    The passphrase returned will contain `wordnum` words deliimted by
    `delimiter`.

    If `capitalized` is ``True``, all words will be capitalized.

    If `wordlist_fd`, a file descriptor, is given, it will be used
    instead of a 'built-in' wordlist (and `lang` will be
    ignored). `wordlist_fd` must be open for reading.

    The wordlist to pick words from is determined by `lang`,
    representing a language (unless `wordlist_fd` is given).

    """
    if wordlist_fd is None:
        wordlist_fd = open(get_wordlist_path(lang), 'r')
    word_list = get_wordlist(wordlist_fd)
    rnd = SystemRandom()
    words = [rnd.choice(word_list) for x in range(wordnum)]
    if capitalized:
        words = [x.capitalize() for x in words]
    result = delimiter.join(words)
    for _ in range(specialsnum):
        result = insert_special_char(result, rnd=rnd)
    return result
예제 #4
0
def random_password(description, min_chars=10, max_chars=20):
    """
    Creates a random password from uppercase letters, lowercase letters and
    digits with a length between min_chars and max_chars
    """

    # Open saved passwords file or create new one.
    try:
        fh = open("info/passwords.json", "r+")
        passwords = json.load(fh)
    except IOError:
        fh = open("info/passwords.json", "w+")
        passwords = {}

    # Return password if it exists already
    if description in passwords:
        fh.close()
        return passwords[description]

    # Create new password if it does not exist
    else:
        seeded_random = SystemRandom()
        chars = ascii_letters + digits
        password_length = seeded_random.randint(min_chars, max_chars)
        password = "".join(seeded_random.choice(chars) for _ in range(password_length))
        passwords[description] = password
        fh.seek(0)
        json.dump(passwords, fh, indent=4)
        fh.close()

        return password
예제 #5
0
    def generate_config(self, env_script, start_script, server_cert=None):
        """Generates the plugin configuration file

        Parameters
        ----------
        env_script : str
            The CLI call used to load the environment in which the plugin is
            installed
        start_script : str
            The script used to start the plugin
        server_cert : str, optional
            If the Qiita server used does not have a valid certificate, the
            path to the Qiita certificate so the plugin can connect over
            HTTPS to it
        """
        logger.debug('Entered BaseQiitaPlugin.generate_config()')
        sr = SystemRandom()
        chars = ascii_letters + digits
        client_id = ''.join(sr.choice(chars) for i in range(50))
        client_secret = ''.join(sr.choice(chars) for i in range(255))

        server_cert = server_cert if server_cert else ""

        with open(self.conf_fp, 'w') as f:
            f.write(CONF_TEMPLATE % (self.name, self.version, self.description,
                                     env_script, start_script,
                                     self._plugin_type, self.publications,
                                     server_cert, client_id, client_secret))
예제 #6
0
def getFiles(gendpointDict, uendpoint, username, upath):

    label = str(uuid4())

    endNames = gendpointDict.keys()

    for thisEndName in endNames:

        fileList = gendpointDict[thisEndName]

        cryptogen = SystemRandom()
        transferFile = '/tmp/transferList_' + thisEndName + '_' + str(cryptogen.randint(1,9999)) + '.txt'
        file = open(transferFile, 'w')

        for thisFile in fileList:

            basename = os.path.basename(thisFile)

            if upath[-1] != '/':
                basename = '/' + basename

            remote = thisFile
            local = upath + basename

            file.write(remote + ' ' + local + '\n')

        file.close()

        os.system("globus transfer "+thisEndName+" "+uendpoint+" --batch --label \"CLI Batch\" < "+transferFile)

        os.remove(transferFile)

    return
예제 #7
0
파일: user.py 프로젝트: ringuh/comics
	def generate_password(self):
		import string
		from random import SystemRandom
		rnd = SystemRandom() # use SystemRandom to get real random numbers
		chars = string.letters + string.digits
		length = 20
		return "".join(rnd.choice(chars) for _ in range(length))
예제 #8
0
    def get_session(self):
        """
        get current session associated with this request.
        if no current session, create a new session
        """
        if self.__session:
            return self.__session

        if "SESSIONID" in self.cookie:
            self.__sid = self.cookie["SESSIONID"].value
        else:
            rand = SystemRandom()
            rand_num = rand.random()
            self.__sid = md5.new(repr(rand_num)).hexdigest()
            self.__new_session_hook()

        if not os.path.exists("/tmp/.session"):
            os.mkdir("/tmp/.session")
        self.__session_file = shelve.open(
                "/tmp/.session/yagra_session_db",
                writeback=True)
        if self.__sid not in self.__session_file:
            self.__session_file[self.__sid] = {}
        self.__session = self.__session_file[self.__sid]
        return self.__session
예제 #9
0
def csprng(low, high, offset=0):
	rng = SystemRandom()
	rnum = rng.randint(low, high-1) + offset
	if rnum < 0:
		print("[-] Error: Random number generator returned out of bounds.")
		return None
	return rnum
예제 #10
0
def generate(word_list, words=5, specials=0):
    rnd = SystemRandom()
    words = [ rnd.choice(word_list) for _ in range(words) ]

    # Insert at most options.special special characters. This is not
    # exactly the procedure described in the Diceware web page, because
    # this handles the case where there are more than 6 words in the
    # passphrase and more than 6 characters in the word.
    if specials:
        split_words = [ map(None, x) for x in words ]
        for _ in range(specials):
            # i is the index of the word in which the special character
            # replacement takes place.
            i = rnd.randrange(len(split_words))

            # j is the index of the character to be replaced with a special
            # character.
            j = rnd.randrange(len(split_words[i]))

            # k is the index of the special character
            k = rnd.randrange(len(SPECIAL_CHARS))

            # Split to individual characters, replace the k'th char, unsplit
            split_words[i][j] = SPECIAL_CHARS[k]

        with_specials = [ "".join(x) for x in split_words ]
    else:
        with_specials = words

    return words, with_specials
예제 #11
0
def get_encrypted_password(password, hashtype='sha512', salt=None):

    # TODO: find a way to construct dynamically from system
    cryptmethod= {
        'md5':      '1',
        'blowfish': '2a',
        'sha256':   '5',
        'sha512':   '6',
    }

    if hashtype in cryptmethod:
        if salt is None:
            r = SystemRandom()
            if hashtype in ['md5']:
                saltsize = 8
            else:
                saltsize = 16
            salt = ''.join([r.choice(string.ascii_letters + string.digits) for _ in range(saltsize)])

        if not HAS_PASSLIB:
            if sys.platform.startswith('darwin'):
                raise errors.AnsibleFilterError('|password_hash requires the passlib python module to generate password hashes on Mac OS X/Darwin')
            saltstring =  "$%s$%s" % (cryptmethod[hashtype],salt)
            encrypted = crypt.crypt(password, saltstring)
        else:
            if hashtype == 'blowfish':
                cls = passlib.hash.bcrypt;
            else:
                cls = getattr(passlib.hash, '%s_crypt' % hashtype)

            encrypted = cls.encrypt(password, salt=salt)

        return encrypted

    return None
예제 #12
0
def client_func(E, P, Q):
    n = E.order
    gen = SystemRandom()
    an = gen.randrange(n)
    bn = gen.randrange(n)
    am = an
    bm = bn
    Xn = P*an + Q*bn
    Xm = Xn

    while (True):
        i = __H(Xn, L)
        Xn += R[i]
        an += c[i]
        bn += d[i]

        for j in range(2):
            h = __H(Xm, L)
            Xm += R[h]
            am += c[h]
            bm += d[h]

        if Xn == Xm:
            break

    if (bn == bm):
        raise ArithmeticError('Undefined value')

    f = an-am
    g = invmod(bm-bn, n)
    ret = (f * g) % n
    ret = (ret + n) % n
    sendToServer(ret)
예제 #13
0
    def __init__(self, config, director, scheduler, _reactor=reactor):
        self._reactor = reactor
        self.director = director
        self.scheduler = scheduler

        self.config = config
        self.measurement_path = FilePath(config.measurements_directory)

        # We use a double submit token to protect against XSRF
        rng = SystemRandom()
        token_space = string.letters+string.digits
        self._xsrf_token = b''.join([rng.choice(token_space)
                                    for _ in range(30)])

        self._director_started = False
        self._is_initialized = config.is_initialized()

        # We use exponential backoff to trigger retries of the startup of
        # the director.
        self._director_startup_retries = 0
        # Maximum delay should be 30 minutes
        self._director_max_retry_delay = 30*60

        self.status_poller = LongPoller(
            self._long_polling_timeout, _reactor)
        self.director_event_poller = LongPoller(
            self._long_polling_timeout, _reactor)

        # XXX move this elsewhere
        self.director_event_poller.start()
        self.status_poller.start()

        self.director.subscribe(self.handle_director_event)
        if self._is_initialized:
            self.start_director()
예제 #14
0
def check_collisions(upper_bound):
    """
    Function that keeps guessing random numbers 1 to N incluside, until it hits a collision (or doesn't)
    """
    cryptogen = SystemRandom() # OS Internal system for generating cryptographic random numbers
    already_found = set([]) # Set of numbers the adversary already found
    iterations = 1
    start = time.time()
    found = False
    try:
        while not found: # Runs until a collision is found
            item = cryptogen.randrange(1,upper_bound) # Uses the cryptographically secure PRNG to generate a random number
            if item in already_found: # If it's in the set of things already found - print the statistics
                found = True
                print "duplicate found in %.2e tries in %f seconds" % (iterations, time.time()-start)
                print "The upper bound on this probability is %.2f %%" % (coll(iterations,upper_bound)*100)
            else: # If it's a new number, add it to the set of numbers checked
                already_found.add(item)
                iterations+=1
    except KeyboardInterrupt: # If someone cancels the program midway - prints some statistics about the current progress
        total_time = time.time()-start
        print "Program cancelled - made %.2e attempts in %.4f seconds" % (iterations, total_time)
        print "The upper bound on getting a duplicate is %.2f %%" % (coll(iterations,upper_bound)*100)
        onepercent = ntimes(.01,upper_bound)
        rate = total_time/iterations
        seconds = onepercent*rate
        print "To have 1%% probability of guessing you need at least %d tries, at this rate it would take %f seconds" % (onepercent, seconds)
        print "%.2f minutes, %.2f hours, %.2f days, %.2f years" % (seconds/60, seconds/60/60, seconds/60/60/24, seconds/60/60/24/365)
예제 #15
0
    def createUserSessionKey(org, username, sessionId,
                             consistency=ConsistencyLevel.LOCAL_QUORUM,
                             session=None):
        """
        Create a session key record in the usersessionkeys table for the given
        user session

        :org:
            Name of organization for the user
        :username:
            Name of the user
        :sessionid:
            ID of the session to create a key for
        """
        charList = (list(range(48, 58)) +  # Numbers
                    list(range(65, 91)) +  # Uppercase
                    list(range(97, 123)))  # Lowercase
        sysrand = SystemRandom()
        sessionKey = ''.join(
            chr(sysrand.choice(charList))
            for i in range(64))
        try:
            createUserSessionKeyQuery = CassandraCluster.getPreparedStatement(
                """
                INSERT INTO usersessionkeys ( sessionkey, org, username,
                    sessionid )
                VALUES ( ?, ?, ?, ? )
                """, keyspace=session.keyspace)
            createUserSessionKeyQuery.consistency_level = consistency
            session.execute(createUserSessionKeyQuery,
                            (sessionKey, org, username, sessionId))
            return sessionKey
        except Exception as e:
            log.critical("Exception in AuthDB.createUserSessionKey: %s" % (e,))
예제 #16
0
파일: user.py 프로젝트: ubnetdef/bank-api
def newAccount():
	"""
	Create's a new account under this user. Balance
	is always 0
	"""
	try:
		check_params(request, ["session", "pin"])
		user = validate_session(request.form["session"])
	except StandardError as e:
		return respond(str(e), code=400), 400

	gen = SystemRandom()
	accnum = str(''.join(map(str, [gen.randrange(9) for i in range(10)])))
	pin = int(request.form["pin"])
	newaccount = Account(accnum, user, 0.00, pin)
	
	try:
		db.session.add(newaccount)
		db.session.commit()

		add_log(LOG_ACCOUNT, "User %s created a new account (%s)" % (user.username, accnum))
	except:
		db.session.rollback()

		return respond("An internal error has occured. Please try again.", code=400), 400

	# Delete their session
	delete_session(request.form["session"])

	return respond("Account created!", data={'account': newaccount.id, 'pin': newaccount.pin})
 def sign(self, message):
     """ Signs message using ECDSA.
     :param message: bytes to sign
     :return: bytes representing r, s.
     """
     m = hashlib.sha256()
     m.update(message)
     e = m.digest()
     ln = self.sign_curve.order.bit_length() // 8
     n = self.sign_curve.order
     z = e[0:ln]
     z = int.from_bytes(z, byteorder="big")  # Matching the BigInteger form in the java signing.
     certificate = 0
     while certificate == 0:
         rng = SystemRandom()
         k = rng.randint(1, n)
         kg = self.sign_curve.get_member(k)
         r = kg.x
         if r == 0:
             continue
         s = (mod_inv(k, n) * (z + (r * self.sign_key) % n) % n) % n
         if s == 0:
             continue
         l = [r, s]
         int_length = self.sign_curve.int_length // 8
         certificate = list_to_bytes(l, int_length)
     return certificate
def directionsGenerator(steps):
    ''' generate unity steps in random directions '''
    from random import SystemRandom
    from numpy import exp, pi
    s = SystemRandom()
    for i in xrange(steps):
        yield exp(s.random()*pi*2j)
예제 #19
0
def  rand_ortho1(n):
    r = SystemRandom()
    pos = [r.random() for x in range(n)]
    s = sum(pos)
    v = array(pos,dtype=float)-(s/float(n))
    norm = sqrt(sum(v*v))
    return v/norm
예제 #20
0
파일: ssconf.py 프로젝트: cyclefusion/szarp
	def new_password(self, user, passhash):
		"""
		Return new random password
		"""
		chars = '23456qwertasdfgzxcvbQWERTASDFGZXCVB789yuiophjknmYUIPHJKLNM'
		r = SystemRandom()
		return ''.join(r.sample(chars, 8))
예제 #21
0
def throwAndSetRandomRun(source,runsAndProbs):
    """Pass a list of tuple pairs, with the first item of the pair a run number
    and the second number of the pair a weight.  The function will normalize the
    weights so you do not have to worry about that.  The pairs will be used to randomly choose what Run
    should be assigned to the job.
    """
    from random import SystemRandom
    totalProb = 0.
    for r,p in runsAndProbs:
        totalProb+=p
    #this is the same random generator used to set the seeds for the RandomNumberGeneratorService
    random = SystemRandom()
    runProb = random.uniform(0,totalProb)
    sumProb = 0
    runNumber = 0
    for r,p in runsAndProbs:
        sumProb+=p
        if sumProb >= runProb:
            runNumber = r
            break
    print('setting runNumber to: ',runNumber)
    if source.type_() == "PoolSource":
        source.setRunNumber = cms.untracked.uint32(runNumber)
    else:
        #sources that inherit from ConfigurableInputSource use 'firstRun'
        source.firstRun = cms.untracked.uint32(runNumber)

    return
예제 #22
0
    def populate(self, *excludePSets):
        """
        _populate_

        generate a bunch of seeds and stick them into this service
        This is the lazy user method.

        Optional args are names of PSets to *NOT* alter seeds.

        Eg:
        populate() will set all seeds
        populate("pset1", "pset2") will set all seeds but not those in
        psets named pset1 and pset2

        """

        import random
        from random import SystemRandom
        _inst = SystemRandom()
        _MAXINT = 900000000

        #  //
        # // count seeds and create the required number of seeds
        #//
        newSeeds = [ _inst.randint(1, _MAXINT)
                     for i in range(self.countSeeds())]


        self._lockedSeeds = list(excludePSets)
        self.insertSeeds(*newSeeds)
        self._lockedSeeds = []
        return
예제 #23
0
    def test_stress(self):
        """
        Runs a large number of threads doing operations with resources
        checked out, ensuring properties of the pool.
        """
        rand = SystemRandom()
        n = rand.randint(1, 400)
        passes = rand.randint(1, 20)
        rounds = rand.randint(1, 200)
        breaker = rand.uniform(0, 1)
        pool = EmptyListPool()

        def _run():
            for i in range(rounds):
                with pool.transaction() as a:
                    self.assertEqual([], a)
                    a.append(currentThread())
                    self.assertEqual([currentThread()], a)

                    for p in range(passes):
                        self.assertEqual([currentThread()], a)
                        if rand.uniform(0, 1) > breaker:
                            break

                    a.remove(currentThread())

        threads = []

        for i in range(n):
            th = Thread(target=_run)
            threads.append(th)
            th.start()

        for th in threads:
            th.join()
예제 #24
0
파일: rpcauth.py 프로젝트: CryptoRekt/VERGE
def generate_salt():
    # This uses os.urandom() underneath
    cryptogen = SystemRandom()

    # Create 16 byte hex salt
    salt_sequence = [cryptogen.randrange(256) for _ in range(16)]
    return ''.join([format(r, 'x') for r in salt_sequence])
예제 #25
0
파일: oracle.py 프로젝트: rot256/Wargames
def get_prime(low, high):
    csprng = SystemRandom()
    n = csprng.randrange(low, high)
    if n % 2 == 0:
        n += 1
    while not miller_rabin(n):
        n += 2
    return n
예제 #26
0
파일: utils.py 프로젝트: serolquo/sefs
 def __init__(self, length=16):
     rand = SystemRandom()
     rand_chars = rand.sample(RandomString.charsets,length)
     self.generated_string = "".join(rand_chars)
     
     m = hashlib.md5()
     m.update(self.generated_string)
     self.md5 = m.digest()
예제 #27
0
def tcp_scan(ips, ports, randomize=True):
    loop = asyncio.get_event_loop()
    if randomize:
        rdev = SystemRandom()
        ips = rdev.shuffle(ips)
        ports = rdev.shuffle(ports)

    tcp_Scanner_run(tcp_scanner(ip, port) for port in ports for ip in ips)
예제 #28
0
def encrypt(message,pubkey):
    ordnums = [ord(ch) for ch in message]
    p,a,akp = pubkey
    r1 = SystemRandom(time.time())
    l = r1.randint(1,p-2)
    d = pow(a,l,p)
    encnums = [onum * pow(akp,l,p) for onum in ordnums]
    return (d,encnums)
예제 #29
0
	def createRandomToken(self):
		'''Create a random byte sequence to use as a repeating token'''
		r = SystemRandom()
		token = bytearray()
		numBytes = r.choice([3, 4, 5, 6])
		for i in range(numBytes):
			token.append(r.randrange(256))
		return token
예제 #30
0
파일: utils.py 프로젝트: idkwim/grandalf
def  rand_ortho1(n):
    from random import SystemRandom
    r = SystemRandom()
    pos = [r.random() for x in xrange(n)]
    s = sum(pos)
    v = array(pos,dtype=float)-(s/len(pos))
    norm = sqrt(sum(v*v))
    return v/norm
예제 #31
0
def cycle_app_reverse_cache(*args, **kwargs):
    """Does not really empty the cache; instead it adds a random element to the
    cache key generation which guarantees that the cache does not yet contain
    values for all newly generated keys"""
    cache.set('app_reverse_cache_generation', str(SystemRandom().random()))
예제 #32
0
from struct import Struct
from random import SystemRandom
from operator import xor
from itertools import starmap

from werkzeug._compat import range_type, PY2, text_type, izip, to_bytes, \
    string_types, to_native


SALT_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
DEFAULT_PBKDF2_ITERATIONS = 1000


_pack_int = Struct('>I').pack
_builtin_safe_str_cmp = getattr(hmac, 'compare_digest', None)
_sys_rng = SystemRandom()
_os_alt_seps = list(sep for sep in [os.path.sep, os.path.altsep]
                    if sep not in (None, '/'))


def _find_hashlib_algorithms():
    algos = getattr(hashlib, 'algorithms', None)
    if algos is None:
        algos = ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
    rv = {}
    for algo in algos:
        func = getattr(hashlib, algo, None)
        if func is not None:
            rv[algo] = func
    return rv
_hash_funcs = _find_hashlib_algorithms()
예제 #33
0
# Schnorr signature built using:
# Elliptic Curve Cryptography using the BitCoin curve, SECG secp256k1
#  This version uses the X,Y,Z "Jacobi coordinates" representation, for speed
#  Dr. Orion Lawlor, [email protected], 2015-03-25 (Public Domain)
from hashlib import sha256
from random import SystemRandom  # cryptographic random byte generator
#from Oracle import Oracle

rand = SystemRandom()  # create strong random number generator


def hex2int(hexString):
    return int("".join(hexString.replace(":", "").split()), 16)


# Half the extended Euclidean algorithm:
#    Computes   gcd(a,b) = a*x + b*y
#    Returns only gcd, x (not y)
# From http://rosettacode.org/wiki/Modular_inverse#Python
def half_extended_gcd(aa, bb):
    lastrem, rem = abs(aa), abs(bb)
    x, lastx = 0, 1
    while rem:
        lastrem, (quotient, rem) = rem, divmod(lastrem, rem)
        x, lastx = lastx - quotient * x, x
    return lastrem, lastx


# Modular inverse: compute the multiplicative inverse i of a mod m:
#     i*a = a*i = 1 mod m
def modular_inverse(a, m):
예제 #34
0
파일: save_file.py 프로젝트: ngslabex/pcr
global data_dir
data_dir = 'data/'
form = cgi.FieldStorage()

# A nested FieldStorage instance holds the file
fileitem = form['fastafile']

# Test if the file was uploaded
#message = "oops"
#message = str(form)

message = ''

global run_name
run_name = ''.join(SystemRandom().choice(ascii_uppercase + digits)
                   for _ in range(6))
while os.path.isfile(run_name):
    run_name = ''.join(SystemRandom().choice(ascii_uppercase + digits)
                       for _ in range(6))


#writes a sequence or sequence file to the data directory
def write_sequence(sequence, sequence_filename):

    fasta_filename = data_dir + run_name
    if sequence != '':
        if check_fasta(sequence, 'nucleotide', false):
            fasta_file = open(fasta_filename)
            sequence = clean_sequence(sequence)
            fasta_file.write(sequence)
예제 #35
0
 def __init__(self, configuration=None, name=None):
     SimpleService.__init__(self, configuration=configuration, name=name)
     self.order = ORDER
     self.definitions = CHARTS
     self.random = SystemRandom()
예제 #36
0
from app.scrum.prod import prod

app.register_blueprint(prod)
from app.scrum.mast import mast

app.register_blueprint(mast)
from app.scrum.dev import dev

app.register_blueprint(dev)
from app.scrum.actor import actor

app.register_blueprint(actor)
from app.scrum.objetivo import objetivo

app.register_blueprint(objetivo)
from app.scrum.accion import accion

app.register_blueprint(accion)
from app.scrum.historias import historias

app.register_blueprint(historias)
from app.scrum.tareas import tareas

app.register_blueprint(tareas)
from app.scrum.cates import cates

app.register_blueprint(cates)

if __name__ == '__main__':
    app.config.update(SECRET_KEY=repr(SystemRandom().random()))
    manager.run()
예제 #37
0
파일: utils.py 프로젝트: athrabeth/passpie
def genpass(length=32, special="_-#|+="):
    """generates a password with random chararcters
    """
    chars = special + string.ascii_letters + string.digits + " "
    return "".join(SystemRandom().choice(chars) for _ in range(length))
예제 #38
0
import json

np.set_printoptions(threshold=np.inf)


def unwrap_self_pairs(arg, **kwarg):
    """
    Helper function for multiprocessing
    :param arg:
    :param kwarg:
    :return:
    """
    return KeyReader.chitext_creation_process(*arg, **kwarg)


gen = SystemRandom()


def generate_plaintext(length):
    """
    Generieren von Klartext als liste
    :param length:
    :return:
    """
    # return [1, 0, 1, 0, 0] # For testing purposes
    # return np.asarray([randint(0, 1) for x in xrange(length)])
    return np.asarray([gen.randrange(2) for x in xrange(length)])


class KeyReader:
    """
예제 #39
0
파일: text.py 프로젝트: leoxian/Coroutine
from Crypto.PublicKey import RSA
from Crypto.Hash import SHA256
from random import SystemRandom

# Signing authority (SA) key
priv = RSA.generate(3072)
pub = priv.publickey()

## Protocol: Blind signature ##

# must be guaranteed to be chosen uniformly at random
r = SystemRandom().randrange(pub.n >> 10, pub.n)

msg = 'OStoLFQC'  # large message (larger than the modulus)
msg = str.encode(msg)

# hash message so that messages of arbitrary length can be signed
hash = SHA256.new()
hash.update(msg)
msgDigest = hash.digest()

# user computes
msg_blinded = pub.blind(msgDigest, r)

# SA computes
msg_blinded_signature = priv.sign(msg_blinded, 0)

# user computes
msg_signature = pub.unblind(msg_blinded_signature[0], r)

print('----msg_signature---------')
예제 #40
0
class Interest(object):
    def __init__(self, value=None):
        if isinstance(value, Interest):
            # Copy the values.
            self._name = ChangeCounter(Name(value.getName()))
            self._minSuffixComponents = value._minSuffixComponents
            self._maxSuffixComponents = value._maxSuffixComponents
            self._keyLocator = ChangeCounter(KeyLocator(value.getKeyLocator()))
            self._exclude = ChangeCounter(Exclude(value.getExclude()))
            self._childSelector = value._childSelector
            self._mustBeFresh = value._mustBeFresh

            self._nonce = value.getNonce()
            self._interestLifetimeMilliseconds = value._interestLifetimeMilliseconds
            self._forwardingHint = ChangeCounter(
                DelegationSet(value.getForwardingHint()))
            self._linkWireEncoding = value._linkWireEncoding
            self._linkWireEncodingFormat = value._linkWireEncodingFormat
            self._link = ChangeCounter(None)
            if value._link.get() != None:
                self._link.set(Link(value._link.get()))
            self._selectedDelegationIndex = value._selectedDelegationIndex
            self._defaultWireEncoding = value.getDefaultWireEncoding()
            self._defaultWireEncodingFormat = value._defaultWireEncodingFormat
        else:
            self._name = ChangeCounter(
                Name(value) if isinstance(value, Name) else Name())
            self._minSuffixComponents = None
            self._maxSuffixComponents = None
            self._keyLocator = ChangeCounter(KeyLocator())
            self._exclude = ChangeCounter(Exclude())
            self._childSelector = None
            self._mustBeFresh = True

            self._nonce = Blob()
            self._interestLifetimeMilliseconds = None
            self._forwardingHint = ChangeCounter(DelegationSet())
            self._linkWireEncoding = Blob()
            self._linkWireEncodingFormat = None
            self._link = ChangeCounter(None)
            self._selectedDelegationIndex = None
            self._defaultWireEncoding = SignedBlob()
            self._defaultWireEncodingFormat = None

        self._getNonceChangeCount = 0
        self._getDefaultWireEncodingChangeCount = 0
        self._changeCount = 0
        self._lpPacket = None

    def getName(self):
        """
        Get the interest Name.

        :return: The name.  The name size() may be 0 if not specified.
        :rtype: Name
        """
        return self._name.get()

    def getMinSuffixComponents(self):
        """
        Get the min suffix components.

        :return: The min suffix components, or None if not specified.
        :rtype: int
        """
        return self._minSuffixComponents

    def getMaxSuffixComponents(self):
        """
        Get the max suffix components.

        :return: The max suffix components, or None if not specified.
        :rtype: int
        """
        return self._maxSuffixComponents

    def getKeyLocator(self):
        """
        Get the interest key locator.

        :return: The key locator. If getType() is None, then the key locator
          is not specified.
        :rtype: KeyLocator
        """
        return self._keyLocator.get()

    def getExclude(self):
        """
        Get the exclude object.

        :return: The exclude object. If the exclude size() is zero, then
          the exclude is not specified.
        :rtype: Exclude
        """
        return self._exclude.get()

    def getChildSelector(self):
        """
        Get the child selector.

        :return: The child selector, or None if not specified.
        :rtype: int
        """
        return self._childSelector

    def getMustBeFresh(self):
        """
        Get the must be fresh flag.

        :return: The must be fresh flag.  If not specified, the default is
          True.
        :rtype: bool
        """
        return self._mustBeFresh

    def getNonce(self):
        """
        Return the nonce value from the incoming interest.  If you change any of
        the fields in this Interest object, then the nonce value is cleared.

        :return: The nonce.  If isNull() then the nonce is omitted.
        :rtype: Blob
        """
        if self._getNonceChangeCount != self.getChangeCount():
            # The values have changed, so the existing nonce is invalidated.
            self._nonce = Blob()
            self._getNonceChangeCount = self.getChangeCount()

        return self._nonce

    def getForwardingHint(self):
        """
        Get the forwarding hint object which you can modify to add or remove
        forwarding hints.

        :return: The forwarding hint as a DelegationSet.
        :rtype: DelegationSet
        """
        return self._forwardingHint.get()

    def hasLink(self):
        """
        Check if this interest has a link object (or a link wire encoding which
        can be decoded to make the link object).

        :return:  True if this interest has a link object, False if not.
        :rtype: bool
        :deprecated: Use getForwardingHint.
        """
        return self._link.get() != None or not self._linkWireEncoding.isNull()

    def getLink(self):
        """
        Get the link object. If necessary, decode it from the link wire encoding.

        :return: The link object, or None if not specified.
        :rtype: Link
        :raises ValueError: For error decoding the link wire encoding (if
          necessary).
        :deprecated: Use getForwardingHint.
        """
        if self._link.get() != None:
            return self._link.get()
        elif not self._linkWireEncoding.isNull():
            # Decode the link object from linkWireEncoding_.
            link = Link()
            link.wireDecode(self._linkWireEncoding,
                            self._linkWireEncodingFormat)
            self._link.set(link)

            # Clear _linkWireEncoding since it is now managed by the link object.
            self._linkWireEncoding = Blob()
            self._linkWireEncodingFormat = None

            return link
        else:
            return None

    def getLinkWireEncoding(self, wireFormat=None):
        """
        Get the wire encoding of the link object. If there is already a wire
        encoding then return it. Otherwise encode from the link object (if
        available).

        :param WireFormat wireFormat: (optional) A WireFormat object used to
          encode the Link. If omitted, use WireFormat.getDefaultWireFormat().
        :return: The wire encoding, or an isNull Blob if the link is not
          specified.
        :rtype: Blob
        :deprecated: Use getForwardingHint.
        """
        if wireFormat == None:
            # Don't use a default argument since getDefaultWireFormat can change.
            wireFormat = WireFormat.getDefaultWireFormat()

        if (not self._linkWireEncoding.isNull()
                and self._linkWireEncodingFormat == wireFormat):
            return self._linkWireEncoding

        link = self.getLink()
        if link != None:
            return link.wireEncode(wireFormat)
        else:
            return Blob()

    def getSelectedDelegationIndex(self):
        """
        Get the selected delegation index.

        :return: The selected delegation index. If not specified, return None.
        :rtype: int
        :deprecated: Use getForwardingHint.
        """
        return self._selectedDelegationIndex

    def getInterestLifetimeMilliseconds(self):
        """
        Get the interest lifetime.

        :return: The interest lifetime in milliseconds, or None if not specified.
        :rtype: float
        """
        return self._interestLifetimeMilliseconds

    def getIncomingFaceId(self):
        """
        Get the incoming face ID according to the incoming packet header.

        :return: The incoming face ID. If not specified, return None.
        :rtype: int
        """
        field = (None if self._lpPacket == None else
                 IncomingFaceId.getFirstHeader(self._lpPacket))
        return None if field == None else field.getFaceId()

    def setName(self, name):
        """
        Set the interest name.

        :note: You can also call getName and change the name values directly.
        :param Name name: The interest name. This makes a copy of the name.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._name.set(name if isinstance(name, Name) else Name(name))
        self._changeCount += 1
        return self

    def setMinSuffixComponents(self, minSuffixComponents):
        """
        Set the min suffix components count.

        :param int minSuffixComponents: The min suffix components count. If not
          specified, set to None.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._minSuffixComponents = Common.nonNegativeIntOrNone(
            minSuffixComponents)
        self._changeCount += 1
        return self

    def setMaxSuffixComponents(self, maxSuffixComponents):
        """
        Set the max suffix components count.

        :param int maxSuffixComponents: The max suffix components count. If not
          specified, set to None.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._maxSuffixComponents = Common.nonNegativeIntOrNone(
            maxSuffixComponents)
        self._changeCount += 1
        return self

    def setKeyLocator(self, keyLocator):
        """
        Set this interest to use a copy of the given KeyLocator object.

        :note: You can also call getKeyLocator and change the key locator directly.
        :param KeyLocator keyLocator: The KeyLocator object. This makes a copy
          of the object. If no key locator is specified, set to a new default
          KeyLocator(), or to a KeyLocator with an unspecified type.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._keyLocator.set(
            KeyLocator(keyLocator) if isinstance(keyLocator, KeyLocator
                                                 ) else KeyLocator())
        self._changeCount += 1
        return self

    def setExclude(self, exclude):
        """
        Set this interest to use a copy of the given Exclude object.

        :note: You can also call getExclude and change the exclude entries directly.
        :param Exclude exclude: The Exclude object. This makes a copy of the
          object. If no exclude is specified, set to a new default Exclude(), or
          to an Exclude with size() 0.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._exclude.set(
            Exclude(exclude) if isinstance(exclude, Exclude) else Exclude())
        self._changeCount += 1
        return self

    def setForwardingHint(self, forwardingHint):
        """
        Set this interest to use a copy of the given DelegationSet object as the
        forwarding hint.

        :note: You can also call getForwardingHint and change the forwarding
          hint directly.
        :param DelegationSet forwardingHint: The DelegationSet object to use as
          the forwarding  hint. This makes a copy of the object. If no
          forwarding hint is specified, set to a new default DelegationSet()
          with no entries.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._forwardingHint.set(
            DelegationSet(forwardingHint) if isinstance(
                forwardingHint, DelegationSet) else DelegationSet())
        self._changeCount += 1
        return self

    def setLinkWireEncoding(self, encoding, wireFormat=None):
        """
        Set the link wire encoding bytes, without decoding them. If there is a
        link object, set it to None. If you later call getLink(), it will decode
        the wireEncoding to create the link object.

        :param Blob encoding: The Blob with the bytes of the link wire encoding.
          If no link is specified, set to an empty Blob() or call unsetLink().
        :param WireFormat wireFormat: The wire format of the encoding, to be
          used later if necessary to decode. If omitted, use
          WireFormat.getDefaultWireFormat().
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        :deprecated: Use setForwardingHint.
        """
        if wireFormat == None:
            # Don't use a default argument since getDefaultWireFormat can change.
            wireFormat = WireFormat.getDefaultWireFormat()

        self._linkWireEncoding = encoding
        self._linkWireEncodingFormat = wireFormat

        # Clear the link object, assuming that it has a different encoding.
        self._link.set(None)

        self._changeCount += 1
        return self

    def unsetLink(self):
        """
        Clear the link wire encoding and link object so that getLink() returns
        None.

        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        :deprecated: Use setForwardingHint.
        """
        return self.setLinkWireEncoding(Blob(), None)

    def setSelectedDelegationIndex(self, selectedDelegationIndex):
        """
        Set the selected delegation index.

        :param int selectedDelegationIndex: The selected delegation index. If
          not specified, set to None.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        :deprecated: Use setForwardingHint.
        """
        self._selectedDelegationIndex = Common.nonNegativeIntOrNone(
            selectedDelegationIndex)
        self._changeCount += 1
        return self

    def setChildSelector(self, childSelector):
        """
        Set the child selector.

        :param int childSelector: The child selector. If not specified, set to None.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._childSelector = Common.nonNegativeIntOrNone(childSelector)
        self._changeCount += 1
        return self

    def setMustBeFresh(self, mustBeFresh):
        """
        Set the MustBeFresh flag.

        :param bool mustBeFresh: True if the content must be fresh, otherwise
          False. If you do not set this flag, the default value is true.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._mustBeFresh = True if mustBeFresh else False
        self._changeCount += 1
        return self

    def setNonce(self, nonce):
        """
        :deprecated: You should let the wire encoder generate a random nonce
          internally before sending the interest.
        """
        self._nonce = nonce if isinstance(nonce, Blob) else Blob(nonce)
        # Set _getNonceChangeCount so that the next call to getNonce() won't
        #   clear _nonce.
        self._changeCount += 1
        self._getNonceChangeCount = self.getChangeCount()
        return self

    def setInterestLifetimeMilliseconds(self, interestLifetimeMilliseconds):
        """
        Set the interest lifetime.

        :param float interestLifetimeMilliseconds: The interest lifetime in
          milliseconds. If not specified, set to None.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        """
        self._interestLifetimeMilliseconds = Common.nonNegativeFloatOrNone(
            interestLifetimeMilliseconds)
        self._changeCount += 1
        return self

    def wireEncode(self, wireFormat=None):
        """
        Encode this Interest for a particular wire format. If wireFormat is the
        default wire format, also set the defaultWireEncoding field to the
        encoded result.

        :param wireFormat: (optional) A WireFormat object used to encode this
           Interest. If omitted, use WireFormat.getDefaultWireFormat().
        :type wireFormat: A subclass of WireFormat
        :return: The encoded buffer.
        :rtype: SignedBlob
        """
        if wireFormat == None:
            # Don't use a default argument since getDefaultWireFormat can change.
            wireFormat = WireFormat.getDefaultWireFormat()

        if (not self.getDefaultWireEncoding().isNull()
                and self.getDefaultWireEncodingFormat() == wireFormat):
            # We already have an encoding in the desired format.
            return self.getDefaultWireEncoding()

        (encoding, signedPortionBeginOffset, signedPortionEndOffset) = \
          wireFormat.encodeInterest(self)
        wireEncoding = SignedBlob(encoding, signedPortionBeginOffset,
                                  signedPortionEndOffset)

        if wireFormat == WireFormat.getDefaultWireFormat():
            # This is the default wire encoding.
            self._setDefaultWireEncoding(wireEncoding,
                                         WireFormat.getDefaultWireFormat())
        return wireEncoding

    def wireDecode(self, input, wireFormat=None):
        """
        Decode the input using a particular wire format and update this Interest.
        If wireFormat is the default wire format, also set the
        defaultWireEncoding to another pointer to the input.

        :param input: The array with the bytes to decode. If input is not a
          Blob, then copy the bytes to save the defaultWireEncoding (otherwise
          take another pointer to the same Blob).
        :type input: A Blob or an array type with int elements
        :param wireFormat: (optional) A WireFormat object used to decode this
           Interest. If omitted, use WireFormat.getDefaultWireFormat().
        :type wireFormat: A subclass of WireFormat
        """
        if wireFormat == None:
            # Don't use a default argument since getDefaultWireFormat can change.
            wireFormat = WireFormat.getDefaultWireFormat()

        if isinstance(input, Blob):
            # Input is a blob, so get its buf() and set copy False.
            result = wireFormat.decodeInterest(self, input.buf(), False)
        else:
            result = wireFormat.decodeInterest(self, input, True)
        (signedPortionBeginOffset, signedPortionEndOffset) = result

        if wireFormat == WireFormat.getDefaultWireFormat():
            # This is the default wire encoding.  In the Blob constructor, set
            #   copy true, but if input is already a Blob, it won't copy.
            self._setDefaultWireEncoding(
                SignedBlob(Blob(input, True), signedPortionBeginOffset,
                           signedPortionEndOffset),
                WireFormat.getDefaultWireFormat())
        else:
            self._setDefaultWireEncoding(SignedBlob(), None)

    def toUri(self):
        """
        Encode the name according to the "NDN URI Scheme".  If there are
        interest selectors, append "?" and add the selectors as a query string.
        For example "/test/name?ndn.ChildSelector=1".
        :note: This is an experimental feature. See the API docs for more detail at
        http://named-data.net/doc/ndn-ccl-api/interest.html#interest-touri-method .

        :return: The URI string.
        :rtype: string
        """
        selectors = ""
        if self._minSuffixComponents != None:
            selectors += "&ndn.MinSuffixComponents=" + repr(
                self._minSuffixComponents)
        if self._maxSuffixComponents != None:
            selectors += "&ndn.MaxSuffixComponents=" + repr(
                self._maxSuffixComponents)
        if self._childSelector != None:
            selectors += "&ndn.ChildSelector=" + repr(self._childSelector)
        if self._mustBeFresh:
            selectors += "&ndn.MustBeFresh=true"
        if self._interestLifetimeMilliseconds != None:
            selectors += "&ndn.InterestLifetime=" + repr(
                int(round(self._interestLifetimeMilliseconds)))
        if self.getNonce().size() > 0:
            selectors += ("&ndn.Nonce=" +
                          Name.toEscapedString(self.getNonce().buf()))
        if self.getExclude().size() > 0:
            selectors += "&ndn.Exclude=" + self.getExclude().toUri()

        result = self.getName().toUri()
        if selectors != "":
            # Replace the first & with ?.
            result += "?" + selectors[1:]

        return result

    def refreshNonce(self):
        """
        Update the bytes of the nonce with new random values. This ensures that
        the new nonce value is different than the current one. If the current
        nonce is not specified, this does nothing.
        """
        currentNonce = self.getNonce()
        if currentNonce.size() == 0:
            return

        while True:
            value = bytearray(currentNonce.size())
            for i in range(len(value)):
                value[i] = self._systemRandom.randint(0, 0xff)
            newNonce = Blob(value, False)
            if newNonce != currentNonce:
                break

        self._nonce = newNonce
        # Set _getNonceChangeCount so that the next call to getNonce() won't
        #   clear _nonce.
        self._changeCount += 1
        self._getNonceChangeCount = self.getChangeCount()

    def matchesName(self, name):
        """
        Check if this interest's name matches the given name (using Name.match)
        and the given name also conforms to the interest selectors.

        :param Name name: The name to check.
        :return: True if the name and interest selectors match, False otherwise.
        :rtype: bool
        """
        if not self.getName().match(name):
            return False

        if (self._minSuffixComponents != None and
                # Add 1 for the implicit digest.
                not (name.size() + 1 - self.getName().size() >=
                     self._minSuffixComponents)):
            return False
        if (self._maxSuffixComponents != None and
                # Add 1 for the implicit digest.
                not (name.size() + 1 - self.getName().size() <=
                     self._maxSuffixComponents)):
            return False
        if (self.getExclude().size() > 0
                and name.size() > self.getName().size()
                and self.getExclude().matches(name[self.getName().size()])):
            return False

        return True

    def matchesData(self, data, wireFormat=None):
        """
        Check if the given Data packet can satisfy this Interest. This method
        considers the Name, MinSuffixComponents, MaxSuffixComponents,
        PublisherPublicKeyLocator, and Exclude. It does not consider the
        ChildSelector or MustBeFresh. This uses the given wireFormat to get the
        Data packet encoding for the full Name.

        :param Data data: The Data packet to check.
        :param wireFormat: (optional) A WireFormat object used to encode the
          Data packet to get its full Name. If omitted, use
          WireFormat.getDefaultWireFormat().
        :type wireFormat: A subclass of WireFormat
        :return: True if the given Data packet can satisfy this Interest.
        :rtype: bool
        """
        # Imitate ndn-cxx Interest::matchesData.
        interestNameLength = self.getName().size()
        dataName = data.getName()
        fullNameLength = dataName.size() + 1

        # Check MinSuffixComponents.
        hasMinSuffixComponents = (self.getMinSuffixComponents() != None)
        minSuffixComponents = (self.getMinSuffixComponents()
                               if hasMinSuffixComponents else 0)
        if not (interestNameLength + minSuffixComponents <= fullNameLength):
            return False

        # Check MaxSuffixComponents.
        hasMaxSuffixComponents = (self.getMaxSuffixComponents() != None)
        if (hasMaxSuffixComponents
                and not (interestNameLength + self.getMaxSuffixComponents() >=
                         fullNameLength)):
            return False

        # Check the prefix.
        if interestNameLength == fullNameLength:
            if self.getName().get(-1).isImplicitSha256Digest():
                if not self.getName().equals(data.getFullName(wireFormat)):
                    return False
            else:
                # The Interest Name is the same length as the Data full Name,
                #   but the last component isn't a digest so there's no
                #   possibility of matching.
                return False
        else:
            # The Interest Name should be a strict prefix of the Data full Name.
            if not self.getName().isPrefixOf(dataName):
                return False

        # Check the Exclude.
        # The Exclude won't be violated if the Interest Name is the same as the
        #   Data full Name.
        if self.getExclude().size(
        ) > 0 and fullNameLength > interestNameLength:
            if interestNameLength == fullNameLength - 1:
                # The component to exclude is the digest.
                if self.getExclude().matches(
                        data.getFullName(wireFormat).get(interestNameLength)):
                    return False
            else:
                # The component to exclude is not the digest.
                if self.getExclude().matches(dataName.get(interestNameLength)):
                    return False

        # Check the KeyLocator.
        publisherPublicKeyLocator = self.getKeyLocator()
        if publisherPublicKeyLocator.getType() != None:
            signature = data.getSignature()
            if not KeyLocator.canGetFromSignature(signature):
                # No KeyLocator in the Data packet.
                return False
            if not publisherPublicKeyLocator.equals(
                (KeyLocator.getFromSignature(signature))):
                return False

        return True

    def getDefaultWireEncoding(self):
        """
        Return the default wire encoding, which was encoded with
        getDefaultWireEncodingFormat().

        :return: The default wire encoding, whose isNull() may be true if there
          is no default wire encoding.
        :rtype: SignedBlob
        """
        if self._getDefaultWireEncodingChangeCount != self.getChangeCount():
            # The values have changed, so the default wire encoding is
            # invalidated.
            self._defaultWireEncoding = SignedBlob()
            self._defaultWireEncodingFormat = None
            self._getDefaultWireEncodingChangeCount = self.getChangeCount()

        return self._defaultWireEncoding

    def getDefaultWireEncodingFormat(self):
        """
        Get the WireFormat which is used by getDefaultWireEncoding().

        :return: The WireFormat, which is only meaningful if the
          getDefaultWireEncoding() is not isNull().
        :rtype: WireFormat
        """
        return self._defaultWireEncodingFormat

    def setLpPacket(self, lpPacket):
        """
        An internal library method to set the LpPacket for an incoming packet.
        The application should not call this.

        :param LpPacket lpPacket: The LpPacket. This does not make a copy.
        :return: This Interest so that you can chain calls to update values.
        :rtype: Interest
        :note: This is an experimental feature. This API may change in the future.
        """
        self._lpPacket = lpPacket
        # Don't update _changeCount since this doesn't affect the wire encoding.
        return self

    def getChangeCount(self):
        """
        Get the change count, which is incremented each time this object
        (or a child object) is changed.

        :return: The change count.
        :rtype: int
        """
        # Make sure each of the checkChanged is called.
        changed = self._name.checkChanged()
        changed = self._keyLocator.checkChanged() or changed
        changed = self._exclude.checkChanged() or changed
        changed = self._forwardingHint.checkChanged() or changed
        if changed:
            # A child object has changed, so update the change count.
            self._changeCount += 1

        return self._changeCount

    def _setDefaultWireEncoding(self, defaultWireEncoding,
                                defaultWireEncodingFormat):
        self._defaultWireEncoding = defaultWireEncoding
        self._defaultWireEncodingFormat = defaultWireEncodingFormat
        # Set _getDefaultWireEncodingChangeCount so that the next call to
        # getDefaultWireEncoding() won't clear _defaultWireEncoding.
        self._getDefaultWireEncodingChangeCount = self.getChangeCount()

    _systemRandom = SystemRandom()

    # Create managed properties for read/write properties of the class for more pythonic syntax.
    name = property(getName, setName)
    minSuffixComponents = property(getMinSuffixComponents,
                                   setMinSuffixComponents)
    maxSuffixComponents = property(getMaxSuffixComponents,
                                   setMaxSuffixComponents)
    keyLocator = property(getKeyLocator, setKeyLocator)
    exclude = property(getExclude, setExclude)
    childSelector = property(getChildSelector, setChildSelector)
    mustBeFresh = property(getMustBeFresh, setMustBeFresh)
    nonce = property(getNonce, setNonce)
    interestLifetimeMilliseconds = property(getInterestLifetimeMilliseconds,
                                            setInterestLifetimeMilliseconds)
예제 #41
0
class ObjectId(object):
    """A MongoDB ObjectId.
    """

    _pid = os.getpid()

    _inc = SystemRandom().randint(0, _MAX_COUNTER_VALUE)
    _inc_lock = threading.Lock()

    __random = _random_bytes()

    __slots__ = ('__id', )

    _type_marker = 7

    def __init__(self, oid=None):
        """Initialize a new ObjectId.

        An ObjectId is a 12-byte unique identifier consisting of:

          - a 4-byte value representing the seconds since the Unix epoch,
          - a 5-byte random value,
          - a 3-byte counter, starting with a random value.

        By default, ``ObjectId()`` creates a new unique identifier. The
        optional parameter `oid` can be an :class:`ObjectId`, or any 12
        :class:`bytes` or, in Python 2, any 12-character :class:`str`.

        For example, the 12 bytes b'foo-bar-quux' do not follow the ObjectId
        specification but they are acceptable input::

          >>> ObjectId(b'foo-bar-quux')
          ObjectId('666f6f2d6261722d71757578')

        `oid` can also be a :class:`unicode` or :class:`str` of 24 hex digits::

          >>> ObjectId('0123456789ab0123456789ab')
          ObjectId('0123456789ab0123456789ab')
          >>>
          >>> # A u-prefixed unicode literal:
          >>> ObjectId(u'0123456789ab0123456789ab')
          ObjectId('0123456789ab0123456789ab')

        Raises :class:`~bson.errors.InvalidId` if `oid` is not 12 bytes nor
        24 hex digits, or :class:`TypeError` if `oid` is not an accepted type.

        :Parameters:
          - `oid` (optional): a valid ObjectId.

        .. mongodoc:: objectids

        .. versionchanged:: 3.8
           :class:`~bson.objectid.ObjectId` now implements the `ObjectID
           specification version 0.2
           <https://github.com/mongodb/specifications/blob/master/source/
           objectid.rst>`_.
        """
        if oid is None:
            self.__generate()
        elif isinstance(oid, bytes) and len(oid) == 12:
            self.__id = oid
        else:
            self.__validate(oid)

    @classmethod
    def from_datetime(cls, generation_time):
        """Create a dummy ObjectId instance with a specific generation time.

        This method is useful for doing range queries on a field
        containing :class:`ObjectId` instances.

        .. warning::
           It is not safe to insert a document containing an ObjectId
           generated using this method. This method deliberately
           eliminates the uniqueness guarantee that ObjectIds
           generally provide. ObjectIds generated with this method
           should be used exclusively in queries.

        `generation_time` will be converted to UTC. Naive datetime
        instances will be treated as though they already contain UTC.

        An example using this helper to get documents where ``"_id"``
        was generated before January 1, 2010 would be:

        >>> gen_time = datetime.datetime(2010, 1, 1)
        >>> dummy_id = ObjectId.from_datetime(gen_time)
        >>> result = collection.find({"_id": {"$lt": dummy_id}})

        :Parameters:
          - `generation_time`: :class:`~datetime.datetime` to be used
            as the generation time for the resulting ObjectId.
        """
        if generation_time.utcoffset() is not None:
            generation_time = generation_time - generation_time.utcoffset()
        timestamp = calendar.timegm(generation_time.timetuple())
        oid = struct.pack(">I",
                          int(timestamp)) + b"\x00\x00\x00\x00\x00\x00\x00\x00"
        return cls(oid)

    @classmethod
    def is_valid(cls, oid):
        """Checks if a `oid` string is valid or not.

        :Parameters:
          - `oid`: the object id to validate

        .. versionadded:: 2.3
        """
        if not oid:
            return False

        try:
            ObjectId(oid)
            return True
        except (InvalidId, TypeError):
            return False

    @classmethod
    def _random(cls):
        """Generate a 5-byte random number once per process.
        """
        pid = os.getpid()
        if pid != cls._pid:
            cls._pid = pid
            cls.__random = _random_bytes()
        return cls.__random

    def __generate(self):
        """Generate a new value for this ObjectId.
        """

        # 4 bytes current time
        oid = struct.pack(">I", int(time.time()))

        # 5 bytes random
        oid += ObjectId._random()

        # 3 bytes inc
        with ObjectId._inc_lock:
            oid += struct.pack(">I", ObjectId._inc)[1:4]
            ObjectId._inc = (ObjectId._inc + 1) % (_MAX_COUNTER_VALUE + 1)

        self.__id = oid

    def __validate(self, oid):
        """Validate and use the given id for this ObjectId.

        Raises TypeError if id is not an instance of
        (:class:`basestring` (:class:`str` or :class:`bytes`
        in python 3), ObjectId) and InvalidId if it is not a
        valid ObjectId.

        :Parameters:
          - `oid`: a valid ObjectId
        """
        if isinstance(oid, ObjectId):
            self.__id = oid.binary
        # bytes or unicode in python 2, str in python 3
        elif isinstance(oid, string_type):
            if len(oid) == 24:
                try:
                    self.__id = bytes_from_hex(oid)
                except (TypeError, ValueError):
                    _raise_invalid_id(oid)
            else:
                _raise_invalid_id(oid)
        else:
            raise TypeError("id must be an instance of (bytes, %s, ObjectId), "
                            "not %s" % (text_type.__name__, type(oid)))

    @property
    def binary(self):
        """12-byte binary representation of this ObjectId.
        """
        return self.__id

    @property
    def generation_time(self):
        """A :class:`datetime.datetime` instance representing the time of
        generation for this :class:`ObjectId`.

        The :class:`datetime.datetime` is timezone aware, and
        represents the generation time in UTC. It is precise to the
        second.
        """
        timestamp = struct.unpack(">I", self.__id[0:4])[0]
        return datetime.datetime.fromtimestamp(timestamp, utc)

    def __getstate__(self):
        """return value of object for pickling.
        needed explicitly because __slots__() defined.
        """
        return self.__id

    def __setstate__(self, value):
        """explicit state set from pickling
        """
        # Provide backwards compatability with OIDs
        # pickled with pymongo-1.9 or older.
        if isinstance(value, dict):
            oid = value["_ObjectId__id"]
        else:
            oid = value
        # ObjectIds pickled in python 2.x used `str` for __id.
        # In python 3.x this has to be converted to `bytes`
        # by encoding latin-1.
        if PY3 and isinstance(oid, text_type):
            self.__id = oid.encode('latin-1')
        else:
            self.__id = oid

    def __str__(self):
        if PY3:
            return binascii.hexlify(self.__id).decode()
        return binascii.hexlify(self.__id)

    def __repr__(self):
        return "ObjectId('%s')" % (str(self), )

    def __eq__(self, other):
        if isinstance(other, ObjectId):
            return self.__id == other.binary
        return NotImplemented

    def __ne__(self, other):
        if isinstance(other, ObjectId):
            return self.__id != other.binary
        return NotImplemented

    def __lt__(self, other):
        if isinstance(other, ObjectId):
            return self.__id < other.binary
        return NotImplemented

    def __le__(self, other):
        if isinstance(other, ObjectId):
            return self.__id <= other.binary
        return NotImplemented

    def __gt__(self, other):
        if isinstance(other, ObjectId):
            return self.__id > other.binary
        return NotImplemented

    def __ge__(self, other):
        if isinstance(other, ObjectId):
            return self.__id >= other.binary
        return NotImplemented

    def __hash__(self):
        """Get a hash value for this :class:`ObjectId`."""
        return hash(self.__id)
예제 #42
0
    SUPPORT_SEEK,
    SUPPORT_SELECT_SOUND_MODE,
    SUPPORT_SELECT_SOURCE,
    SUPPORT_SHUFFLE_SET,
    SUPPORT_STOP,
    SUPPORT_TURN_OFF,
    SUPPORT_TURN_ON,
    SUPPORT_VOLUME_MUTE,
    SUPPORT_VOLUME_SET,
    SUPPORT_VOLUME_STEP,
)

# mypy: allow-untyped-defs, no-check-untyped-defs

_LOGGER = logging.getLogger(__name__)
_RND = SystemRandom()

ENTITY_ID_FORMAT = DOMAIN + ".{}"

ENTITY_IMAGE_URL = "/api/media_player_proxy/{0}?token={1}&cache={2}"
CACHE_IMAGES = "images"
CACHE_MAXSIZE = "maxsize"
CACHE_LOCK = "lock"
CACHE_URL = "url"
CACHE_CONTENT = "content"
ENTITY_IMAGE_CACHE = {
    CACHE_IMAGES: collections.OrderedDict(),
    CACHE_MAXSIZE: 16
}

SCAN_INTERVAL = timedelta(seconds=10)
예제 #43
0
def _random_bytes():
    """Get the 5-byte random field of an ObjectId."""
    return struct.pack(">Q", SystemRandom().randint(0, 0xFFFFFFFFFF))[3:]
import hashlib
import sys
import os
from random import SystemRandom
import base64
import hmac

if len(sys.argv) < 2:
    sys.stderr.write('Please include username as an argument.\n')
    sys.exit(0)

username = sys.argv[1]

#This uses os.urandom() underneath
cryptogen = SystemRandom()

#Create 16 byte hex salt
salt_sequence = [cryptogen.randrange(256) for i in range(16)]
hexseq = list(map(hex, salt_sequence))
salt = "".join([x[2:] for x in hexseq])

#Create 32 byte b64 password
password = base64.urlsafe_b64encode(os.urandom(32))

digestmod = hashlib.sha256

if sys.version_info.major >= 3:
    password = password.decode('utf-8')
    digestmod = 'SHA256'
예제 #45
0
""" Welborn Productions - Utilities - ID Tools
    Tools that any model can use to generate unique ids.
    These are not safe-guarded ids.
    -Christopher Welborn 2-2-15
"""
from random import SystemRandom

SYSRANDOM = SystemRandom()
# Changing the start char will wreck previously encoded ids.
IDSTARTCHAR = 'a'
# IDPADCHARS cannot contain IDSTARTCHAR + 9 letters (a -> j, when 'a' is used)
IDPADCHARS = 'lmnopqrstuvwxyz'


def encode_id(realid, length=4):
    """ A form of encoding that is reversible.
        Ensures an id at least `length` + `length // 2` characters long.
        Example:
            encode_id(123, length=4)
            'btycydx'

        Arguments:
            realid           : Int or digit string to encode.
            length           : Max length for the actual id.
                               Automatically bumped up to len(str(realid))
                               when needed.
    """
    realidstr = str(realid)
    if not realidstr.isdigit():
        raise ValueError(
            'Expecting a number, or str of digits. Got: ({}) {!r}'.format(
예제 #46
0
import os
from random import SystemRandom
import ntpath
import PySimpleGUI as sg
from PIL import Image, ImageDraw

_random = SystemRandom()


def merge_images(img1, img2, output_path=os.getcwd()):
    img_A = Image.open(img1)
    img_B = Image.open(img2)
    head, tail = ntpath.split("Merge_res.png")
    file_name_AB = tail or ntpath.basename(head)
    img_A.paste(img_B, (0, 0), img_B)
    img_A.save(output_path + '\\' + file_name_AB, 'PNG')

    sg.popup('Done!')


def visual_crypto(file_path, output_path=os.getcwd()):
    img = Image.open(file_path)
    f, e = os.path.splitext(file_path)

    out_filename_A = f + "_A.png"
    out_filename_B = f + "_B.png"
    out_filename_AB = f + "_AB_res.png"

    img = img.convert('1')  # convert image to 1 bit

    # Prepare two empty slider images for drawing
 def so_random(self, x, y):
     return SystemRandom().randint(x, y)
예제 #48
0
    ON_OFF = 1
    STREAM = 2


# These SUPPORT_* constants are deprecated as of Home Assistant 2022.5.
# Pleease use the CameraEntityFeature enum instead.
SUPPORT_ON_OFF: Final = 1
SUPPORT_STREAM: Final = 2

RTSP_PREFIXES = {"rtsp://", "rtsps://"}

DEFAULT_CONTENT_TYPE: Final = "image/jpeg"
ENTITY_IMAGE_URL: Final = "/api/camera_proxy/{0}?token={1}"

TOKEN_CHANGE_INTERVAL: Final = timedelta(minutes=5)
_RND: Final = SystemRandom()

MIN_STREAM_INTERVAL: Final = 0.5  # seconds

CAMERA_SERVICE_SNAPSHOT: Final = {vol.Required(ATTR_FILENAME): cv.template}

CAMERA_SERVICE_PLAY_STREAM: Final = {
    vol.Required(ATTR_MEDIA_PLAYER): cv.entities_domain(DOMAIN_MP),
    vol.Optional(ATTR_FORMAT, default="hls"): vol.In(OUTPUT_FORMATS),
}

CAMERA_SERVICE_RECORD: Final = {
    vol.Required(CONF_FILENAME): cv.template,
    vol.Optional(CONF_DURATION, default=30): vol.Coerce(int),
    vol.Optional(CONF_LOOKBACK, default=0): vol.Coerce(int),
}
            to_output = motion.reshape(-1, FLAGS.frame_size)
        else:
            to_output = motion

        np.savetxt(fp, to_output, delimiter=",")
        print("Motion was written to " + file_name)

if __name__ == '__main__':

    torch.manual_seed(args.random_seed)
    np.random.seed(args.random_seed)

    experimentID = args.load
    if experimentID is None:
        # Make a new experiment ID
	experimentID = int(SystemRandom().random()*100000)
    ckpt_path = os.path.join(args.save, "experiment_" + str(experimentID) + '.ckpt')

    start = time.time()
    print("Sampling dataset of {} training examples".format(args.n))
	
    input_command = sys.argv
    ind = [i for i in range(len(input_command)) if input_command[i] == "--load"]
    if len(ind) == 1:
        ind = ind[0]
	input_command = input_command[:ind] + input_command[(ind+2):]
    input_command = " ".join(input_command)

    utils.makedirs("results/")

    ##################################################################
예제 #50
0
파일: main.py 프로젝트: ioerror/sibc
def bsidh_main(ctx):
    algo = ctx.meta['sidh.kwargs']['algo']
    setting = ctx.meta['sidh.kwargs']
    curve = algo.curve
    tuned_name = ('-classical', '-suitable')[setting.tuned]
    SIDp = algo.curve.SIDp
    SIDm = algo.curve.SIDm
    SQR, ADD = algo.curve.SQR, algo.curve.ADD
    p = algo.params.p
    global_L = algo.curve.L
    coeff = curve.coeff
    random = SystemRandom()
    fp = curve.fp

    f_name = 'data/strategies/' + setting.algorithm + '-' + setting.prime + '-' + algo.formula.name + tuned_name
    try:
        f = open(resource_filename('sidh', f_name))
        print("// Strategies to be read from a file")
        # Corresponding to the list of Small Isogeny Degree, Lp := [l_0, ...,
        # l_{n-1}] [We need to include case l=2 and l=4]
        tmp = f.readline()
        tmp = [int(b) for b in tmp.split()]
        Sp = list(tmp)
        # Corresponding to the list of Small Isogeny Degree, Lm := [l_0, ..., l_{n-1}]
        tmp = f.readline()
        tmp = [int(b) for b in tmp.split()]
        Sm = list(tmp)
        f.close()
    except IOError:
        print("// Strategies to be computed")
        # List of Small Isogeny Degree, Lp := [l_0, ..., l_{n-1}] [We need to
        # include case l=2 and l=4]
        Sp, Cp = dynamic_programming_algorithm(SIDp[::-1], len(SIDp))
        # List of Small Isogeny Degree, Lm := [l_0, ..., l_{n-1}]
        Sm, Cm = dynamic_programming_algorithm(SIDm[::-1], len(SIDm))
        f = open(f_name, 'w')
        f.writelines(' '.join([str(tmp) for tmp in Sp]) + '\n')
        f.writelines(' '.join([str(tmp) for tmp in Sm]) + '\n')
        f.close()
    print(
        "// All the experiments are assuming S = %1.6f x M and a = %1.6f x M. The curve.measures are given in millions of field operations.\n"
        % (SQR, ADD))

    print("p := 0x%X;" % p)
    print("fp := GF(p);")
    print("_<x> := PolynomialRing(fp);")
    print("fp2<i> := ext<fp | x^2 + 1>;")
    print("Pr<x> := PolynomialRing(fp2);")

    # Reading public generators points
    f = open(resource_filename('sidh', 'data/gen/' + setting.prime))

    # x(PA), x(QA) and x(PA - QA)
    PQA = f.readline()
    PQA = [int(x, 16) for x in PQA.split()]
    PA = [list(PQA[0:2]), [0x1, 0x0]]
    QA = [list(PQA[2:4]), [0x1, 0x0]]
    PQA = [list(PQA[4:6]), [0x1, 0x0]]

    # x(PB), x(QB) and x(PB - QB)
    PQB = f.readline()
    PQB = [int(x, 16) for x in PQB.split()]
    PB = [list(PQB[0:2]), [0x1, 0x0]]
    QB = [list(PQB[2:4]), [0x1, 0x0]]
    PQB = [list(PQB[4:6]), [0x1, 0x0]]

    f.close()

    A = [[0x8, 0x0], [0x4, 0x0]]
    a = coeff(A)

    print("public_coeff := 0x%X + i * 0x%X;\n" % (a[0], a[1]))

    print(
        "// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------"
    )
    print("// Public Key Generation")
    print(
        "// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
    )

    # Alice's side
    print("// Private key corresponding to Alice")
    a_private = algo.gae.random_key(p + 1)
    fp.fp.set_zero_ops()
    Ra = curve.Ladder3pt(a_private, PA, QA, PQA, A)
    print("// sk_a := 0x%X;" % a_private)
    RUNNING_TIME = fp.fp.get_ops()
    print(
        "// kernel point generator cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;\n"
        % (
            RUNNING_TIME[0] / (10.0**6),
            RUNNING_TIME[1] / (10.0**6),
            RUNNING_TIME[2] / (10.0**6),
            curve.measure(RUNNING_TIME) / (10.0**6),
        ))
    print("// Public key corresponding to Alice")
    fp.fp.set_zero_ops()
    a_public, PB_a, QB_a, PQB_a = algo.gae.evaluate_strategy(
        True, PB, QB, PQB, A, Ra, SIDp[::-1], Sp, len(SIDp))
    RUNNING_TIME = fp.fp.get_ops()
    print("// isogeny evaluation cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;" % (
        RUNNING_TIME[0] / (10.0**6),
        RUNNING_TIME[1] / (10.0**6),
        RUNNING_TIME[2] / (10.0**6),
        curve.measure(RUNNING_TIME) / (10.0**6),
    ))

    a_curve = coeff(a_public)
    print("pk_a := 0x%X + i * 0x%X;\n" % (a_curve[0], a_curve[1]))
    # print("B := EllipticCurve(x^3 + (0x%X + i * 0x%X )* x^2 + x);" % (a_curve[0], a_curve[1]) )
    # print("assert(Random(B) * (p + 1) eq B!0);")

    print("// Private key corresponding to Bob")
    b_private = algo.gae.random_key(p - 1)
    print("// sk_b := 0x%X;" % b_private)
    fp.fp.set_zero_ops()
    Rb = curve.Ladder3pt(b_private, PB, QB, PQB, A)
    RUNNING_TIME = fp.fp.get_ops()
    print(
        "// kernel point generator cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;\n"
        % (
            RUNNING_TIME[0] / (10.0**6),
            RUNNING_TIME[1] / (10.0**6),
            RUNNING_TIME[2] / (10.0**6),
            curve.measure(RUNNING_TIME) / (10.0**6),
        ))
    print("// Public key corresponding to Bob")
    fp.fp.set_zero_ops()
    b_public, PA_b, QA_b, PQA_b = algo.gae.evaluate_strategy(
        True, PA, QA, PQA, A, Rb, SIDm[::-1], Sm, len(SIDm))
    RUNNING_TIME = fp.fp.get_ops()
    print("// isogeny evaluation cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;" % (
        RUNNING_TIME[0] / (10.0**6),
        RUNNING_TIME[1] / (10.0**6),
        RUNNING_TIME[2] / (10.0**6),
        curve.measure(RUNNING_TIME) / (10.0**6),
    ))

    b_curve = coeff(b_public)
    print("pk_b := 0x%X + i * 0x%X;\n" % (b_curve[0], b_curve[1]))
    # print("B := EllipticCurve(x^3 + (0x%X + i * 0x%X )* x^2 + x);" % (b_curve[0], b_curve[1]) )
    # print("assert(Random(B) * (p + 1) eq B!0);")

    # ======================================================
    print(
        "\n// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------"
    )
    print("// Secret Sharing Computation")
    print(
        "// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
    )

    print("// Secret sharing corresponding to Alice")
    fp.fp.set_zero_ops()
    RB_a = curve.Ladder3pt(a_private, PA_b, QA_b, PQA_b, b_public)
    RUNNING_TIME = fp.fp.get_ops()
    print(
        "// kernel point generator cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;" %
        (
            RUNNING_TIME[0] / (10.0**6),
            RUNNING_TIME[1] / (10.0**6),
            RUNNING_TIME[2] / (10.0**6),
            curve.measure(RUNNING_TIME) / (10.0**6),
        ))
    fp.fp.set_zero_ops()
    ss_a, _, _, _ = algo.gae.evaluate_strategy(False, PB, QB, PQB, b_public,
                                               RB_a, SIDp[::-1], Sp, len(SIDp))
    RUNNING_TIME = fp.fp.get_ops()
    print("// isogeny evaluation cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;" % (
        RUNNING_TIME[0] / (10.0**6),
        RUNNING_TIME[1] / (10.0**6),
        RUNNING_TIME[2] / (10.0**6),
        curve.measure(RUNNING_TIME) / (10.0**6),
    ))

    ss_a_curve = coeff(ss_a)
    print("ss_a := 0x%X + i * 0x%X;\n" % (ss_a_curve[0], ss_a_curve[1]))
    # ss_ja = jinvariant(ss_a)
    # print("B := EllipticCurve(x^3 + (0x%X + i * 0x%X )* x^2 + x);" % (ss_a_curve[0], ss_a_curve[1]) )
    # print("jB := 0x%X + i * 0x%X;" % (ss_ja[0], ss_ja[1]) )
    # print("assert(Random(B) * (p + 1) eq B!0);")
    # print("assert(jInvariant(B) eq jB);")

    print("// Secret sharing corresponding to Bob")
    fp.fp.set_zero_ops()
    RA_b = curve.Ladder3pt(b_private, PB_a, QB_a, PQB_a, a_public)
    RUNNING_TIME = fp.fp.get_ops()
    print(
        "// kernel point generator cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;" %
        (
            RUNNING_TIME[0] / (10.0**6),
            RUNNING_TIME[1] / (10.0**6),
            RUNNING_TIME[2] / (10.0**6),
            curve.measure(RUNNING_TIME) / (10.0**6),
        ))
    fp.fp.set_zero_ops()
    ss_b, _, _, _ = algo.gae.evaluate_strategy(False, PA, QA, PQA, a_public,
                                               RA_b, SIDm[::-1], Sm, len(SIDm))
    RUNNING_TIME = fp.fp.get_ops()
    print("// isogeny evaluation cost:\t%2.3fM + %2.3fS + %2.3fa = %2.3fM;" % (
        RUNNING_TIME[0] / (10.0**6),
        RUNNING_TIME[1] / (10.0**6),
        RUNNING_TIME[2] / (10.0**6),
        curve.measure(RUNNING_TIME) / (10.0**6),
    ))

    ss_b_curve = coeff(ss_b)
    print("ss_b := 0x%X + i * 0x%X;\n" % (ss_b_curve[0], ss_b_curve[1]))
    # ss_jb = jinvariant(ss_b)
    # print("B := EllipticCurve(x^3 + (0x%X + i * 0x%X )* x^2 + x);" % (ss_b_curve[0], ss_b_curve[1]) )
    # print("jB := 0x%X + i * 0x%X;" % (ss_jb[0], ss_jb[1]) )
    # print("assert(Random(B) * (p + 1) eq B!0);")
    # print("assert(jInvariant(B) eq jB);")

    print(
        "\n// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------"
    )
    if ss_a_curve == ss_b_curve:
        print('\x1b[0;30;43m' + '\"Successfully passed!\";' + '\x1b[0m')
    else:
        print('\x1b[0;30;41m' +
              '\"Great Scott!... The sky is falling. NOT PASSED!!!\"' +
              '\x1b[0m')
    return attrdict(name='bsidh-main', **locals())
예제 #51
0
    def _prepare_eletronic_doc_vals(self):
        invoice = self
        num_controle = int(''.join(
            [str(SystemRandom().randrange(9)) for i in range(8)]))
        numero_nfe = numero_rps = 0
        if self.company_id.l10n_br_nfe_sequence:
            numero_nfe = self.company_id.l10n_br_nfe_sequence.next_by_id()
        if self.company_id.l10n_br_nfe_service_sequence:
            numero_rps = self.company_id.l10n_br_nfe_service_sequence.next_by_id(
            )
        vals = {
            'name': invoice.name,
            'move_id': invoice.id,
            'company_id': invoice.company_id.id,
            'schedule_user_id': self.env.user.id,
            'state': 'draft',
            'tipo_operacao': TYPE2EDOC[invoice.type],
            'numero_controle': num_controle,
            'data_emissao': datetime.now(),
            'data_agendada': invoice.invoice_date,
            'finalidade_emissao': '1',
            'ambiente': invoice.company_id.l10n_br_tipo_ambiente,
            'partner_id': invoice.partner_id.id,
            'payment_term_id': invoice.invoice_payment_term_id.id,
            'fiscal_position_id': invoice.fiscal_position_id.id,
            'natureza_operacao': invoice.fiscal_position_id.name,
            'ind_pres': invoice.fiscal_position_id.ind_pres,
            'finalidade_emissao':
            invoice.fiscal_position_id.finalidade_emissao,
            # 'valor_icms': invoice.icms_value,
            # 'valor_icmsst': invoice.icms_st_value,
            # 'valor_ipi': invoice.ipi_value,
            # 'valor_pis': invoice.pis_value,
            # 'valor_cofins': invoice.cofins_value,
            # 'valor_ii': invoice.ii_value,
            'valor_bruto': invoice.amount_total,
            # 'valor_desconto': invoice.total_desconto,
            'valor_final': invoice.amount_total,
            # 'valor_bc_icms': invoice.icms_base,
            # 'valor_bc_icmsst': invoice.icms_st_base,
            # 'valor_estimado_tributos': invoice.total_tributos_estimados,
            # 'valor_retencao_pis': invoice.pis_retention,
            # 'valor_retencao_cofins': invoice.cofins_retention,
            # 'valor_bc_irrf': invoice.irrf_base,
            # 'valor_retencao_irrf': invoice.irrf_retention,
            # 'valor_bc_csll': invoice.csll_base,
            # 'valor_retencao_csll': invoice.csll_retention,
            # 'valor_bc_inss': invoice.inss_base,
            # 'valor_retencao_inss': invoice.inss_retention,
            'informacoes_complementares': invoice.narration,
            'numero_fatura': invoice.name,
            'fatura_bruto': invoice.amount_total,
            'fatura_desconto': 0.0,
            'fatura_liquido': invoice.amount_total,
            'pedido_compra': invoice.invoice_payment_ref,
            'serie_documento': invoice.fiscal_position_id.serie_nota_fiscal,
            'numero': numero_nfe,
            'numero_rps': numero_rps,
        }
        vals[
            'cod_regime_tributario'] = '1' if invoice.company_id.l10n_br_tax_regime == 'simples' else '3'
        # Indicador Consumidor Final
        if invoice.commercial_partner_id.is_company:
            vals['ind_final'] = '0'
        else:
            vals['ind_final'] = '1'
        vals['ind_dest'] = '1'
        if invoice.company_id.state_id != invoice.commercial_partner_id.state_id:
            vals['ind_dest'] = '2'
        if invoice.company_id.country_id != invoice.commercial_partner_id.country_id:
            vals['ind_dest'] = '3'
        if invoice.fiscal_position_id.ind_final:
            vals['ind_final'] = invoice.fiscal_position_id.ind_final

        # Indicador IE Destinatário
        ind_ie_dest = False
        if invoice.commercial_partner_id.is_company:
            if invoice.commercial_partner_id.l10n_br_inscr_est:
                ind_ie_dest = '1'
            elif invoice.commercial_partner_id.state_id.code in ('AM', 'BA',
                                                                 'CE', 'GO',
                                                                 'MG', 'MS',
                                                                 'MT', 'PE',
                                                                 'RN', 'SP'):
                ind_ie_dest = '9'
            elif invoice.commercial_partner_id.country_id.code != 'BR':
                ind_ie_dest = '9'
            else:
                ind_ie_dest = '2'
        else:
            ind_ie_dest = '9'
        if invoice.commercial_partner_id.l10n_br_indicador_ie_dest:
            ind_ie_dest = invoice.commercial_partner_id.l10n_br_indicador_ie_dest
        vals['ind_ie_dest'] = ind_ie_dest
        iest_id = invoice.company_id.l10n_br_iest_ids.filtered(
            lambda x: x.state_id == invoice.commercial_partner_id.state_id)
        if iest_id:
            vals['iest'] = iest_id.name

        total_produtos = total_servicos = 0.0
        for inv_line in self.invoice_line_ids:
            if inv_line.product_id.type == 'service':
                total_servicos += inv_line.price_subtotal
            else:
                total_produtos += inv_line.price_subtotal

        vals.update({
            'valor_servicos': total_servicos,
            'valor_produtos': total_produtos,
        })
        return vals
예제 #52
0
    def test_check_valid_path(self):
        # success case: input the valid path
        path = [
            self.connector_token_list[0], self.flexible_token_address_list[0],
            self.connector_token_list[1]
        ]
        self.network_score._require_valid_path(path)

        # failure case: input path whose length under 3
        invalid_path = [
            self.connector_token_list[0], self.flexible_token_address_list[0]
        ]
        self.assertRaises(RevertException,
                          self.network_score._require_valid_path, invalid_path)

        # failure case: input path whose length is more than 21
        random = SystemRandom()
        # use random data to avoid same address is made
        invalid_path = [
            Address.from_string("cx" + str(random.randrange(10)) +
                                str(random.randrange(10)) * 39)
            in range(0, 22)
        ]
        self.assertRaises(RevertException,
                          self.network_score._require_valid_path, invalid_path)

        # failure case: input path whose length is even
        invalid_path = [
            self.connector_token_list[0], self.flexible_token_address_list[0],
            self.connector_token_list[1], self.flexible_token_address_list[1]
        ]
        self.assertRaises(RevertException,
                          self.network_score._require_valid_path, invalid_path)

        # failure case: input path which has the same flexible token address in it
        invalid_path = [
            self.connector_token_list[0], self.flexible_token_address_list[0],
            self.connector_token_list[1], self.flexible_token_address_list[0],
            self.connector_token_list[1]
        ]
        self.assertRaises(RevertException,
                          self.network_score._require_valid_path, invalid_path)

        # success case: input path which has the same flexible token address in the 'from' or 'to' position in it
        # path: [connector0 - flexible token0 - flexible token1 - flexible token2, flexible token0]
        path = [
            self.connector_token_list[0], self.flexible_token_address_list[0],
            self.flexible_token_address_list[1],
            self.flexible_token_address_list[2],
            self.flexible_token_address_list[0]
        ]
        self.network_score._require_valid_path(path)

        # success case: input path which has the same flexible tokens that only exist in 'from' or 'to' in it
        path = [
            self.flexible_token_address_list[0],
            self.flexible_token_address_list[1], self.connector_token_list[0],
            self.flexible_token_address_list[2],
            self.flexible_token_address_list[0]
        ]
        self.network_score._require_valid_path(path)
예제 #53
0
 def make_password(length):
     generator = SystemRandom()
     chars = string.ascii_letters + string.digits + '!@#$%^&*()'
     return ''.join(generator.choice(chars) for i in range(length))
예제 #54
0
 def gen_access_key(self):
     rs = Rstr(SystemRandom())
     self.access_key = rs.xeger(r'[A-Z]\d[A-Z]-\d[A-Z]\d')
     return self.access_key
예제 #55
0
파일: utils.py 프로젝트: BeryJu/supervisr
def generate_secret_key(ctx):
    """Generate Django SECRET_KEY"""
    charset = "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)"
    print(''.join([SystemRandom().choice(charset) for i in range(50)]))
예제 #56
0
    def _prepare_edoc_vals(self, invoice, inv_lines, serie_id):
        num_controle = int(''.join([str(SystemRandom().randrange(9))
                                    for i in range(8)]))
        vals = {
            'name': invoice.number,
            'invoice_id': invoice.id,
            'code': invoice.number,
            'company_id': invoice.company_id.id,
            'schedule_user_id': self.env.user.id,
            'state': 'draft',
            'tipo_operacao': TYPE2EDOC[invoice.type],
            'numero_controle': num_controle,
            'data_emissao': datetime.now(),
            'data_agendada': invoice.date_invoice,
            'data_fatura': datetime.now(),
            'finalidade_emissao': '1',
            'partner_id': invoice.partner_id.id,
            'payment_term_id': invoice.payment_term_id.id,
            'fiscal_position_id': invoice.fiscal_position_id.id,
            'valor_icms': invoice.icms_value,
            'valor_icmsst': invoice.icms_st_value,
            'valor_ipi': invoice.ipi_value,
            'valor_pis': invoice.pis_value,
            'valor_cofins': invoice.cofins_value,
            'valor_ii': invoice.ii_value,
            'valor_bruto': invoice.total_bruto,
            'valor_desconto': invoice.total_desconto,
            'valor_final': invoice.amount_total,
            'valor_bc_icms': invoice.icms_base,
            'valor_bc_icmsst': invoice.icms_st_base,
            'valor_servicos': invoice.issqn_base,
            'valor_bc_issqn': invoice.issqn_base,
            'valor_issqn': invoice.issqn_value,
            'valor_estimado_tributos': invoice.total_tributos_estimados,
            'valor_retencao_issqn': invoice.issqn_retention,
            'valor_retencao_pis': invoice.pis_retention,
            'valor_retencao_cofins': invoice.cofins_retention,
            'valor_bc_irrf': invoice.irrf_base,
            'valor_retencao_irrf': invoice.irrf_retention,
            'valor_bc_csll': invoice.csll_base,
            'valor_retencao_csll': invoice.csll_retention,
            'valor_bc_inss': invoice.inss_base,
            'valor_retencao_inss': invoice.inss_retention,
        }

        total_produtos = total_servicos = 0.0
        eletronic_items = []
        for inv_line in inv_lines:
            if inv_line.product_type == 'service':
                total_servicos += inv_line.valor_bruto
            else:
                total_produtos += inv_line.valor_bruto
            eletronic_items.append((0, 0,
                                    self._prepare_edoc_item_vals(inv_line)))

        vals.update({
            'eletronic_item_ids': eletronic_items,
            'valor_servicos': total_servicos,
            'valor_bruto': total_produtos,
        })
        return vals
예제 #57
0
from hashlib import md5
from random import SystemRandom

pw = "kpdCE8aSt2gaqKKcU"

r = SystemRandom()
pwlen = len(pw)
itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
salt = "".join(r.choice(itoa64) for i in range(8))

p = pw
pp = pw+pw
ps = pw+salt
psp = pw+salt+pw
sp = salt+pw
spp = salt+pw+pw

permutations = [
    (p , psp), (spp, pp), (spp, psp), (pp, ps ), (spp, pp), (spp, psp),
    (pp, psp), (sp , pp), (spp, psp), (pp, psp), (spp, p ), (spp, psp),
    (pp, psp), (spp, pp), (sp , psp), (pp, psp), (spp, pp), (spp, ps ),
    (pp, psp), (spp, pp), (spp, psp)
]

# Start digest "a"
da = md5(pw + "$1$" + salt)

# Create digest "b"
db = md5(psp).digest()

# Update digest "a" by repeating digest "b", providing "pwlen" bytes:
예제 #58
0
__all__ = ('Response', 'Twilio')

from string import ascii_letters, digits
from random import SystemRandom
from functools import wraps
from six.moves.urllib.parse import urlsplit, urlunsplit
from twilio.rest import Client
from twilio.request_validator import RequestValidator
from twilio.twiml import TwiML
from flask import Response as FlaskResponse
from flask import abort, current_app, make_response, request, url_for
from flask import _app_ctx_stack as stack
from itsdangerous import TimestampSigner


rand = SystemRandom()
letters_and_digits = ascii_letters + digits


class Response(FlaskResponse, TwiML):
    """
    A response class for constructing TwiML documents, providing all of
    the verbs that are available through :py:class:`twilio.twiml.Response`.
    See also https://www.twilio.com/docs/api/twiml.
    """

    def __init__(self, *args, **kwargs):
        TwiML.__init__(self)
        FlaskResponse.__init__(self, *args, **kwargs)

    @property
예제 #59
0
def random_ascii_string(length):
    random = SystemRandom()
    return ''.join([random.choice(UNICODE_ASCII_CHARACTERS) for x in xrange(length)])
예제 #60
0
def random_hash():
    return hashlib.sha1(str(SystemRandom().random())).hexdigest()