示例#1
0
def perform(request_list):
    body = {
        'clientid': 'TAOBAO',
        'verifycode':
        r'30ad8nUZXX/eWN4Gos29WKSxIYHC9yB/bdb8Dp+zCilxYFylv++PdFjSUi5MUYGA',
        'clienttype': 2
    }
    # TODO:AES code calculated
    assertion = request_list[2]
    req_url = request_list[0]
    req_body = body
    req_body.update(request_list[1])
    url_dic = form_dic(info_list, r'/info/')
    url_dic.update(form_dic(user_list, r'/user/'))
    url_dic.update(form_dic(trade_list, r'/trade/'))
    url_dic.update(form_dic(pay_list, r'/trade/'))
    if req_url not in url_dic:
        return False
    try:
        response = getresponse(geturl(url_dic[req_url] + req_url, req_body),
                               assertion)
        if isinstance(response, dict):
            response = response.items()
        try:
            update_dic_data(req_url, response)
        except WrongData:
            print "Update job fails while url is %r" % req_url
        if response != [] and req_url != 'cinemahallsections':
            print random.choice(response)
        if req_url == 'cinemahallsections':
            print response
        return True
    except UrlError:
        return False
示例#2
0
def generate_password(length, options=[]):
    """
    Generate a new password of given length using specified options.
    Options is a string array possibly containing containing ['Uppercase', 'Numbers', 'Symbols'].
    """
    lowercase = string.ascii_lowercase
    uppercase = string.ascii_uppercase
    numbers = string.digits
    symbols = '!@#$%^&*?'

    password = list()
    for i in range(length):
        password.append(random.choice(lowercase))

    if 'Uppercase' in options:
        num_to_replace = int(length/5) + 1
        for i in range(num_to_replace):
            replace_idx = random.randint(0, length-1)
            password[replace_idx] = random.choice(uppercase)

    if 'Numbers' in options:
        num_to_replace = int(length/5) + 1
        for i in range(num_to_replace):
            replace_idx = random.randint(0, length-1)
            password[replace_idx] = random.choice(numbers)

    if 'Symbols' in options:
        num_to_replace = int(length/6) + 1
        for i in range(num_to_replace):
            replace_idx = random.randint(0, length-1)
            password[replace_idx] = random.choice(symbols)

    return ''.join(password)
示例#3
0
def generate_request(**request_parameters):
    '''Generate a token provisioning request.'''
    default_model = 'MacBookPro%d,%d' % (random.randint(1, 12), random.randint(1, 4))
    default_request_parameters = {
        'timestamp':int(time.time()),
        'token_model':'VSST',
        'otp_algorithm':'HMAC-SHA1-TRUNC-6DIGITS',
        'shared_secret_delivery_method':'HTTPS',
        'manufacturer':'Apple Inc.',
        'serial':''.join(random.choice(string.digits + string.ascii_uppercase) for x in range(12)),
        'model':default_model,
        'app_handle':'iMac010200',
        'client_id_type':'BOARDID',
        'client_id':'Mac-' + ''.join(random.choice('0123456789ABCDEF') for x in range(16)),
        'dist_channel':'Symantec',
        'platform':'iMac',
        'os':default_model,
    }

    default_request_parameters.update(request_parameters)
    request_parameters = default_request_parameters

    data_before_hmac = u'%(timestamp)d%(timestamp)d%(client_id_type)s%(client_id)s%(dist_channel)s' % request_parameters
    request_parameters['data'] = base64.b64encode(
        hmac.new(
            HMAC_KEY,
            data_before_hmac.encode('utf-8'),
            hashlib.sha256
            ).digest()
        ).decode('utf-8')

    return REQUEST_TEMPLATE % request_parameters
示例#4
0
def crypt(SHELL, brutelen=7, alphanum=False):
    nums = '0123456789'
    alpha = 'abcdefghijklmnopqrstuvwxyz'
    if alphanum:
	keyspace = nums + alpha + alpha.upper()
    else:
	keyspace = nums
    BLOCK_SIZE = 16
    BRUTE_LENGTH = brutelen
    PADDING = '\x00'
    pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * PADDING
    EncodeAES = lambda c, s: base64.b64encode(c.encrypt(pad(s)))
    #DecodeAES = lambda c, e: c.decrypt(base64.b64decode(e)).rstrip(PADDING)
    decoded = ''
    secret = Random.new().read(BLOCK_SIZE-BRUTE_LENGTH)
    secret += ''.join(random.choice(keyspace) for i in range(BRUTE_LENGTH))
    #print secret
    IV = Random.new().read(16)
    checkstring = ''.join(random.choice(nums+alpha) for i in range(BLOCK_SIZE))
    cipher = AES.new(secret)
    encoded = EncodeAES(cipher, SHELL) 
    control = cipher.encrypt(checkstring)
    encoded += secret[:-BRUTE_LENGTH] + control + checkstring
    encoded = base64.b64encode(encoded)
    return encoded
示例#5
0
def carGen():
    global CAR_LIST, USER_TEL
    alpha = list(
        '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-~')
    CAR_TPYE = [
        'Porsche', 'Lamborghini', 'Maybach', '大众', 'bmw', 'Bentley',
        'Rolls-Royce', 'mercedes-benz'
    ]
    picture = ''.join(
        random.choice(alpha) for i in range(random.randint(3, 7)))
    isDetail = random.randint(0, 1)
    if isDetail:
        detailImage1 = ''.join(
            random.choice(alpha) for i in range(random.randint(3, 7)))

    car_type = random.choice(CAR_TPYE)
    owner_id = random.randint(1, len(USER_LIST))
    owner_tel = USER_TEL[owner_id - 1]
    price = random.randint(10000, 1000000000)
    transfer_time = 0
    isSold = False
    isAssess = False
    isCheck = False
    if isDetail:
        return 'INSERT INTO `CAR_TABLE` (`PICTURE`, `DETAIL_IMAGE1`, `CAR_TYPE`, `OWNER_ID`, `OWNER_TEL`, `PRICE`, `TRANSFER_TIME`, `IS_SOLD`, `IS_ASSESS`, `IS_CHECK`) VALUES (\'' + picture + '\', \'' + detailImage1 + '\', \'' + car_type + '\', ' + str(
            owner_id) + ', \'' + owner_tel + '\', ' + str(price) + ', ' + str(
                transfer_time) + ', ' + str(isSold) + ', ' + str(
                    isAssess) + ', ' + str(isCheck) + ');\n'
    else:
        return 'INSERT INTO `CAR_TABLE` (`PICTURE`, `CAR_TYPE`, `OWNER_ID`, `OWNER_TEL`, `PRICE`, `TRANSFER_TIME`, `IS_SOLD`, `IS_ASSESS`, `IS_CHECK`) VALUES (\'' + picture + '\', \'' + car_type + '\', ' + str(
            owner_id) + ', \'' + owner_tel + '\', ' + str(price) + ', ' + str(
                transfer_time) + ', ' + str(isSold) + ', ' + str(
                    isAssess) + ', ' + str(isCheck) + ');\n'
示例#6
0
def adminGen():
    global ADMIN_LIST
    alpha = list(
        '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-~')
    username_length = random.randint(3, 10)
    username = ''.join([random.choice(alpha) for i in range(username_length)])
    password = '******'
    salt = hex(random.getrandbits(160))[2:]
    password_hash = SHA256.new(
        (password + SALT_PREFIX + salt).encode('utf-8')).hexdigest()
    phone = '1' + ''.join([str(random.randint(0, 9)) for i in range(10)])
    hasId = random.randint(0, 1)
    identity_number = ''
    realname = ''
    email = ''.join(
        [random.choice(alpha)
         for i in range(random.randint(7, 15))]) + '@buaa.edu.cn'
    ADMIN_LIST.append(username)
    if hasId:
        identity_number = ''.join(
            [str(random.randint(0, 9))
             for i in range(17)]) + random.choice(list('0123456789X'))
        realname = ''.join([random.choice(alpha) for i in range(4)])
        identity_number = SHA256.new(
            identity_number.encode('utf-8')).hexdigest()
    data = username + password_hash + salt + phone + realname + identity_number
    mac = SHA256.new(data.encode('utf-8')).hexdigest()
    if hasId:
        return 'INSERT INTO `ADMIN_TABLE` (`NAME`, `PASSWORD`, `SALT`, `PHONE`, `IDENTITY_NUMBER`, `REAL_NAME`, `EMAIL`, `MAC`) VALUES (\'' + username + '\', \'' + password_hash + '\', \'' + salt + '\', \'' + phone + '\', \'' + identity_number + '\', \'' + realname + '\', \'' + email + '\', \'' + mac + '\');\n'
    else:
        return 'INSERT INTO `ADMIN_TABLE` (`NAME`, `PASSWORD`, `SALT`, `PHONE`, `EMAIL`, `MAC`) VALUES (\'' + username + '\', \'' + password_hash + '\', \'' + salt + '\', \'' + phone + '\', \'' + email + '\', \'' + mac + '\');\n'
示例#7
0
    def __init__(self):
        super(Xeger, self).__init__()
        self._cache = dict()
        self._categories = {
            "category_digit": lambda: self._alphabets['digits'],
            "category_not_digit": lambda: self._alphabets['nondigits'],
            "category_space": lambda: self._alphabets['whitespace'],
            "category_not_space": lambda: self._alphabets['nonwhitespace'],
            "category_word": lambda: self._alphabets['word'],
            "category_not_word": lambda: self._alphabets['nonword'],
                  }

        self._cases = {"literal": lambda x: unichr(x),
             "not_literal": lambda x: choice(
                                string.printable.replace(unichr(x), '')),
             "at": lambda x: '',
             "in": lambda x: self._handle_in(x),
             "any": lambda x: self.printable(1),
             "range": lambda x: [unichr(i) for i in xrange(x[0], x[1]+1)],
             "category": lambda x: self._categories[x](),
             'branch': lambda x: ''.join(self._handle_state(i) for
                                                            i in choice(x[1])),
             "subpattern": lambda x: self._handle_group(x),
             "assert": lambda x: ''.join(self._handle_state(i) for i in x[1]),
             "assert_not": lambda x: '',
             "groupref": lambda x: self._cache[x],
             'max_repeat': lambda x: self._handle_repeat(*x),
             'negate': lambda x: [False],
             }
示例#8
0
def generate_request(**request_parameters):
    '''Generate a token provisioning request.'''
    default_model = 'MacBookPro%d,%d' % (random.randint(1, 12), random.randint(1, 4))
    default_request_parameters = {
        'timestamp':int(time.time()),
        'token_model':'VSST',
        'otp_algorithm':'HMAC-SHA1-TRUNC-6DIGITS',
        'shared_secret_delivery_method':'HTTPS',
        'manufacturer':'Apple Inc.',
        'serial':''.join(random.choice(string.digits + string.ascii_uppercase) for x in range(12)),
        'model':default_model,
        'app_handle':'iMac010200',
        'client_id_type':'BOARDID',
        'client_id':'Mac-' + ''.join(random.choice('0123456789ABCDEF') for x in range(16)),
        'dist_channel':'Symantec',
        'platform':'iMac',
        'os':default_model,
    }

    default_request_parameters.update(request_parameters)
    request_parameters = default_request_parameters

    data_before_hmac = u'%(timestamp)d%(timestamp)d%(client_id_type)s%(client_id)s%(dist_channel)s' % request_parameters
    request_parameters['data'] = base64.b64encode(
        hmac.new(
            HMAC_KEY,
            data_before_hmac.encode('utf-8'),
            hashlib.sha256
            ).digest()
        ).decode('utf-8')

    return REQUEST_TEMPLATE % request_parameters
def generate_password(length=16, symbolgroups=DEFAULT_PASSWORD_SYMBOLS):
    """Generate a random password from the supplied symbol groups.

    At least one symbol from each group will be included. Unpredictable
    results if length is less than the number of symbol groups.

    Believed to be reasonably secure (with a reasonable password length!)

    """
    # NOTE(jerdfelt): Some password policies require at least one character
    # from each group of symbols, so start off with one random character
    # from each symbol group
    password = [random.choice(s) for s in symbolgroups]
    # If length < len(symbolgroups), the leading characters will only
    # be from the first length groups. Try our best to not be predictable
    # by shuffling and then truncating.
    random.shuffle(password)
    password = password[:length]
    length -= len(password)

    # then fill with random characters from all symbol groups
    symbols = ''.join(symbolgroups)
    password.extend([random.choice(symbols) for _i in range(length)])

    # finally shuffle to ensure first x characters aren't from a
    # predictable group
    random.shuffle(password)

    return ''.join(password)
    def setup(self, security):
        # Pick p, q primes such that p | q - 1, that is equvalent to
        # say that q = r*p + 1 for some r
        p = number.getPrime(security, Random.new().read)
        print("p = ",p)
        
        r = 1
        while True:
            q = r*p + 1
            if number.isPrime(q):
                print("q = ",q)
                break
            r += 1
        
        # Compute elements of G = {i^r mod q | i in Z_q*}
        G = [] 
        for i in range(1, q): # Z_q*
            G.append(i**r % q)

        G = list(set(G))
        print("Order of G = {i^r mod q | i in Z_q*} is " + str(len(G)) + " (must be equal to p).")
        
        # Since the order of G is prime, any element of G except 1 is a generator
        g = random.choice(list(filter(lambda e: e != 1, G)))
        print("g = ",g)
                
        h = random.choice(list(filter(lambda e: e != 1 and e != g, G)))
        print("h = ",h)
        
        # g and h are elements of G such that nobody knows math.log(h, g) (log of h base g)
           
        return q,g,h
示例#11
0
    def symmetricKey(self, bits):
        bits = int(bits)
        if bits == 128:
            key = bytes(''.join(random.choice(ascii_lowercase) for i in range(16)))

        if bits == 256:
            key = bytes(''.join(random.choice(ascii_lowercase) for i in range(32)))
            return key
示例#12
0
 def _handle_in(self, value):
     candidates = list(chain(*(self._handle_state(i) for
                                                  i in value)))
     if candidates[0] is False:
         candidates = set(string.printable).difference(candidates[1:])
         return choice(list(candidates))
     else:
         return choice(candidates)
示例#13
0
def random_plugin_gus():
    length = 10

    if TESTING:
        global global_debug_counter
        global_debug_counter += 1
        string_value = str(global_debug_counter)
        return u'p_'+(''.join(random.choice('0') for x in range(length - len(string_value))))+string_value
    else:
        return u'p_'+(''.join(random.choice('0123456789') for x in range(length)))
示例#14
0
def encryption_oracle(data):
    prepad = Random.get_random_bytes(random.choice(range(5, 11)))
    postpad = Random.get_random_bytes(random.choice(range(5, 11)))
    padded = pkcs7_pad(prepad + data + postpad)
    key = keygen()
    if random.choice(range(2)) == 0:
        iv = keygen()
        return cbc_encrypt(data, key, iv)
    else:
        return ecb_encrypt(data, key)
示例#15
0
def encryption_oracle(cleartext, key):
    choice = random.choice([AES_ECB_MODE, AES_CBC_MODE])
    if choice == AES_ECB_MODE:
        func = lambda x: aes_ecb_encrypt(x, key)
    else:
        IV = Random.new().read(16)
        func = lambda x: aes_cbc_encrypt(x, key, IV)
    return func(
        paddpkcs7(
            Random.new().read(random.choice(range(5, 11))) + cleartext +
            Random.new().read(random.choice(range(5, 11))), 16)), choice
示例#16
0
def random_submission_gus(testingmode=False):
    """
    this need to be not guessable because this secret auth the WB
    during the submission procedure.
    """
    length = 50

    if testingmode:
        return u's_'+(''.join(random.choice('A') for x in range(length)))
    else:
        return u's_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#17
0
文件: main.py 项目: jhperales/gumpswd
def generate_password(range=None, size=16):
    if not range:
        range = string.digits + string.ascii_letters + string.digits
    a = []
    while len(a) < size - 4:
        a.append(random.choice(range))
    while len(a) < size - 2:
        a.append(random.choice(r"+=-@#~,.[]()!%^*$"))
    random.shuffle(a)
    return random.choice(string.ascii_letters) + \
           ''.join(a) + \
           random.choice(string.ascii_letters)
示例#18
0
    def test_ch22(self):
        import time
        time.sleep(random.choice(range(1, 10)))

        time_now = int(time.time())
        orig_seed = time_now
        obj = MT19937(time_now)
        num = obj.extract_number()

        time.sleep(random.choice(range(1, 10)))

        i = break_mt19937_seeded_time(int(time.time()), num)
        self.assertEqual(i, orig_seed)
示例#19
0
def random_tip_gus():
    """
    need to be NOT guessable
    """
    length = 50

    if TESTING:
        global global_debug_counter
        global_debug_counter += 1
        string_value = str(global_debug_counter)
        return u't_'+(''.join(random.choice('0') for x in range(length - len(string_value))))+string_value
    else:
        return u't_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#20
0
def random_file_gus():
    """
    need to be random
    XXX file is now starting with f_ and is supposed to be random
    """
    length = 30

    if TESTING:
        global global_debug_counter
        global_debug_counter += 1
        string_value = str(global_debug_counter)
        return u'f_'+(''.join(random.choice('0') for x in range(length - len(string_value))))+string_value
    else:
        return u'f_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#21
0
def random_submission_gus():
    """
    this need to be not guessable because this secret auth the WB
    during the submission procedure.
    """
    length = 50

    if TESTING:
        global global_debug_counter
        global_debug_counter += 1
        string_value = str(global_debug_counter)
        return u's_'+(''.join(random.choice('0') for x in range(length - len(string_value))))+string_value
    else:
        return u's_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#22
0
def random_receiver_gus():
    """
    maybe guessable, because is an information available to the whistleblower, and
    then every time is used as input, need to be checked in coherence, in the context.
    anyway we made it not guessable, just to avoid enumeration.
    """
    length = 20

    if TESTING:
        global global_debug_counter
        global_debug_counter += 1
        string_value = str(global_debug_counter)
        return u'r_'+(''.join(random.choice('0') for x in range(length - len(string_value))))+string_value
    else:
        return u'r_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#23
0
def chooseAxes(numBits):
    """Return Alice and Bob's randomly chosen mstment axes for the specified
       number of qubits in the E91 protocol:
           A chooses from (0, pi/4, pi/2) with equal probability,
           B chooses from (pi/4, pi/2, 3pi/4) with equal probability.
    """
    choicesA = [0, pi / 8, pi / 4]
    choicesB = [0, pi / 8, -pi / 8]
    basesA = []
    basesB = []
    for j in range(numBits):
        basesA.append(random.choice(choicesA))
        basesB.append(random.choice(choicesB))

    return (basesA, basesB)
示例#24
0
 def generate_random_password(self, size=10 ):
     """
     Generates random password of given size
     it ensures -
     1 uppercase
     1 lowercase
     1 digit
     1 punc
     """
     P = [random.choice(s) for s in self.must_set]
     P.extend([random.choice(self.All) 
               for n in range(size-len(self.must_set))])
     n = random.randint(0, MAX_INT) 
     password = self.decode2string(n, P)
     return password
示例#25
0
文件: board.py 项目: wukat/Tetris
 def reset(self):
     self.surface.fill(backgroundcolor)
     self.point = 0
     self.level = 1
     self.count = 0
     self.time = 500
     self.board_show = {i : [SingleBlock(self.surface, BLACK, WHITE) for j in range(NROWS)] for i in range(NCOLS)}
     self.board = {i: [0 for j in range(NROWS + 1)] for i in range(-1, NCOLS + 1)}
     self.board[-1] = [1 for j in range(NROWS + 1)]
     self.board[NCOLS] = [1 for j in range(NROWS + 1)]
     for i in range(-1, NCOLS + 1):
         self.board[i][NROWS] = 1
     self.block = Block(self.board, self.board_show, random.choice(Blocks))
     self.block_next = random.choice(Blocks)
     self.draw()
示例#26
0
def random_context_gus():
    """
    need to be random (because not all context maybe reachable directly from the
    home page, or not all context need to be disclosed publicly), but need to be
    short, just for do not create a loooong URL
    """
    length = 20

    if TESTING:
        global global_debug_counter
        global_debug_counter += 1
        string_value = str(global_debug_counter)
        return u'c_'+(''.join(random.choice('0') for x in range(length - len(string_value))))+string_value
    else:
        return u'c_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#27
0
    def post_request(self, method, filename, request_params={}):
        """
        Generate an API POST request string for an image upload search.

        The POST request string can be sent as is to issue the POST
        request to the API server.

        - `method`, API method being called.
        - `filename`, the filename of the image that is being searched for.
        - `request_params`, the list of search parameters.

        Returns:

        - `request_url`, the URL to send the search to.
        - `boundary`, the boundary to be used in the POST request.
        """
        if filename is None or not len(str(filename).strip()):
            raise APIRequestError("Must specify an image to search for.")

        # Have to generate a boundary, nonce, and date to use in generating a POST
        # request signature
        boundary = ''.join(
            random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
        nonce = self._generate_nonce()
        date = int(time.time())

        api_signature = self._generate_post_hmac_signature(
            "search", boundary, nonce, date, filename,
            request_params=request_params)

        return self._request_url(method, nonce, date, api_signature, request_params), boundary
示例#28
0
文件: oauth.py 项目: multiSnow/ptapp
    def prepare_request(self,url,token=None,secret='',additional_params={},method='GET'):
        encode=lambda t:urlquote(str(t),'')
        urlquh=lambda t:urlquote(str(t),'~')

        params={'oauth_consumer_key':self.consumer_key,
                'oauth_signature_method':'HMAC-SHA1',
                'oauth_timestamp':str(int(time())),
                'oauth_nonce':''.join(list(choice(seqstr) for i in xrange(64))),
                'oauth_version':'1.0'}

        if token:
            params['oauth_token']=token
        elif self.callback_url:
            params['oauth_callback']=self.callback_url

        params.update(additional_params)
        for k,v in params.iteritems():
            if isinstance(v,unicode):
                params[k]=v.encode('utf8')

        params_str='&'.join([encode(k)+'='+urlquh(v) for k,v in sorted(params.iteritems())])
        params['oauth_signature']=hmac('&'.join([self.consumer_secret,secret]),
                                       '&'.join([method,encode(url),urlquh(params_str)]),
                                       sha1).digest().encode('base64').strip()
        return '&'.join([urlquote_plus(str(k),'~')+'='+urlquote_plus(str(v),'~') for k,v in sorted(params.iteritems())])
示例#29
0
def random_file_gus():
    """
    need to be random
    XXX file is now starting with f_ and is supposed to be random
    """
    length = 30
    return u'f_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#30
0
文件: rpg.py 项目: babaklava/SPYA
    def ranpassgen(self, passlen, lower, upper, spec, dig):

        """ Constructs a random password using the provided parameters.

        :param passlen: the length of the password to be generated
        :param lower: use lower case characters in the password
        :param upper: use upper case characters in the password
        :param spec: use special characters in the password
        :param dig: use digits in the password
        :return: Returns randomly generated password
        """
        char_set = []

        if lower is True:
            char_set.append(self.ascii_lower)

        if upper is True:
            char_set.append(self.ascii_upper)

        if spec is True:
            char_set.append(self.special)

        if dig is True:
            char_set.append(self.digits)

        characters = "".join(char_set[:4])
        password = "".join(random.choice(characters) for i in range(int(passlen)))

        return password
示例#31
0
    def ranpassgen(self, passlen, lower, upper, spec, dig):
        """ Constructs a random password using the provided parameters.

        :param passlen: the length of the password to be generated
        :param lower: use lower case characters in the password
        :param upper: use upper case characters in the password
        :param spec: use special characters in the password
        :param dig: use digits in the password
        :return: Returns randomly generated password
        """
        char_set = []

        if lower is True:
            char_set.append(self.ascii_lower)

        if upper is True:
            char_set.append(self.ascii_upper)

        if spec is True:
            char_set.append(self.special)

        if dig is True:
            char_set.append(self.digits)

        characters = "".join(char_set[:4])
        password = "".join(
            random.choice(characters) for i in range(int(passlen)))

        return password
示例#32
0
def generate_unused_dbkey():
    """
    Returns a id matching /[A-Z]{2}[1-9][0-9]{3}/
    for example WL2007
    """
    # Two upper case letters
    new_key = "".join(random.choice(settings.CHARS) for x in range(2))
    # Four digit number, not starting with zero
    new_key += str(random.choice(settings.NUMBERS[1:10]))
    new_key += "".join(random.choice(settings.NUMBERS) for x in range(3))
    try:
        Profile.objects.get(uid = new_key)
        # If we get to here, the key already exists. generate another one..
        return generate_unused_dbkey()
    except ObjectDoesNotExist:
        return new_key
示例#33
0
def random_str(length=8):
    '''生成可打印的 [0-9a-zA-Z] 随机字符串.'''
    seeds = string.letters + string.digits
    random_str = ''
    for x in xrange(length):
        random_str += random.choice(seeds)
    return random_str
示例#34
0
文件: crypter.py 项目: rootkeb/SLAE
def encrypt():
    try:
        global shellcode
        global iv
        global keyList
        key = random.choice(keyList)

        #Let's get our shellcode up to 32 bytes (has to be multiple of 16)

        shellPad = 32 - len(shellcode)

        shellPadBytes = b'\xff' * shellPad

        shellcode = shellPadBytes + shellcode

        #This is where we do our actual encryption!
        aes = AES.new(key, AES.MODE_CBC, iv)
        data = shellcode
        encd = aes.encrypt(data)

        #Let's get it into printable format!
        output = ""

        for x in bytearray(encd):
            output += "\\x"
            output += '%02x' % x

        output = output.replace("\\x", r'\\x')

        print("\n[+] Encrypted Shellcode: " + output)

    except:
        print "Something went wrong with the encryption process."
示例#35
0
def gen_token():
    global key
    iv = rndfile.read(16)
    crypt = AES.new(key, AES.MODE_CBC, iv)
    plaintext = random.choice(data)
    ciphertext = crypt.encrypt(pad_pkcs7(plaintext, 16))
    return iv+ciphertext
def generate(wordlist,
             num_words,
             num_passwords,
             min_word_length=4,
             max_word_length=100,
             min_length=4,
             max_length=100):
    wordlist = [
        x for x in wordlist if min_word_length <= len(x) <= max_word_length
    ]
    generated_passwords = 0
    bad_passwords = 0
    while generated_passwords < num_passwords:
        words = [random.choice(wordlist) for unused_j in range(num_words)]
        password = ''.join(words)
        if not (min_length <= len(password) <= max_length):
            bad_passwords += 1
            if bad_passwords >= 1000:
                raise Exception(
                    "generated too many passwords not fitting the length requirements, bailing out"
                )
            continue

        yield password, tuple(words)
        generated_passwords += 1
示例#37
0
def measureEntangledState(basisA, basisB, errorRate=0.0):
    """Return Alice and Bob's measurement results on a pair of maximally
    entangled qubits. basis[A,B] contain Alice and Bob's axes of mstment.
    """
    # Alice measures either basis state with equal probability
    # -1 will correspond to False (0) and +1 will correspond to True (1)
    resultA = random.choice([-1, 1])

    # If Alice and Bob chose the same axis of mstment, Bob's result is
    # perfectly anti-correlated with Alice's. Otherwise its correlation
    # coefficient is given by -cos[2(basisA-basisB)]. We use the result
    # r to generate a correlated random number that gives Bob's result.
    r = -1 * cos(2 * (basisA - basisB))
    r2 = r**2
    ve = 1 - r2
    SD = sqrt(ve)
    e = np.random.normal(0, SD)
    resultB = resultA * r + e

    resultA = False if resultA < 0 else True
    resultB = False if resultB < 0 else True

    if errorRate:
        samples = np.random.rand(2)
        if samples[0] < errorRate: resultA = not (resultA)
        if samples[1] < errorRate: resultB = not (resultB)

    return (resultA, resultB)
示例#38
0
    def generate_expiring_request(lifetime, plaintext):
        """
        Generate the parameters needed for an expiring email request with the given payload.
        Payload should be comma-delimited, and the consumer should expect to find and verify
        a timestamp and nonce appended to the given plaintext.
        """

        # Add nonce
        rng = Random.new()
        nonce = ''.join(choice(string.ascii_uppercase + string.digits) for _ in range(256))

        expiry = str(time.time() + lifetime)

        plaintext = (plaintext + "," + expiry + "," + nonce).encode('utf-8')

        # Pad the plaintext to the next full block with commas, because I can't be arsed to
        # write an actually clever parser.
        bs = Blowfish.block_size
        paddinglen = bs - (len(plaintext) % bs)
        plaintext += b',' * paddinglen

        # Generate random IV of size one block.
        iv = rng.read(bs)
        cipher = Blowfish.new(VERIFICATION_SECRET_KEY, Blowfish.MODE_CBC, iv)
        ciphertext = cipher.encrypt(plaintext)

        # Generate the verification hash.
        verification = hashlib.sha256()
        verification.update(plaintext + VERIFICATION_HASH_SECRET.encode('utf-8'))
        verify_hex = verification.hexdigest()

        return base64.urlsafe_b64encode(iv), base64.urlsafe_b64encode(ciphertext), verify_hex
示例#39
0
def generate_password(keyfile, args):
    characters = args.get('characters', keyfile.characters)
    length = int(args.get('length', keyfile.length))
    password = ''
    while len(password) < length:
        password += random.choice(characters)
    return password
示例#40
0
    def generate_expiring_request(lifetime, plaintext):
        """
        Generate the parameters needed for an expiring email request with the given payload.
        Payload should be comma-delimited, and the consumer should expect to find and verify
        a timestamp and nonce appended to the given plaintext.
        """

        # Add nonce
        rng = Random.new()
        nonce = ''.join(
            choice(string.ascii_uppercase + string.digits) for _ in range(256))

        expiry = str(time.time() + lifetime)

        plaintext = (plaintext + "," + expiry + "," + nonce).encode('utf-8')

        # Pad the plaintext to the next full block with commas, because I can't be arsed to
        # write an actually clever parser.
        bs = Blowfish.block_size
        paddinglen = bs - (len(plaintext) % bs)
        plaintext += b',' * paddinglen

        # Generate random IV of size one block.
        iv = rng.read(bs)
        cipher = Blowfish.new(VERIFICATION_SECRET_KEY, Blowfish.MODE_CBC, iv)
        ciphertext = cipher.encrypt(plaintext)

        # Generate the verification hash.
        verification = hashlib.sha256()
        verification.update(plaintext +
                            VERIFICATION_HASH_SECRET.encode('utf-8'))
        verify_hex = verification.hexdigest()

        return base64.urlsafe_b64encode(iv), base64.urlsafe_b64encode(
            ciphertext), verify_hex
示例#41
0
    def get_db_prep_value(self, value, connection=None, prepared=False):
        if value is None:
            return None

        value = smart_str(value)

        if not self._is_encrypted(value):
            padding = self._get_padding(value)
            if padding > 0:
                value += "\0" + ''.join([
                    random.choice(string.printable)
                    for index in range(padding-1)
                ])
            if self.block_type:
                self.cipher = self.cipher_object.new(
                    self.secret_key,
                    getattr(self.cipher_object, self.block_type),
                    self.iv)
                if PYTHON3 is True:
                    value = self.prefix + binascii.b2a_hex(
                        self.iv + self.cipher.encrypt(value)).decode('utf-8')
                else:
                    value = self.prefix + binascii.b2a_hex(
                        self.iv + self.cipher.encrypt(value))
            else:
                if PYTHON3 is True:
                    print('>>>', value, '-->', len(value)/16)
                    value = self.prefix + binascii.b2a_hex(
                        self.cipher.encrypt(value)).decode('utf-8')
                else:
                    value = self.prefix + binascii.b2a_hex(
                        self.cipher.encrypt(value))
        return value
示例#42
0
 def genKey(self):
     """Randomly generate a private key"""
     key = ""
     H = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
     for i in range(16):
         key += random.choice(H)
     return key
示例#43
0
def main():
    print('16-bit hash.')
    print('k=8 spacetime tradeoff.', end='\n\n')

    print('building diamond...')
    diamond = build_diamond()
    #  diamond = testvector5()
    print('\n')
    print(diamond)

    ##### MAKE FORECAST #####
    for key in diamond[-1]:
        hashdrop = f(diamond[-1][key], key)
    print('\nh_diamond hashdrop:', hashdrop)

    forecast = choice(open('/usr/share/dict/words',
                           'r').read().splitlines()).encode()
    forepad = forecast + b' #' + (b'\x00' * (32 - 2 - len(forecast)))
    print('\n\n', forepad)
    h2 = f(forepad)
    print('finding link message')
    m_link = find_m_link(h2, diamond[0])
    print('m_link:', m_link)

    prediction = b''
    prediction += forepad + m_link
    for block in diamond:
        prediction += block[f(prediction)]

    print('\npostseason message:', prediction, '\n\nhash:', f(prediction))
    if f(prediction) == hashdrop:
        print('huzzah')
    else:
        print('kaboom')
示例#44
0
文件: crypto.py 项目: jcioi/ioi-cms
def generate_random_password():
    """Utility method to generate a random password.

    return (str): a random string.

    """
    return "".join((random.choice('abcdefghjkmnpqrstuvwxyz23456789') for _ in range(10)))
示例#45
0
def generate_token(length=32):
    """
    Generates a random token containing a-z A-Z 0-9 of size `length`
    Crypto.Random may be a bad choice, consider switching to os.urandom:
    http://stackoverflow.com/a/20469525/263132
    """
    return ''.join(chr(random.choice(_POOL)) for _ in range(length))
示例#46
0
def login(request, *args, **kwargs):
    response = authlogin(request, *args, **kwargs)
    if request.user.is_authenticated():
        lst = [random.choice(string.ascii_letters + string.digits) for n in xrange(30)]
        key = "".join(lst)
        request.user.db.magic_cookie = key
    return response
示例#47
0
def generate_fake_generations():
    genesis_account = Account.objects.get(address=GENESIS_ADDRESS)
    num_transactions = random.randint(1, MAX_TX_PER_BLOCK)

    with open("genesisprivatekey.pem", "r") as f:
        key = RSA.import_key(f.read())

    transactions = []
    print("there are " + str(num_transactions) +
          "transactions generated in this block")
    for _ in range(num_transactions):
        amount = Decimal(str(random.randint(0, 10)))
        target_address = random.choice(account_addresses)
        target_account = Account.objects.get(address=target_address)

        genesis_transactions = Transaction.objects.filter(
            sender=genesis_account)
        nonce = len(genesis_transactions) + 1
        transaction = Transaction.objects.create(sender=genesis_account,
                                                 amount=amount,
                                                 receiver=target_account,
                                                 nonce=nonce)
        transaction.transaction_hash = transaction.hash_hex()
        transaction.signature = pss.new(key).sign(
            transaction.hash_transaction())
        transaction.save()
        transactions.append(transaction)

    return transactions
def pad_message(message):
    """
    Adds padding to the front of the message. Padding is generated by random
    selections from RANDOM_SAMPLE using Crypto.Random.random.choice(). A new
    message is returned in the following format:

                            "{padding}`{message}"

    padding is added to the front to obscure common output from the command
    line i.e. windows sends the stdin to the stdout, beginning with the
    working directory.
    """

    # determine the pad_length based on the key BLOCK_SIZE
    if len(message) < BLOCK_SIZE:
        pad_length = (BLOCK_SIZE - len(message))
    elif len(message) > BLOCK_SIZE:
        pad_length = (len(message) % BLOCK_SIZE)
    else:
        pad_length = BLOCK_SIZE

    if pad_length < 16:
        pad_length += BLOCK_SIZE

    # reduce by one for the delimiter that is added between message and padding
    pad_length -= 1
    padding = ""

    while len(padding) < pad_length:
        padding += random.choice(RANDOM_SAMPLE)

    return"{}`{}".format(padding, message)
示例#49
0
def test_dlog_eq(iters=1):
    print "test_dlog_eq:"
    keys = generate_keys()
    n = keys['pub']
    z = n - 1
    p, q = keys['priv']

    for i in range(iters):
        print 'i = ', i
        r = random.randint(0, int((p - 1) * (q - 1)))

        y = random.randint(0, int(n - 1))

        Y = powmod(y, r, n)
        Z = powmod(z, r, n)

        P_dlog = proof_dlog_eq(r, y, n)

        assert (verify_dlog_eq(n, y, Y, Z, P_dlog))

        P_dlog[random.randint(0, len(P_dlog)-1)][random.randint(0,2)] += \
            random.choice([-1, 1])

        assert (not verify_dlog_eq(n, y, Y, Z, P_dlog))

    print "test_dlog_eq pass"
示例#50
0
def gen_key(size=16):
    """ 
    用Crypto.Random模块生成的真随机字符串
    """
    _key = ''
    return _key.join(
        cry_rand.choice(string.letters + string.digits) for i in range(size))
示例#51
0
    def get_db_prep_value(self, value, connection=None, prepared=False):
        if value is None:
            return None

        value = smart_bytes(value)

        if not self._is_encrypted(value):
            padding = self._get_padding(value)
            if padding > 0:
                value += smart_bytes("\0" + ''.join([
                    random.choice(string.printable)
                    for index in range(padding-1)
                ]))
            if self.block_type:
                self.cipher = self.cipher_object.new(
                    self.secret_key,
                    getattr(self.cipher_object, self.block_type),
                    self.iv)
                value = smart_bytes(self.prefix) + binascii.b2a_hex(
                    smart_bytes(self.iv) + self.cipher.encrypt(smart_bytes(value))
                )
            else:
                value = smart_bytes(self.prefix) + binascii.b2a_hex(
                    self.cipher.encrypt(smart_bytes(value))
                )
        return value
示例#52
0
def random_folder_gus():
    """
    need to be random
    XXX this has been changed to starting d_ for directory.
    """
    length = 20
    return u'd_'+(''.join(random.choice(string.ascii_letters) for x in range(length)))
示例#53
0
文件: crypt.py 项目: jiaort/my-site
def random_str(length=8):
    '''生成可打印的 [0-9a-zA-Z] 随机字符串.'''
    seeds = string.letters + string.digits
    random_str = ''
    for x in xrange(length):
        random_str += random.choice(seeds)
    return random_str
示例#54
0
def randKey(alpha, keyLen):
    key = ""
    count = 0
    while count < keyLen:
        key += random.choice(alpha)
        count += 1
    return key
示例#55
0
def redeem_token(claim):
    try:
        # verify the checksum of the file against its "token" object
        token = claim["token"]
        token_str = json.dumps(token)
        print("Verifying token...")
        checksum = bytes.fromhex(claim["checksum"])
        validate_checksum(token_str, checksum)
        print("Validated Checksum.")
        print("Fetching Keys from Bank")
        response = requests.get(claim["bank-address"] + "/public-key")
        data = response.json()
        e = int.from_bytes(bytes.fromhex(data.get("key")), "big")
        n = int.from_bytes(bytes.fromhex(data.get("modulus")), "big")
        print("Validating Bank Signature...")
        checksum = int.from_bytes(checksum, "big")
        signature = int.from_bytes(bytes.fromhex(claim.get("signature")),
                                   "big")
        validate_signature(checksum, signature, (e, n))
        print("Signature Good.")

        session_id = str(uuid.uuid4())
        print("Establishing Session: %s" % session_id)
        pattern = list(
            random.choice([0, 1]) for identity in token["identities"])
        print("Requesting keys for from Client: \n" + str(pattern))
        _sessions[session_id] = claim, pattern
        return session_id, pattern
    except Exception as e:
        raise e
示例#56
0
def home(request):
    """Renders the home page."""
    key = '000102030405060708090A0B0C0D0E0F'
    nonce = 'BBAA99887766554433221103'
    associated = ''
    #if request.GET.get('U'):
    #    message = 'You submitted: %r' % request.GET['U']
    #else:
    #    message = 'You submitted nothing'
    #UID = ''+request.GET.get('U').upper().encode()
    #TF = binascii.hexlify(request.GET.get('TF').upper())
    #TS = ''+request.GET.get('TS')
    #RLC = request.GET.get('RLC')
    PT = "%s%s%s%s" % (request.GET.get('U'),binascii.hexlify(request.GET.get('TF').upper()),request.GET.get('TS'),request.GET.get('RLC'))
    [cipher,tag] = ocb_encrypt(key,nonce,'',PT)
    assert isinstance(request, HttpRequest)
    return render(
        request,
        'app/index.html',
        {
            #/?U=E0391122334455&TF=AA&TS=0000019B&RLC=D7B9EEA9C9FD689333AD097A9BD79C12B67A0FA6130BBC7890F12AEADF01206CB78F9DDA10A56933AE08F12588
            'namee':random.choice(['Dogs', 'Cats', 'Bears']),
            #'getu':request.GET.get('U'),
            #'gettf':binascii.hexlify(request.GET.get('TF').upper()),
            #'getts':request.GET.get('TS'),
            #'getrlc':request.GET.get('RLC'),
            'ocb': [binascii.hexlify(cipher).upper(),binascii.hexlify(tag).upper()],
            'decry': ocb_decrypt(key,nonce,associated,cipher,tag),
            'title':'Home Page',
            'year':datetime.now().year,
        }
    )
 def generate_random_password(self, length = 8):
     #concatination of all chosen sets (uppercase, lowercase, etc.)
     password_set = self.UPPERCASE_LETTERS + self.LOWERCASE_LETTERS + self.DIGITS + self.PUNCTUATION
     password = ''
     for i in xrange(length):
         password += random.choice(password_set)
     return password