示例#1
0
    def test_data_transfer(self):

        # open stream
        random.shuffle(self.swarm)
        alice = self.swarm[0]
        bob = self.swarm[1]
        hexstreamid = alice.stream_open(bob.dht_id())
        self.assertIsNotNone(hexstreamid)

        # send 1M
        sent = hashlib.sha256()
        for chunk in [os.urandom(1024) for i in range(512)]:
            hexdata = binascii.hexlify(chunk)
            bytes_written = alice.stream_write(hexstreamid, hexdata)
            self.assertEqual(bytes_written, 1024)
            sent.update(hexdata)
        sent_digest = sent.hexdigest()

        # receive 1M
        received = hashlib.sha256()
        while True:
            hexdata = bob.stream_read(hexstreamid, size=1024)
            if not hexdata:
                break
            received.update(hexdata)
        received_digetst = received.hexdigest()

        self.assertEqual(sent_digest, received_digetst)

        # close stream
        self.assertTrue(alice.stream_close(hexstreamid))
 def forwards(self, orm):
     for award in orm['badges.Award'].objects.all():
         user = award.user
         try:
             user.identity
             current_identity_hash = user.identity.identity_hash
             new_candidate_identity_hash = u'sha256$' + hashlib.sha256(user.email + user.identity.salt).hexdigest()
             if current_identity_hash != new_candidate_identity_hash:
                 salt = uuid.uuid4().hex[:5]
                 user.identity.salt = salt
                 user.identity.identity_hash = u'sha256$' + hashlib.sha256(user.email + salt).hexdigest()
                 user.identity.save()
         except:
             salt = uuid.uuid4().hex[:5]
             orm['badges.Identity'].objects.create(
                 user=user,
                 identity_hash=u'sha256$' + hashlib.sha256(user.email + salt).hexdigest(),
                 salt=salt
             )
         award.uuid = uuid.uuid1()
         award.identity_hash = award.user.identity.identity_hash
         award.identity_type = award.user.identity.type
         award.identity_hashed = award.user.identity.hashed
         award.identity_salt = award.user.identity.salt
         award.expires = None
         award.save()
def cross_check_consistency_against_opensource_algorithm(first, second, first_hash, second_hash, consistency):
    try:
        node = first - 1
        last_node = second - 1

        while node & 1:
            node >>= 1
            last_node >>= 1

        p = iter(consistency)
        if node:
            old_hash = p.next()
        else:  # old was 2 ** n
            old_hash = first_hash
        new_hash = old_hash

        while node:
            if node & 1:
                x = p.next()
                old_hash = sha256(chr(1) + x + old_hash).digest()
                new_hash = sha256(chr(1) + x + new_hash).digest()
            elif node < last_node:
                new_hash = sha256(chr(1) + new_hash + p.next()).digest()
            node >>= 1
            last_node >>= 1
        while last_node:
            new_hash = sha256(chr(1) + new_hash + p.next()).digest()
            last_node >>= 1

        for remaining in p:
            return False  # we shouldn't have any elements left over

        return old_hash == first_hash and new_hash == second_hash
    except StopIteration:
        return False  # ran out of elements
示例#4
0
def submit_recording(connection, data):
    data_json = json.dumps(data, sort_keys=True, separators=(',', ':'))
    data_sha256 = sha256(data_json.encode("utf-8")).hexdigest()

    meta = {"artist": data["artist"], "title": data["title"]}
    meta_json = json.dumps(meta, sort_keys=True, separators=(',', ':'))
    meta_sha256 = sha256(meta_json.encode("utf-8")).hexdigest()

    artist = get_artist_credit(connection, data["artist"])
    if not artist:
        artist = add_artist_credit(connection, data["artist"])
    if "release" in data:
        release = get_release(connection, data["release"])
        if not release:
            release = add_release(connection, data["release"])
    else:
        release = None
    query = text("""INSERT INTO recording_json (data, data_sha256, meta_sha256)
                   VALUES (:data, :data_sha256, :meta_sha256)
                RETURNING id""")
    result = connection.execute(query, {"data": data_json,
                                           "data_sha256": data_sha256,
                                           "meta_sha256": meta_sha256})
    id = result.fetchone()["id"]
    gid = str(uuid.uuid4())
    query = text("""INSERT INTO recording (gid, data, artist, release, submitted)
                    VALUES (:gid, :data, :artist, :release, now())""")
    connection.execute(query, {"gid": gid,
                                  "data": id,
                                  "artist": artist,
                                  "release": release})

    return gid
def cross_check_inclusion_via_opensource(hash, leaf_index, audit_path, tree_size, root_hash):
    audit_path = audit_path[:]

    node_index = leaf_index
    calculated_hash = hash
    last_node = tree_size - 1
    while last_node > 0:
        if not audit_path:
            return False

        if node_index % 2:
            audit_hash = audit_path.pop(0)
            calculated_hash = sha256(chr(1) + audit_hash + calculated_hash).digest()
        elif node_index < last_node:
            audit_hash = audit_path.pop(0)
            calculated_hash = sha256(chr(1) + calculated_hash + audit_hash).digest()
        # node_index == last_node and node_index is even: A sibling does
        # not exist. Go further up the tree until node_index is odd so
        # calculated_hash will be used as the right-hand operand.
        node_index //= 2
        last_node //= 2
    if audit_path:
        return False

    return calculated_hash == root_hash
示例#6
0
    def outputfilename(self, data, filename, raw):
        directory = os.path.dirname(filename)
        if is_py2:
            id = hashlib.sha256(data["programVersionId"]).hexdigest()[:7]
        else:
            id = hashlib.sha256(data["programVersionId"].encode("utf-8")).hexdigest()[:7]

        datatitle = re.search('data-title="([^"]+)"', self.get_urldata())
        if not datatitle:
            return None
        datat = decode_html_entities(datatitle.group(1))
        name = self.name(datat)
        episode = self.seasoninfo(datat)
        if is_py2:
            name = name.encode("utf8")
        if episode:
            title = "{0}.{1}-{2}-svtplay".format(name, episode, id)
        else:
            title = "{0}-{1}-svtplay".format(name, id)
        title = filenamify(title)
        if len(directory):
            output = os.path.join(directory, title)
        else:
            output = title
        return output
def check_inclusion_via_rfc_algorithm(hash, leaf_index, audit_path, tree_size, root_hash):
    # 1.  Set "fn" to "leaf_index" and "sn" to "tree_size - 1".
    fn, sn = leaf_index, tree_size - 1

    # 2.  Set "r" to "hash".
    r = hash

    # 3.  For each value "p" in the "audit_path" array:
    for p in audit_path:
        #  If "LSB(fn)" is set, or if "fn" is equal to "sn", then:
        if lsb(fn) or (fn == sn):
            # 1.  Set "r" to "HASH(0x01 || p || r)"
            r = sha256(chr(1) + p + r).digest()

            # 2.  If "LSB(fn)" is not set, then right-shift both "fn" and "sn"
            #     equally until either "LSB(fn)" is set or "fn" is "fn".
            while not ((fn == 0) or lsb(fn)):
                fn >>= 1
                sn >>= 1
        # Otherwise:
        else:
            #    Set "r" to "HASH(0x01 || r || p)"
            r = sha256(chr(1) + r + p).digest()
        #   Finally, right-shift both "fn" and "sn" one time.
        fn >>= 1
        sn >>= 1

    # 4.  Compare "r" against the "root_hash".  If they are equal,
    #     then the log has proven the inclusion of "hash".
    return r == root_hash
示例#8
0
    def test_derSigToHexSig(self):
        derSig = "304502204c01fee2d724fb2e34930c658f585d49be2f6ac87c126506c0179e6977716093022100faad0afd3ae536cfe11f83afaba9a8914fc0e70d4c6d1495333b2fb3df6e8cae"
        self.assertEqual("4c01fee2d724fb2e34930c658f585d49be2f6ac87c126506c0179e6977716093faad0afd3ae536cfe11f83afaba9a8914fc0e70d4c6d1495333b2fb3df6e8cae",
                         derSigToHexSig(derSig))
   

        txn =          ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
                        "8a47" +
                        "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01" +
                        "41" +
                        "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55" +
                        "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
                        "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000")
        myTxn_forSig = ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
                        "1976a914" + "167c74f7491fe552ce9e1912810a984355b8ee07" + "88ac" +
                        "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
                        "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000" +
                        "01000000")
        public_key =    "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55"
        hashToSign = hashlib.sha256(hashlib.sha256(myTxn_forSig.decode('hex')).digest()).digest().encode('hex')
        sig_der =       "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01"[:-2]
        sig = derSigToHexSig(sig_der)

        vk = ecdsa.VerifyingKey.from_string(public_key[2:].decode('hex'), curve=ecdsa.SECP256k1)
        self.assertEquals(vk.verify_digest(sig.decode('hex'), hashToSign.decode('hex')), True)
示例#9
0
    def _generate_new_keypair(self):
        secret = str(random.randrange(2 ** 256))
        self.secret = hashlib.sha256(secret).hexdigest()
        self.pubkey = privtopub(self.secret)
        self.privkey = random_key()
        print 'PRIVATE KEY: ', self.privkey
        self.btc_pubkey = privtopub(self.privkey)
        print 'PUBLIC KEY: ', self.btc_pubkey

        # Generate SIN
        sha_hash = hashlib.sha256()
        sha_hash.update(self.pubkey)
        ripe_hash = hashlib.new('ripemd160')
        ripe_hash.update(sha_hash.digest())

        self.guid = ripe_hash.digest().encode('hex')
        self.sin = obelisk.EncodeBase58Check('\x0F\x02%s' + ripe_hash.digest())

        newsettings = {
            "secret": self.secret,
            "pubkey": self.pubkey,
            "privkey": self.privkey,
            "guid": self.guid,
            "sin": self.sin
        }
        self.db.updateEntries("settings", {"market_id": self.market_id}, newsettings)
        self.settings.update(newsettings)
 def __init__(self, username, password, pathToKeyFilename):
     #when making keys from password for a specific keyFilename
     salt = hashlib.sha256(username).digest()
     self.keyAES = makeKeyAES(password, salt)
     saltIv = hashlib.sha256(str(pathToKeyFilename)).digest()
     self.iv = makeIV(self.keyAES, saltIv)
     self.rsaKeyObj = makeRSAKeyObj(password, salt)
示例#11
0
def checkSame(seq1, seq2, numOfBits):
    for i in xrange(numOfBits/4):
        if (int(hashlib.sha256(seq1).hexdigest()[i], 16) & FLAG_1) != \
            (int(hashlib.sha256(seq2).hexdigest()[i], 16) & FLAG_1):
            return False

    return True
示例#12
0
def wrappedSummationAndItems(fact, roundedSum, boundSummationItems):
    # need hash of facts and their values from boundSummationItems
    ''' ARELLE-281, replace: faster python-based hash (replace with hashlib for fewer collisions)
    itemValuesHash = hash( tuple(( hash(b.modelObject.qname), hash(b.extraProperties[1][1]) )
                                 # sort by qname so we don't care about reordering of summation terms
                                 for b in sorted(boundSummationItems,
                                                       key=lambda b: b.modelObject.qname)) )
    sumValueHash = hash( (hash(fact.qname), hash(roundedSum)) )
    '''
    sha256 = hashlib.sha256()
    # items hash: sort by qname so we don't care about reordering of summation terms in linkbase updates
    for b in sorted(boundSummationItems, key=lambda b: b.modelObject.qname):
        sha256.update(b.modelObject.qname.namespaceURI.encode('utf-8','replace')) #qname of erroneous submission may not be utf-8 perfectly encodable
        sha256.update(b.modelObject.qname.localName.encode('utf-8','replace'))
        sha256.update(str(b.extraProperties[1][1]).encode('utf-8','replace'))
    itemValuesHash = sha256.hexdigest()
    # summation value hash
    sha256 = hashlib.sha256()
    sha256.update(fact.qname.namespaceURI.encode('utf-8','replace'))
    sha256.update(fact.qname.localName.encode('utf-8','replace'))
    sha256.update(str(roundedSum).encode('utf-8','replace'))
    sumValueHash = sha256.hexdigest()
    # return list of bound summation followed by bound contributing items
    return [ObjectPropertyViewWrapper(fact,
                                      ( ("sumValueHash", sumValueHash),
                                        ("itemValuesHash", itemValuesHash),
                                        ("roundedSum", roundedSum) ))] + \
            boundSummationItems
                    
  def setUp(self):
    super(CollectionArchiveGeneratorTest, self).setUp()

    path1 = "aff4:/C.0000000000000000/fs/os/foo/bar/hello1.txt"
    with aff4.FACTORY.Create(path1, aff4.AFF4MemoryStream.__name__,
                             token=self.token) as fd:
      fd.Write("hello1")
      fd.Set(fd.Schema.HASH,
             rdf_crypto.Hash(sha256=hashlib.sha256("hello1").digest()))

    path2 = u"aff4:/C.0000000000000000/fs/os/foo/bar/中国新闻网新闻中.txt"
    with aff4.FACTORY.Create(path2, aff4.AFF4MemoryStream.__name__,
                             token=self.token) as fd:
      fd.Write("hello2")
      fd.Set(fd.Schema.HASH,
             rdf_crypto.Hash(sha256=hashlib.sha256("hello2").digest()))

    self.stat_entries = []
    self.paths = [path1, path2]
    for path in self.paths:
      self.stat_entries.append(rdf_client.StatEntry(
          aff4path=path,
          pathspec=rdf_paths.PathSpec(
              path="fs/os/foo/bar/" + path.split("/")[-1],
              pathtype=rdf_paths.PathSpec.PathType.OS)))

    self.fd = None
示例#14
0
    def got_data(self):
        while True:
            if len(self.recvbuf) < 4:
                return
            if self.recvbuf[:4] != self.node.netmagic.msg_start:
                raise ValueError("got garbage %s" % repr(self.recvbuf))
            # check checksum
            if len(self.recvbuf) < 4 + 12 + 4 + 4:
                return
            command = self.recvbuf[4:4+12].split("\x00", 1)[0]
            msglen = struct.unpack("<i", self.recvbuf[4+12:4+12+4])[0]
            checksum = self.recvbuf[4+12+4:4+12+4+4]
            if len(self.recvbuf) < 4 + 12 + 4 + 4 + msglen:
                return
            msg = self.recvbuf[4+12+4+4:4+12+4+4+msglen]
            th = hashlib.sha256(msg).digest()
            h = hashlib.sha256(th).digest()
            if checksum != h[:4]:
                raise ValueError("got bad checksum %s" % repr(self.recvbuf))
            self.recvbuf = self.recvbuf[4+12+4+4+msglen:]

            if command in messagemap:
                f = cStringIO.StringIO(msg)
                t = messagemap[command](self.ver_recv)
                t.deserialize(f)
                self.node.got_message(self, t)
            else:
                print("UNKNOWN COMMAND %s %s" % (command, repr(msg)))
示例#15
0
    def _delete_network_with_exception(self, network_id, ex):
        fake_neutron_network_id = "4e8e5957-649f-477b-9e5b-f1f75b21c03c"
        if ex == exceptions.NotFound:
            fake_networks_response = {
                "networks": []
            }
        else:
            fake_networks_response = {
                "networks": [{
                    "status": "ACTIVE",
                    "subnets": [],
                    "name": network_id,
                    "admin_state_up": True,
                    "tenant_id": "9bacb3c5d39d41a79512987f338cf177",
                    "router:external": False,
                    "segments": [],
                    "shared": False,
                    "id": fake_neutron_network_id
                }]
            }
        self.mox.StubOutWithMock(app.neutron, 'list_networks')
        app.neutron.list_networks(
            name=network_id).AndReturn(fake_networks_response)
        subnet_v4_id = "9436e561-47bf-436a-b1f1-fe23a926e031"
        subnet_v6_id = "64dd4a98-3d7a-4bfd-acf4-91137a8d2f51"

        docker_network_id = hashlib.sha256(
            utils.getrandbits(256)).hexdigest()
        docker_endpoint_id = hashlib.sha256(
            utils.getrandbits(256)).hexdigest()

        fake_v4_subnet = self._get_fake_v4_subnet(
            docker_network_id, docker_endpoint_id, subnet_v4_id)
        fake_v6_subnet = self._get_fake_v6_subnet(
            docker_network_id, docker_endpoint_id, subnet_v6_id)
        fake_subnets_response = {
            "subnets": [
                fake_v4_subnet['subnet'],
                fake_v6_subnet['subnet']
            ]
        }

        self.mox.StubOutWithMock(app.neutron, 'list_subnets')
        app.neutron.list_subnets(network_id=fake_neutron_network_id).AndReturn(
            fake_subnets_response)

        self.mox.StubOutWithMock(app.neutron, 'list_subnetpools')
        fake_subnetpools_response = {"subnetpools": []}
        app.neutron.list_subnetpools(name='kuryr').AndReturn(
            fake_subnetpools_response)
        app.neutron.list_subnetpools(name='kuryr6').AndReturn(
            fake_subnetpools_response)

        self.mox.StubOutWithMock(app.neutron, 'delete_subnet')
        app.neutron.delete_subnet(subnet_v4_id).AndReturn(None)
        app.neutron.delete_subnet(subnet_v6_id).AndReturn(None)

        self.mox.StubOutWithMock(app.neutron, 'delete_network')
        app.neutron.delete_network(fake_neutron_network_id).AndRaise(ex)
        self.mox.ReplayAll()
示例#16
0
 def get_password_digest(self, password, salt=None):
     if not salt:
         salt = base64.b64encode(os.urandom(32))
     digest = hashlib.sha256(salt + password).hexdigest()
     for x in range(0, 100001):
         digest = hashlib.sha256(digest).hexdigest()
     return salt, digest
示例#17
0
文件: labels.py 项目: GemHQ/electrum
    def load_wallet(self, wallet, window):
        self.wallet = wallet

        self.wallet_nonce = self.wallet.storage.get("wallet_nonce")
        self.print_error("Wallet nonce is", self.wallet_nonce)
        if self.wallet_nonce is None:
            self.set_nonce(1)

        mpk = ''.join(sorted(self.wallet.get_master_public_keys().values()))
        self.encode_password = hashlib.sha1(mpk).digest().encode('hex')[:32]
        self.iv = hashlib.sha256(self.encode_password).digest()[:16]
        self.wallet_id = hashlib.sha256(mpk).digest().encode('hex')

        addresses = []
        for account in self.wallet.accounts.values():
            for address in account.get_addresses(0):
                addresses.append(address)

        self.addresses = addresses

        # If there is an auth token we can try to actually start syncing
        def do_pull_thread():
            try:
                self.pull_thread()
            except Exception as e:
                self.print_error("could not retrieve labels:", e)
        t = threading.Thread(target=do_pull_thread)
        t.setDaemon(True)
        t.start()
示例#18
0
    def _set_shedule(self):
        settings = self.client.settings
        client = boto3.client('events', **settings)
        for function_name, function_config in self.lambda_config.items():
            expression = function_config.get('shedule_expression')
            if expression:
                response = client.put_rule(
                    Name=function_name,
                    ScheduleExpression=expression,
                    State='ENABLED'
                )

                client.put_targets(
                    Rule=function_name,
                    Targets=[
                        {'Id': hashlib.sha256(function_name).hexdigest(),
                         'Arn': self.arns[function_name]
                         }
                    ]
                )
                permission = dict(
                    FunctionName=function_name,
                    StatementId=hashlib.sha256(function_name).hexdigest(),
                    Action="lambda:InvokeFunction",
                    Principal="events.amazonaws.com",
                    SourceArn=response['RuleArn'],
                )

                try:
                    self.client.instance.add_permission(**permission)
                except ClientError:
                    pass
示例#19
0
 def test_all(self):
     for test in ['', 'a', 'b', 'abc', 'abc'*50, 'hello world']:
         #print test
         #print sha256.sha256(test).hexdigest()
         #print hashlib.sha256(test).hexdigest()
         #print
         assert sha256.sha256(test).hexdigest() == hashlib.sha256(test).hexdigest()
     def random_str(l):
         return ''.join(chr(random.randrange(256)) for i in xrange(l))
     for length in xrange(150):
         test = random_str(length)
         a = sha256.sha256(test).hexdigest()
         b = hashlib.sha256(test).hexdigest()
         #print length, a, b
         if a != b:
             print 'ERROR!'
             raise ValueError()
     for i in xrange(100):
         test = random_str(int(random.expovariate(1/100)))
         test2 = random_str(int(random.expovariate(1/100)))
         
         a = sha256.sha256(test)
         a = a.copy()
         a.update(test2)
         a = a.hexdigest()
         
         b = hashlib.sha256(test)
         b = b.copy()
         b.update(test2)
         b = b.hexdigest()
         #print a, b
         if a != b:
             print 'ERROR!'
             raise ValueError()
示例#20
0
文件: electrum.py 项目: imcoddy/bippy
def encrypt(seed, passphrase):
	"""
		Encrypt the Electrum seed
	"""
	#1. Decode the seed value to the original number
	seed = mn_decode(seed.split())

	#2. Take a hash of the decoded seed to act as a scrypt salt
	salt = hashlib.sha256(hashlib.sha256(seed).digest()).digest()[:4]

	#3. Derive a key from the passphrase using scrypt
	key = scrypt.hash(passphrase, salt, 16384, 8, 8)

	#4. Split the key into half 1 and half 2
	derivedhalf1 = key[0:32]
	derivedhalf2 = key[32:64]

	#5. Do AES256Encrypt(seedhalf1 xor derivedhalf1[0...15], derivedhalf2), call the 16-byte result encryptedhalf1
	# (Electrum may change the number of words in a seed so we should future proof by just using the halfs rather than hardcoded lengths)
	Aes = aes.Aes(derivedhalf2)
	encryptedhalf1 = Aes.enc(enc.sxor(seed[:int(math.floor(len(seed)/2))], derivedhalf1[:16]))

	#6. Do AES256Encrypt(seedhalf2 xor derivedhalf1[16...31], derivedhalf2), call the 16-byte result encryptedhalf2
	encryptedhalf2 = Aes.enc(enc.sxor(seed[int(math.floor(len(seed)/2)):len(seed)], derivedhalf1[16:32]))

	#7. The encrypted private key is the Base58Check-encoded concatenation of the following
	# \x4E\xE3\x13\x35 + salt + encryptedhalf1 + encryptedhalf2
	# (\x4E\xE3\x13\x35) gives the 'SeedE' prefix)
	encSeed = '\x4E\xE3\x13\x35' + salt + encryptedhalf1 + encryptedhalf2
	check = hashlib.sha256(hashlib.sha256(encSeed).digest()).digest()[:4]
	return enc.b58encode(encSeed + check)
示例#21
0
def decrypt(secret, message):
    message = message.encode('utf-8')
    curve = SECP256k1.curve()
    order = SECP256k1.order()
    R_size = 1 + 32
    mac_size = hashlib.sha256().digest_size

    message_binary = base64.b64decode(message)
    if len(message_binary) < (R_size + mac_size):
        return None

    R = decode_point(message_binary)
    d = message_binary[R_size:R_size + mac_size]
    prefix_bytes = message_binary[R_size + mac_size:R_size + mac_size + 8]
    c = message_binary[R_size + mac_size + 8:]
    S = (secret * R).x()
    S_bytes = S.to_bytes(32, 'big')
    k_E = hashlib.sha256(S_bytes + b'\0\0\0\1').digest()
    k_M = hashlib.sha256(S_bytes + b'\0\0\0\2').digest()
    d_verify = hmac.new(k_M, prefix_bytes + c, hashlib.sha256).digest()
    if d_verify != d:
        return None
    ctr = Counter.new(64, prefix=prefix_bytes)
    cipher = AES.new(key=k_E, mode=AES.MODE_CTR, counter=ctr)
    padded = cipher.decrypt(c)
    try:
        return unpad(padded, AES.block_size).decode('utf-8')
    except:
        return None
示例#22
0
    def decrypt_body(self, password, data):
        import time
        key = sha256(password).digest()
        hdr = self.header
        
        then = time.time()
        # sha256 the password, encrypt it upon itself 50000 times, sha256 it again, and sha256 it again concatenated with a random number :|
        cipher = AES.new(hdr['seed_key'], AES.MODE_ECB)
        for x in range(hdr['seed_rot_n']):
            key = cipher.encrypt(key)
        key = sha256(key).digest()
        key = sha256(hdr['seed_rand'] + key).digest()
        cipher = AES.new(key, AES.MODE_CBC, hdr['enc_iv'])
        body = cipher.decrypt(data)

        # remove some padding
        padding = unpack("b", body[-1])[0]
        body = body[:-padding]

        now = time.time()

        print 'spent %.3fms on decryption' % ((now - then) * 1000)
        if sha256(body).digest() != hdr['checksum']:
            raise KdbReaderDecodeFailError()

        return body
def validate(bitcoin_address, magicbyte=0):
    """Check the integrity of a bitcoin address

    Returns False if the address is invalid.
    >>> validate('1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i')
    True
    >>> validate('')
    False
    """
    if isinstance(magicbyte, int):
        magicbyte = (magicbyte,)
    clen = len(bitcoin_address)
    if clen < 27 or clen > 35: # XXX or 34?
        return False
    allowed_first = tuple(string.digits)
    try:
        bcbytes = decode_base58(bitcoin_address, 25)
    except ValueError:
        return False
    # Check magic byte (for other altcoins, fix by Frederico Reiven)
    for mb in magicbyte:
        if bcbytes.startswith(chr(int(mb))):
            break
    else:
        return False
    # Compare checksum
    checksum = sha256(sha256(bcbytes[:-4]).digest()).digest()[:4]
    if bcbytes[-4:] != checksum:
        return False
    # Encoded bytestring should be equal to the original address,
    # for example '14oLvT2' has a valid checksum, but is not a valid btc
    # address
    return bitcoin_address == encode_base58(bcbytes)
示例#24
0
def DerivePlayReadyKey(seed, kid, swap=True):
    if len(seed) < 30:
        raise Exception('seed must be  >= 30 bytes')
    if len(kid) != 16:
        raise Exception('kid must be 16 bytes')

    if swap:
        kid = kid[3]+kid[2]+kid[1]+kid[0]+kid[5]+kid[4]+kid[7]+kid[6]+kid[8:]

    seed = seed[:30]

    sha = hashlib.sha256()
    sha.update(seed)
    sha.update(kid)
    sha_A = [ord(x) for x in sha.digest()]

    sha = hashlib.sha256()
    sha.update(seed)
    sha.update(kid)
    sha.update(seed)
    sha_B = [ord(x) for x in sha.digest()]

    sha = hashlib.sha256()
    sha.update(seed)
    sha.update(kid)
    sha.update(seed)
    sha.update(kid)
    sha_C = [ord(x) for x in sha.digest()]

    content_key = ""
    for i in range(16):
        content_key += chr(sha_A[i] ^ sha_A[i+16] ^ sha_B[i] ^ sha_B[i+16] ^ sha_C[i] ^ sha_C[i+16])

    return content_key
示例#25
0
    def test_pick_blocks(self):
        integer = random.randint(0, 65535)
        decimal_ = Decimal(random.random()) + 5
        hashobj = hashlib.sha256(os.urandom(24))
        hexdigest = hashlib.sha256(os.urandom(24)).hexdigest()

        seeds = self.hb.pick_blocks(4, integer)
        self.assertEqual(len(seeds), 4)

        seeds = self.hb.pick_blocks(4, decimal_)
        self.assertEqual(len(seeds), 4)
        for seed in seeds:
            self.assertIsInstance(seed, int)

        seeds = self.hb.pick_blocks(4, hashobj)
        self.assertEqual(len(seeds), 4)
        for seed in seeds:
            self.assertIsInstance(seed, int)

        seeds = self.hb.pick_blocks(4, hexdigest)
        self.assertEqual(len(seeds), 4)
        for seed in seeds:
            self.assertIsInstance(seed, int)

        with self.assertRaises(HeartbeatError) as ex:
            self.hb.pick_blocks(-1, integer)
        ex_msg = ex.exception.message
        self.assertEqual("-1 is not greater than 0", ex_msg)
示例#26
0
文件: pyaxo.py 项目: ghtdak/pyaxo
 def encrypt(self, plaintext):
     if self.state['ratchet_flag']:
         self.state['DHRs_priv'], self.state['DHRs'] = self.genKey()
         self.state['HKs'] = self.state['NHKs']
         self.state['RK'] = sha256(self.state['RK'] +
                                   self.gen_dh(
                                       self.state['DHRs_priv'],
                                       self.state['DHRr'])).digest()
         if self.mode:
             self.state['NHKs'] = pbkdf2(self.state['RK'], b'\x03', 10,
                                         prf='hmac-sha256')
             self.state['CKs'] = pbkdf2(self.state['RK'], b'\x05', 10,
                                        prf='hmac-sha256')
         else:
             self.state['NHKs'] = pbkdf2(self.state['RK'], b'\x04', 10,
                                         prf='hmac-sha256')
             self.state['CKs'] = pbkdf2(self.state['RK'], b'\x06', 10,
                                        prf='hmac-sha256')
         self.state['PNs'] = self.state['Ns']
         self.state['Ns'] = 0
         self.state['ratchet_flag'] = False
     mk = sha256(self.state['CKs'] + '0').digest()
     msg1 = self.enc(self.state['HKs'], str(self.state['Ns']).zfill(3) +
                     str(self.state['PNs']).zfill(3) + self.state['DHRs'])
     msg2 = self.enc(mk, plaintext)
     pad_length = 106 - len(msg1)
     pad = os.urandom(pad_length - 1) + chr(pad_length)
     msg = msg1 + pad + msg2
     self.state['Ns'] += 1
     self.state['CKs'] = sha256(self.state['CKs'] + '1').digest()
     return msg
示例#27
0
def encode_xmlrpc_chunks_iterator(file_obj):
    """
    Prepare data for a xml-rpc transfer.
    Iterate through (chunk_start, chunk_len, chunk_checksum, encoded_chunk) tuples.
    Final tuple is (total_length, -1, total_checksum, "").

    @param file_obj: file object (or StringIO, etc.)
    @type  file_obj: file
    @return: (chunk_start, chunk_len, chunk_checksum, encoded_chunk)
    @rtype:  (str, str, str, str)
    """

    CHUNK_SIZE = 1024 ** 2
    checksum = hashlib.sha256()
    chunk_start = file_obj.tell()

    while True:
        chunk = file_obj.read(CHUNK_SIZE)
        if not chunk:
            break
        checksum.update(chunk)
        encoded_chunk = base64.encodestring(chunk)
        yield (str(chunk_start), str(len(chunk)), hashlib.sha256(chunk).hexdigest().lower(), encoded_chunk)
        chunk_start += len(chunk)

    yield (str(chunk_start), -1, checksum.hexdigest().lower(), "")
示例#28
0
    def __init__(self, password = "******"):
        
        '''
        This constructor will create a password hash that can be
        used to verify user.
        '''

        if password: 
            passhash = hashlib.sha256(str(password)).hexdigest()

        else:
            passhash = hashlib.sha256("key").hexdigest()        

        self.passhash = passhash

        datetime.MINYEAR = 2016
        build_time = tuple(x for x in time.localtime()[0:5])
        
        self.creationtime = build_time
        self.last_post = build_time
        self.current_time = build_time

        #Eventually use self.hashlist as a way to merge IdeaPads.
        self.hashlist = ['END'] # Treat as a reverse queue: front is oldest.  Tail is youngest
        self.PAYABLE = False
        self.name = str(passhash)
    
        self.post_texts = PostDict.postdict()  
示例#29
0
文件: docgen.py 项目: Petzku/weechat
 def update(self, obj_name, num_files, num_files_updated):
     """Update doc file if needed (if content has changed)."""
     # close temp file
     self._file.close()
     # compute checksum on old file
     try:
         with open(self.filename, 'r') as _file:
             shaold = hashlib.sha256(_file.read()).hexdigest()
     except IOError:
         shaold = ''
     # compute checksum on new (temp) file
     try:
         with open(self.filename_tmp, 'r') as _file:
             shanew = hashlib.sha256(_file.read()).hexdigest()
     except IOError:
         shanew = ''
     # compare checksums
     if shaold != shanew:
         # update doc file
         if os.path.exists(self.filename):
             os.unlink(self.filename)
         os.rename(self.filename_tmp, self.filename)
         num_files_updated['total1'] += 1
         num_files_updated['total2'] += 1
         num_files_updated[obj_name] += 1
     else:
         os.unlink(self.filename_tmp)
     # update counters
     num_files['total1'] += 1
     num_files['total2'] += 1
     num_files[obj_name] += 1
示例#30
0
def verify_certificate(c, pc):
    # TODO: need a new way
    c_signature_algorithm = c['signature_algorithm']['algorithm'].dotted
    c_tbs_encoded = c['tbs_certificate'].dump()
    if c_signature_algorithm == '1.2.840.113549.1.1.4':  # RSA
        tbs_hash_hex = hashlib.md5(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.113549.1.1.5':
        tbs_hash_hex = hashlib.sha1(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.113549.1.1.11':
        tbs_hash_hex = hashlib.sha256(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.113549.1.1.12':
        tbs_hash_hex = hashlib.sha384(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.113549.1.1.13':
        tbs_hash_hex = hashlib.sha512(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.10040.4.3':  # DSA
        tbs_hash_hex = hashlib.sha1(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '2.16.840.1.101.3.4.3.2':
        tbs_hash_hex = hashlib.sha256(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.10045.4.1':  # ecdsa
        tbs_hash_hex = hashlib.sha1(c_tbs_encoded).hexdigest()
    elif c_signature_algorithm == '1.2.840.10045.4.3.2':
        tbs_hash_hex = hashlib.sha256(c_tbs_encoded).hexdigest()
    else:
        tbs_hash_hex = ''
    pub_key = pc.public_key
    return sig_verify(c.signature, pub_key, tbs_hash_hex)
示例#31
0
def _get_key(salt):
    """ Combines `settings.SECRET_KEY` with a salt. """
    if not salt: salt = ""
    
    return sha256("%s%s" % (settings.SECRET_KEY, salt)).digest()
示例#32
0
def password_encryption(password, salt=''):
    sha = hashlib.sha256()
    new_password = '******' + password + salt + '$%^'
    sha.update(new_password.encode('utf-8'))

    return sha.hexdigest()
def dict_to_tf_example(data, image_file, annotations_dir, label_map_dict, include_masks, ignore_difficult_instances):
    with tf.gfile.GFile(image_file, 'rb') as fid:
        encoded_jpg = fid.read()
    encoded_jpg_io = io.BytesIO(encoded_jpg)
    image = PIL.Image.open(encoded_jpg_io)
    if image.format != 'JPEG':
        raise ValueError('Image format not JPEG')
    key = hashlib.sha256(encoded_jpg).hexdigest()
    width = int(data['size']['width'])
    height = int(data['size']['height'])
    xmin = []
    ymin = []
    xmax = []
    ymax = []
    classes = []
    classes_text = []
    truncated = []
    poses = []
    difficult_obj = []
    masks = []
    if 'object' in data:
        for idx, obj in enumerate(data['object']):
            difficult = bool(int(obj['difficult']))
            if ignore_difficult_instances and difficult:
                continue
            class_id = getClassId(obj['name'], label_map_dict)
            if class_id < 0:
                continue
            difficult_obj.append(int(difficult))
            xmin.append(float(obj['bndbox']['xmin']) / width)
            ymin.append(float(obj['bndbox']['ymin']) / height)
            xmax.append(float(obj['bndbox']['xmax']) / width)
            ymax.append(float(obj['bndbox']['ymax']) / height)
            classes_text.append(obj['name'].encode('utf8'))
            classes.append(class_id)
            truncated.append(int(obj['truncated']))
            poses.append(obj['pose'].encode('utf8'))

            if include_masks:
                mask_path = os.path.join(annotations_dir, os.path.splitext(data['filename'])[0] + '_object' + str(idx) + '.png')
                with tf.gfile.GFile(mask_path, 'rb') as fid:
                    encoded_mask_png = fid.read()
                encoded_png_io = io.BytesIO(encoded_mask_png)
                mask = PIL.Image.open(encoded_png_io)
                if mask.format != 'PNG':
                    raise ValueError('Mask format not PNG')
                mask_np = np.asarray(mask)
                mask_remapped = (mask_np == 255).astype(np.uint8)
                masks.append(mask_remapped)
    feature_dict = {
        'image/height': dataset_util.int64_feature(height),
        'image/width': dataset_util.int64_feature(width),
        'image/filename': dataset_util.bytes_feature(
            data['filename'].encode('utf8')),
        'image/source_id': dataset_util.bytes_feature(
            data['filename'].encode('utf8')),
        'image/key/sha256': dataset_util.bytes_feature(key.encode('utf8')),
        'image/encoded': dataset_util.bytes_feature(encoded_jpg),
        'image/format': dataset_util.bytes_feature('jpeg'.encode('utf8')),
        'image/object/bbox/xmin': dataset_util.float_list_feature(xmin),
        'image/object/bbox/xmax': dataset_util.float_list_feature(xmax),
        'image/object/bbox/ymin': dataset_util.float_list_feature(ymin),
        'image/object/bbox/ymax': dataset_util.float_list_feature(ymax),
        'image/object/class/text': dataset_util.bytes_list_feature(classes_text),
        'image/object/class/label': dataset_util.int64_list_feature(classes),
        'image/object/difficult': dataset_util.int64_list_feature(difficult_obj),
        'image/object/truncated': dataset_util.int64_list_feature(truncated),
        'image/object/view': dataset_util.bytes_list_feature(poses),
    }

    if include_masks:
        encoded_mask_png_list = []
        for mask in masks:
            img = PIL.Image.fromarray(mask)
            output = io.BytesIO()
            img.save(output, format='PNG')
            encoded_mask_png_list.append(output.getvalue())
        feature_dict['image/object/mask'] = (dataset_util.bytes_list_feature(encoded_mask_png_list))
    example = tf.train.Example(features=tf.train.Features(feature=feature_dict))
    return example
示例#34
0
def _aws_headers(service, access_key_id, secret_access_key, region, host,
                 method, path, query, pre_auth_headers, payload):
    algorithm = 'AWS4-HMAC-SHA256'

    now = datetime.datetime.utcnow()
    amzdate = now.strftime('%Y%m%dT%H%M%SZ')
    datestamp = now.strftime('%Y%m%d')
    credential_scope = f'{datestamp}/{region}/{service}/aws4_request'
    headers_lower = {
        header_key.lower().strip(): header_value.strip()
        for header_key, header_value in pre_auth_headers.items()
    }
    required_headers = ['host', 'x-amz-content-sha256', 'x-amz-date']
    signed_header_keys = sorted(
        [header_key for header_key in headers_lower.keys()] + required_headers)
    signed_headers = ';'.join(signed_header_keys)
    payload_hash = hashlib.sha256(payload).hexdigest()

    def signature():
        def canonical_request():
            header_values = {
                **headers_lower,
                'host': host,
                'x-amz-content-sha256': payload_hash,
                'x-amz-date': amzdate,
            }

            canonical_uri = urllib.parse.quote(path, safe='/~')
            query_keys = sorted(query.keys())
            canonical_querystring = '&'.join([
                urllib.parse.quote(key, safe='~') + '=' +
                urllib.parse.quote(query[key], safe='~') for key in query_keys
            ])
            canonical_headers = ''.join([
                header_key + ':' + header_values[header_key] + '\n'
                for header_key in signed_header_keys
            ])

            return f'{method}\n{canonical_uri}\n{canonical_querystring}\n' + \
                   f'{canonical_headers}\n{signed_headers}\n{payload_hash}'

        def sign(key, msg):
            return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()

        string_to_sign = \
            f'{algorithm}\n{amzdate}\n{credential_scope}\n' + \
            hashlib.sha256(canonical_request().encode('utf-8')).hexdigest()

        date_key = sign(('AWS4' + secret_access_key).encode('utf-8'),
                        datestamp)
        region_key = sign(date_key, region)
        service_key = sign(region_key, service)
        request_key = sign(service_key, 'aws4_request')
        return sign(request_key, string_to_sign).hex()

    return {
        **pre_auth_headers,
        'x-amz-date':
        amzdate,
        'x-amz-content-sha256':
        payload_hash,
        'Authorization':
        (f'{algorithm} Credential={access_key_id}/{credential_scope}, ' +
         f'SignedHeaders={signed_headers}, Signature=' + signature()),
    }
示例#35
0
import hashlib
import xlrd
import numpy as np
from passlib.hash import scrypt
import scrypt as sc

h1 = sc.hash('password',"r")
print("h1",h1)
print("int",int.from_bytes(h1, byteorder='little', signed=True))

m = hashlib.sha256()
m.update("password".encode('utf-8'))
print(int(m.hexdigest(), 16))

m = hashlib.sha3_256()
m.update("password".encode('utf-8'))
print(int(m.hexdigest(), 16))
示例#36
0
def khash(data):
    '''Single place to change hashes of attachments'''
    return hashlib.sha256(data.encode('ascii')).hexdigest()
示例#37
0
from hashlib import sha256

x = 5
y = 0 # TBD

while sha256(f'{x*y}'.encode()).hexdigest()[-1] != '0':
    y += 1

    print(f'The solution is y = {y}')
示例#38
0
 def hash(self):
     print(json.dumps(self.data))
     return hashlib.sha256( (self.timestamp+ str(self.nonce) + json.dumps(self.data)+self.previous_hash).encode()).hexdigest()
示例#39
0
def verify_aws_secret_access_key(key, secret):  # pragma: no cover
    """
    Using requests, because we don't want to require boto3 for this one
    optional verification step.

    Loosely based off:
    https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html

    :type key: str
    :type secret: str
    """
    now = datetime.utcnow()
    amazon_datetime = now.strftime('%Y%m%dT%H%M%SZ')

    headers = {
        # This is a required header for the signing process
        'Host': 'sts.amazonaws.com',
        'X-Amz-Date': amazon_datetime,
    }
    body = {
        'Action': 'GetCallerIdentity',
        'Version': '2011-06-15',
    }

    # Step #1: Canonical Request
    signed_headers = ';'.join(
        map(
            lambda x: x.lower(),
            headers.keys(),
        ),
    )
    canonical_request = textwrap.dedent("""
        POST
        /

        {headers}

        {signed_headers}
        {hashed_payload}
    """)[1:-1].format(

        headers='\n'.join([
            '{}:{}'.format(header.lower(), value)
            for header, value in headers.items()
        ]),
        signed_headers=signed_headers,

        # Poor man's method, but works for this use case.
        hashed_payload=hashlib.sha256(
            '&'.join([
                '{}={}'.format(header, value)
                for header, value in body.items()
            ]).encode('utf-8'),
        ).hexdigest(),
    )

    # Step #2: String to Sign
    region = 'us-east-1'
    scope = '{request_date}/{region}/sts/aws4_request'.format(
        request_date=now.strftime('%Y%m%d'),

        # STS is a global service; this is just for latency control.
        region=region,
    )

    string_to_sign = textwrap.dedent("""
        AWS4-HMAC-SHA256
        {request_datetime}
        {scope}
        {hashed_canonical_request}
    """)[1:-1].format(
        request_datetime=amazon_datetime,
        scope=scope,
        hashed_canonical_request=hashlib.sha256(
            canonical_request.encode('utf-8'),
        ).hexdigest(),
    )

    # Step #3: Calculate signature
    signing_key = _sign(
        _sign(
            _sign(
                _sign(
                    'AWS4{}'.format(secret).encode('utf-8'),
                    now.strftime('%Y%m%d'),
                ),
                region,
            ),
            'sts',
        ),
        'aws4_request',
    )

    signature = _sign(
        signing_key,
        string_to_sign,
        hex=True,
    )

    # Step #4: Add to request headers
    headers['Authorization'] = (
        'AWS4-HMAC-SHA256 '
        'Credential={access_key}/{scope}, '
        'SignedHeaders={signed_headers}, '
        'Signature={signature}'
    ).format(
        access_key=key,
        scope=scope,
        signed_headers=signed_headers,
        signature=signature,
    )

    # Step #5: Finally send the request
    response = requests.post(
        'https://sts.amazonaws.com',
        headers=headers,
        data=body,
    )

    if response.status_code == 403:
        return False

    return True
示例#40
0
 def generate_genesis():
     hash = hashlib.sha256(str('Today'+str(0)+ json.dumps('data') + 'xyz').encode()).hexdigest()
     return Block('Today' ,0, 'data' , hash , 'xyz')
示例#41
0
 def H(x):
     return sha256(x).digest()
示例#42
0
    def redirect_payfort(self, **post):
        """
        create payfort payment link and
        redirect to Payfort Page.
        -------------------------------
        :return: redirect to payfort payment getway page.
        """
        #----------------new code---------------------
        currency = 'AED'
        #----------------new code---------------------
        env = request.env(user=SUPERUSER_ID)
        user_id = 1
        if user_id:
            res_user_obj = env['res.users']
            res_user_obj_rec = res_user_obj.sudo().search(
                [('id', '=', user_id)], limit=1)
            #----------------new code---------------------
            currency = str(res_user_obj_rec.company_id.currency_id.name)
            #----------------new code---------------------
        payfort_conf_obj = env['payfort.config']
        payfort_conf_rec = payfort_conf_obj.sudo().search(
            [('active', '=', 'True')], limit=1)
        if payfort_conf_rec.id:
            order_id = str(post.get('ORDERID'))
            total_amount = float(post.get('AMOUNT')) or 0.00
            payment_method = str(post.get('payment_method'))

            #------------------------get partner email------------------------------#
            reg_ids = env['registration'].sudo().search([
                ('registration_number', '=', order_id)
            ])
            invoice_ids = env['account.invoice'].sudo().search(
                [('invoice_number', '=', order_id)], limit=1)
            voucher_rec = env['account.voucher'].sudo().search(
                [('payfort_type', '=', True),
                 ('voucher_number', '=', order_id)],
                limit=1)
            next_year_advance_fee_rec = env['next.year.advance.fee'].sudo(
            ).search([('order_id', '=', order_id)])
            re_registration_parent_rec = env[
                're.reg.waiting.responce.parents'].sudo().search(
                    [('re_registration_number', '=', order_id)], limit=1)
            tc_student_rec = env['trensfer.certificate'].sudo().search(
                [('transfer_certificate_number', '=', order_id)], limit=1)
            #                                                                                           limit=1)
            customer_email = False
            if len(reg_ids) > 0:
                customer_email = reg_ids.parent_email
            elif len(invoice_ids) > 0:
                customer_email = invoice_ids.partner_id.email
            elif len(voucher_rec) > 0:
                customer_email = voucher_rec.partner_id.parents_email
            elif len(next_year_advance_fee_rec) > 0:
                customer_email = next_year_advance_fee_rec.partner_id.email

            elif len(tc_student_rec) > 0:
                customer_email = tc_student_rec.name.email
            elif len(re_registration_parent_rec) > 0:
                customer_email = re_registration_parent_rec.name.parents_email
            #------------------------get partner email------------------------------#

            #------------------------calculate payfort charge-----------------------#
            amount = 0.00
            payfort_charge_amount = 0
            payfort_transaction_charge = 0
            payfort_url = payfort_conf_rec.payfort_url
            payfort_bank_charge = 0
            access_code = str(payfort_conf_rec.access_code)
            merchant_identifier = str(payfort_conf_rec.merchant_identifier)
            return_url = str(payfort_conf_rec.return_url)
            language = str(payfort_conf_rec.language)
            if payfort_conf_rec.id and payfort_conf_rec.charge > 0:
                payfort_charge_amount = (total_amount /
                                         100) * payfort_conf_rec.charge
            if payfort_conf_rec.transaction_charg_amount > 0.00:
                payfort_transaction_charge = payfort_conf_rec.transaction_charg_amount


#             if payfort_conf_rec.id and payfort_conf_rec.bank_service_charge > 0:
#                 payfort_bank_charge = (total_amount / 100 )  * payfort_conf_rec.bank_service_charge
            total_payfort_charge = payfort_charge_amount + payfort_transaction_charge + payfort_bank_charge
            #------------------------calculate payfort charge-----------------------#

            #------------------------add payfort charge in amount-------------------#
            total_payable_amount = total_amount + total_payfort_charge
            total_net_amount = round(total_payable_amount)
            amount = int(total_net_amount * 100)
            #------------------------add payfort charge in amount-------------------#

            #----------------Redirection to sbcheckout page-------------------------#
            command = "PURCHASE"
            cart_details = '{"cart_items":[{"item_name":"Xbox360","item_description":"Xbox","item_quantity":"1","item_price":"300","item_image":"http://image.com"}],"sub_total":"300"}'
            #
            if payment_method == 'MASTERPASS':
                digital_wallet = payment_method
                message = 'TESTSHAINaccess_code=%samount=%scart_details=%scommand=%scurrency=%scustomer_email=%sdigital_wallet=%slanguage=%smerchant_identifier=%smerchant_reference=%sreturn_url=%sTESTSHAIN' % (
                    access_code, amount, cart_details, command, currency,
                    customer_email, digital_wallet, language,
                    merchant_identifier, order_id, return_url)
                signature = hashlib.sha256(message)
                return """
                                                  <html>
                                                      <body>
                                                      <form action=%s method='post' id="payu" name="payu">
                                                          <input type="hidden" name="access_code" value="%s" />
                                                          <input type="hidden" name="amount" value="%s" />
                                                          <input type="hidden" name="cart_details" value='{"cart_items":[{"item_name":"Xbox360","item_description":"Xbox","item_quantity":"1","item_price":"300","item_image":"http://image.com"}],"sub_total":"300"}'/>
                                                          <input type="hidden" name="command" value="%s" />
                                                          <input type="hidden" name="currency" value="%s" />
                                                          <input type="hidden" name="customer_email" value ="%s" />
                                                          <input type="hidden" name="digital_wallet" value ="%s" />
                                                          <input type="hidden" name="language" value="%s" />
                                                          <input type="hidden" name="merchant_identifier" value="%s" />
                                                          <input type="hidden" name="merchant_reference" value="%s" />
                                                          <input type="hidden" name="return_url" value="%s" />
                                                          <input type="hidden" name="signature" value="%s" />
                                                      </form>
                                                      </body>
                                                      <script type='text/javascript'>
                                                       window.onload = function(){
                                                       document.forms['payu'].submit()
                                                      }
                                                      </script>
                                                  </html>
      
                                              """ % (
                    payfort_url, access_code, amount, command, currency,
                    customer_email, digital_wallet, language,
                    merchant_identifier, order_id, return_url,
                    signature.hexdigest())

            if payment_method == 'VISA_CHECKOUT':
                digital_wallet = payment_method
                message = 'TESTSHAINaccess_code=%samount=%scommand=%scurrency=%scustomer_email=%sdigital_wallet=%slanguage=%smerchant_identifier=%smerchant_reference=%sreturn_url=%sTESTSHAIN' % (
                    access_code, amount, command, currency, customer_email,
                    digital_wallet, language, merchant_identifier, order_id,
                    return_url)
                signature = hashlib.sha256(message)
                #                 cart_details = json.dumps(cart_details)
                return """
                                                  <html>
                                                      <body>
                                                      <form action=%s method='post' id="payu" name="payu">
                                                          <input type="hidden" name="access_code" value="%s" />
                                                          <input type="hidden" name="amount" value="%s" />
                                                          <input type="hidden" name="command" value="%s" />
                                                          <input type="hidden" name="currency" value="%s" />
                                                          <input type="hidden" name="customer_email" value ="%s" />
                                                          <input type="hidden" name="digital_wallet" value ="%s" />
                                                          <input type="hidden" name="language" value="%s" />
                                                          <input type="hidden" name="merchant_identifier" value="%s" />
                                                          <input type="hidden" name="merchant_reference" value="%s" />
                                                          <input type="hidden" name="return_url" value="%s" />
                                                          <input type="hidden" name="signature" value="%s" />
                                                      </form>
                                                      </body>
                                                      <script type='text/javascript'>
                                                       window.onload = function(){
                                                       document.forms['payu'].submit()
                                                      }
                                                      </script>
                                                  </html>
      
                                              """ % (
                    payfort_url, access_code, amount, command, currency,
                    customer_email, digital_wallet, language,
                    merchant_identifier, order_id, return_url,
                    signature.hexdigest())

            if payment_method == 'CREDIT_CARD':
                message = 'TESTSHAINaccess_code=%samount=%scommand=%scurrency=%scustomer_email=%slanguage=%smerchant_identifier=%smerchant_reference=%sreturn_url=%sTESTSHAIN' % (
                    access_code, amount, command, currency, customer_email,
                    language, merchant_identifier, order_id, return_url)
                signature = hashlib.sha256(message)
                return """
                                                  <html>
                                                      <body>
                                                      <form action=%s method='post' id="payu" name="payu">
                                                          <input type="hidden" name="access_code" value="%s" />
                                                          <input type="hidden" name="amount" value="%s" />
                                                          <input type="hidden" name="command" value="%s" />
                                                          <input type="hidden" name="currency" value="%s" />
                                                          <input type="hidden" name="customer_email" value ="%s" />
                                                          <input type="hidden" name="language" value="%s" />
                                                          <input type="hidden" name="merchant_identifier" value="%s" />
                                                          <input type="hidden" name="merchant_reference" value="%s" />
                                                          <input type="hidden" name="return_url" value="%s" />
                                                          <input type="hidden" name="signature" value="%s" />
                                                      </form>
                                                      </body>
                                                      <script type='text/javascript'>
                                                       window.onload = function(){
                                                       document.forms['payu'].submit()
                                                      }
                                                      </script>
                                                  </html>
                                              """ % (
                    payfort_url, access_code, amount, command, currency,
                    customer_email, language, merchant_identifier, order_id,
                    return_url, signature.hexdigest())
示例#43
0
def list_hash(lst):
    return hashlib.sha256(json.dumps(list(lst),
                                     sort_keys=True).encode()).hexdigest()
 def get_SHA256(string):
     """
     Compute the SHA256 signature of a string.
     """
     return hashlib.sha256(string.encode("utf-8")).hexdigest()
示例#45
0
def get_file_sha256(binary: AnyPath):
    """Hash a binary with the SHA-256 algorithm."""
    # This doesn't do any sort of buffering; but our binaries are pretty small
    # in comparison to what we're storing as metadata, anyway
    with open(binary, "rb") as fp:
        return hashlib.sha256(fp.read()).hexdigest()
示例#46
0
        hasher.update(block)
    return hasher.hexdigest() if ashexstr else hasher.digest()

def file_as_blockiter(afile, blocksize=65536):
    with afile:
        block = afile.read(blocksize)
        while len(block) > 0:
            yield block
            block = afile.read(blocksize)

resources_file = {}
resources_array = []

for filename in glob.iglob(work_dir + '**/*', recursive=True):
    if os.path.isfile(filename):
        hexSha256Half = hash_bytestr_iter(file_as_blockiter(open(os.path.abspath(filename), 'rb')), hashlib.sha256(), True)[:16]
        item = {}
        item['id'] = os.path.relpath(filename, root_dir).replace(os.sep, '_').split('.')[0]
        item['path'] = os.path.relpath(filename, root_dir)
        item['checksum']=hexSha256Half
        resources_array.append(item)
        print(item)

resources_file['data'] = resources_array
hasher = hashlib.sha256()
hasher.update(json.dumps(resources_array, sort_keys=True).encode('utf-8'))
resources_file['checksum'] = hasher.hexdigest()[:16]

with open(os.path.join(result_dir, "description.json"), 'wt') as destFile:
    destFile.write(json.dumps(resources_file, sort_keys=True))
示例#47
0
 def get_hash(self):
     new_hash = str(self.index)+str(self.previous_hash)+str(self.timestamp)+str(self.transactions)
     return str(hashlib.sha256(new_hash.encode('utf-8')).hexdigest())        
示例#48
0
def bootstrap_dependency(settings, url, hash_, priority, version, on_complete):
    """
    Downloads a dependency from a hard-coded URL - only used for bootstrapping _ssl
    on Linux and ST2/Windows

    :param settings:
        Package Control settings

    :param url:
        The non-secure URL to download from

    :param hash_:
        The sha256 hash of the package file

    :param version:
        The version number of the package

    :param priority:
        A three-digit number that controls what order packages are
        injected in

    :param on_complete:
        A callback to be run in the main Sublime thread, so it can use the API
    """

    package_filename = path.basename(urlparse(url).path)
    package_basename, _ = path.splitext(package_filename)

    package_dir = path.join(sys_path.packages_path, package_basename)

    version = SemVer(version)

    # The package has already been installed. Don't reinstall unless we have
    # a newer version.
    if path.exists(package_dir) and loader.exists(package_basename):
        try:
            dep_metadata_path = path.join(package_dir, 'dependency-metadata.json')
            with open_compat(dep_metadata_path, 'r') as f:
                metadata = json.loads(read_compat(f))
            old_version = SemVer(metadata['version'])
            if version <= old_version:
                sublime.set_timeout(mark_bootstrapped, 10)
                return

            console_write(
                u'''
                Upgrading bootstrapped dependency %s to %s from %s
                ''',
                (package_basename, version, old_version)
            )

        except (KeyError, FileNotFoundError):
            # If we can't determine the old version, install the new one
            pass

    with downloader(url, settings) as manager:
        try:
            console_write(
                u'''
                Downloading bootstrapped dependency %s
                ''',
                package_basename
            )
            data = manager.fetch(url, 'Error downloading bootstrapped dependency %s.' % package_basename)
            console_write(
                u'''
                Successfully downloaded bootstraped dependency %s
                ''',
                package_basename
            )
            data_io = BytesIO(data)

        except (DownloaderException) as e:
            console_write(e)
            return

    data_hash = hashlib.sha256(data).hexdigest()
    if data_hash != hash_:
        console_write(
            u'''
            Error validating bootstrapped dependency %s (got %s instead of %s)
            ''',
            (package_basename, data_hash, hash_)
        )
        return

    try:
        data_zip = zipfile.ZipFile(data_io, 'r')
    except (zipfile.BadZipfile):
        console_write(
            u'''
            Error unzipping bootstrapped dependency %s
            ''',
            package_filename
        )
        return

    if not path.exists(package_dir):
        os.makedirs(package_dir, 0o755)
    else:
        clear_directory(package_dir)

    code = None
    for zip_path in data_zip.namelist():
        dest = zip_path

        if not isinstance(dest, str_cls):
            dest = dest.decode('utf-8', 'strict')

        dest = dest.replace('\\', '/')

        # loader.py is included for backwards compatibility. New code should use
        # loader.code with Python inside of it. We no longer use loader.py since
        # we can't have any files ending in .py in the root of a package,
        # otherwise Sublime Text loads it as a plugin and then the dependency
        # path added to sys.path and the package path loaded by Sublime Text
        # conflict and there will be errors when Sublime Text tries to
        # initialize plugins. By using loader.code, developers can git clone a
        # dependency into their Packages folder without issue.
        if dest in set([u'loader.py', u'loader.code']):
            code = data_zip.read(zip_path).decode('utf-8')
            if dest == u'loader.py':
                continue

        dest = path.join(package_dir, dest)

        if dest[-1] == '/':
            if not path.exists(dest):
                os.makedirs(dest, 0o755)
        else:
            dest_dir = path.dirname(dest)
            if not path.exists(dest_dir):
                os.makedirs(dest_dir, 0o755)

            with open(dest, 'wb') as f:
                f.write(data_zip.read(zip_path))

    data_zip.close()

    loader.add_or_update(priority, package_basename, code)

    console_write(
        u'''
        Successfully installed bootstrapped dependency %s
        ''',
        package_basename
    )

    sublime.set_timeout(mark_bootstrapped, 10)
    if on_complete:
        sublime.set_timeout(on_complete, 100)
示例#49
0
文件: session.py 项目: zhill/yosai
 def generate_session_id(self):
     """
     :param session: the new session instance for which an ID will be
                     generated and then assigned
     """
     return sha256(sha512(urandom(20)).digest()).hexdigest()
示例#50
0
def get_bytes_sha256(contents: bytes):
    """Hash a byte string with the SHA-256 algorithm."""
    return hashlib.sha256(contents).hexdigest()
示例#51
0
    # Step 4: Create the canonical headers and signed headers. Header names
    # must be trimmed and lowercase, and sorted in code point order from
    # low to high. Note that there is a trailing \n.
    canonical_headers = 'host:' + host + '\n' + 'x-amz-date:' + amzdate + '\n'

    # Step 5: Create the list of signed headers. This lists the headers
    # in the canonical_headers list, delimited with ";" and in alpha order.
    # Note: The request can include any headers; canonical_headers and
    # signed_headers lists those that you want to be included in the
    # hash of the request. "Host" and "x-amz-date" are always required.
    signed_headers = 'host;x-amz-date'

    # Step 6: Create payload hash (hash of the request body content). For GET
    # requests, the payload is an empty string ("").
    payload_hash = hashlib.sha256(('').encode('utf-8')).hexdigest()

    # Step 7: Combine elements to create canonical request
    canonical_request = method + '\n' + canonical_uri + '\n' + canonical_querystring + '\n' + canonical_headers + '\n' + signed_headers + '\n' + payload_hash

    # ************* TASK 2: CREATE THE STRING TO SIGN*************
    # Match the algorithm to the hashing algorithm you use, either SHA-1 or
    # SHA-256 (recommended)
    algorithm = 'AWS4-HMAC-SHA256'
    credential_scope = datestamp + '/' + region + '/' + service + '/' + 'aws4_request'
    string_to_sign = algorithm + '\n' + amzdate + '\n' + credential_scope + '\n' + hashlib.sha256(
        canonical_request.encode('utf-8')).hexdigest()

    # ************* TASK 3: CALCULATE THE SIGNATURE *************
    # Create the signing key using the function defined above.
    signing_key = getSignatureKey(secret_key, datestamp, region, service)
示例#52
0
文件: ex3.py 项目: gdincu/courses
def sha256(msg):
  return int(hashlib.sha256(msg.encode('utf-8')).hexdigest(), 16)
示例#53
0
文件: auth.py 项目: og3niuz/LKLCTF19
def hash_password(password):
    return hashlib.sha256(password.encode()).hexdigest()
示例#54
0
# add inside this flag at random bytes for each chal
for i in chals:
    regex_done = False

    # we calculate the location of the identifying bytes
    salt_chal = small_hash(i + SECRET)
    salts = []
    for z in range(0, 4):
        salts = add_salt(salts, salt_chal[z] % 32)

    for y in team_names:
        uni_hash = small_hash(i + y + SECRET)
        # make it a bit harder to guess the format of the sha2
        chal_name = i + SECRET
        hash_final = bytearray(
            bytes.fromhex(hashlib.sha256(chal_name.encode()).hexdigest()))
        # we replace by the identifying bytes
        hash_final[salts[0]] = uni_hash[0]
        hash_final[salts[1]] = uni_hash[1]
        hash_final[salts[2]] = uni_hash[2]
        hash_final[salts[3]] = uni_hash[3]
        hash_final_str = hash_final.hex()
        uni_bytes.append([
            salts[0], uni_hash[0], salts[1], uni_hash[1], salts[2],
            uni_hash[2], salts[3], uni_hash[3], y, i
        ])
        flag = "GY{" + hash_final_str + "}"
        flags.append([y, flag])

for i in submissions:
    found_flag = False
示例#55
0
def hash256(byte_str):
    sha256 = hashlib.sha256()
    sha256.update(byte_str)
    sha256d = hashlib.sha256()
    sha256d.update(sha256.digest())
    return sha256d.digest()[::-1]
示例#56
0
def path_key(path):
    return sha256(as_bytes(path)).hexdigest()
示例#57
0
from __future__ import print_function
import base64
import os
import hashlib
import struct

password = '******'

salt = os.urandom(4)

tmp0 = salt + password.encode('utf-8')

tmp1 = hashlib.sha256(tmp0).digest()

salted_hash = salt + tmp1

pass_hash = base64.b64encode(salted_hash)

print(pass_hash)
示例#58
0
 def deriveChecksum(self, s):
     """ Derive the checksum
     """
     checksum = hashlib.sha256(compat_bytes(s, "ascii")).hexdigest()
     return checksum[:4]
示例#59
0
def commit(winning_door, witness):
    m = sha256()
    m.update(u.zpad(u.encode_int(winning_door), 1))
    m.update(witness)
    return m.digest()
示例#60
0
 def hash(self) -> str:
     return hashlib.sha256(self.serialize()).hexdigest()