def ver_Signature(): ######## Receive Public key from Authenticator ########## auth_public_key = RSA.importKey(open('auth_public_key.pem').read()) ###### Receive Signature from Authenticator ####### #open signature file with open("signature.txt", "rb") as f: signature = f.read() #Decrypt the ballot dec_ballot = dec_Ballot() #create hash of the decrypted ballot hash = SHA256.new(dec_ballot) ##################### VERIFYING SIGNATURE ################################ verifier = PKCS115_SigScheme(auth_public_key) try: verifier.verify(hash, signature) print("Signature is valid.") return True except: print("Signature is invalid.") return False
def __getSignature(self, byteString): hashValue = SHA256.new(byteString) signer = PKCS115_SigScheme(self.privateKey) signatureByte = signer.sign(hashValue) signatureStr = binascii.hexlify(signatureByte).decode('utf-8') log.debug(f'signature is {signatureStr}') return signatureStr
def firmar(document): signature = "" if len(document) > 0: hash = SHA256.new(bytes(document, 'utf-8')) signer = PKCS115_SigScheme(keyPair) signature = signer.sign(hash).hex() return signature
def sigGenerator(sender_keyPair, sender_passphrase, file="", string=""): # Opening and reading file to encrypt buffer = string #print("String before hash ") #print(buffer.encode()) # Creating hash of the file. Using SHA-256 (SHA-512 rose problems) h = SHA256.new(buffer.encode()) # Reading private key to sign file with f = open(sender_keyPair, "rb") keyPair = RSA.importKey(f.read(), passphrase=sender_passphrase) f.close() #key = RSA.importKey(open("public.pem", "rb")) keySigner = PKCS115_SigScheme(keyPair) #print ( h.hexdigest()) # Saving signature to *.sig file sign = keySigner.sign(h) #print(sign) if file == "": file = upload + "email.txt" else: file = upload + file #print(sign) f = open(file.split('.')[0] + ".sig", "wb") f.write(sign) f.close()
def results(): # Publish results from election on CLI decrypted_vote_state = file_decrypt("vote.state").decode().replace("\n", ";") votes_emeri = decrypted_vote_state.count("EK") votes_frans = decrypted_vote_state.count("FS") votes_tim = decrypted_vote_state.count("TK") print("EK: " + str(votes_emeri) + "\nFS: " + str(votes_frans) + "\nTK: " + str(votes_tim)) # Publish results in result.txt result = ("EK: " + str(votes_emeri) + "\nFS: " + str(votes_frans) + "\nTK: " + str(votes_tim)).encode() with open('*****@*****.**', 'r') as f: key = RSA.importKey(f.read()) f.close() h = SHA256.new(result) signer = PKCS115_SigScheme(key) signature = signer.sign(h) with open("signature.sign", 'wb') as h: h.write(signature) h.close() with open("results.txt", 'w') as i: i.write(result.decode()) i.close() # create recountable file recount_file() # delete temp voter file after results delete(arg="results")
def Process(self, orange, processName, data): # 构建数据区块 b = Block() b.prevBlock = orange.identity b.processName = processName b.factoryName = self.name b.data = data # 获取前一区块的标识 prevSignedStr = b.prevBlock[256:] prevSignedBytes = binascii.unhexlify(prevSignedStr) # 生成待签名的数据 blockJson = json.dumps(b.__dict__).encode('utf-8') data = prevSignedBytes + blockJson # 数据签名 hashData = SHA256.new(data) # 哈希压缩数据 signer = PKCS115_SigScheme(self.keyPair) signature = signer.sign(hashData) signatureStr = ''.join(format(x, '02x') for x in signature) # 更新标识并添加数据区块 orange.identity = prevSignedStr + signatureStr orange.blockData.append(b) return orange
def sigInput(): global signature msg = plaintxt.get() msg1 = str.encode(msg) hash = SHA256.new(msg1) signer = PKCS115_SigScheme(keyPair) signature = signer.sign(hash) resulttxt2.insert(INSERT, binascii.hexlify(signature))
def rsa_verify(msg, signature, pubKey): h = SHA256.new(msg) verifier = PKCS115_SigScheme(pubKey) try: verifier.verify(h, signature) return "valid" except: return "invalid"
def verify_signature(signature, pubKey, msg): hash = SHA256.new(msg) verifier = PKCS115_SigScheme(pubKey) try: verifier.verify(hash, signature) return 1 except: return 0
def check_sign_rsa(key: RsaKey, signed_data: bytes, data: bytes) -> bool: verifier = PKCS115_SigScheme(key) try: # noinspection PyTypeChecker verifier.verify(SHA256.new(data), b64decode(signed_data)) return True except ValueError: return False
def encrypt_pgp(self, data: bytes, public_key: RsaKey) -> bytes: session_key = self.generate_session_key() encrypted_data = self.encrypt_aes(data, session_key) encrypted_session_key = self.encrypt_rsa(session_key, public_key) # noinspection PyTypeChecker signature = PKCS115_SigScheme(self.__private_key).sign( SHA256.new(data)) return encrypted_session_key + signature + encrypted_data
def verify(message, signature): hash = SHA256.new(message) signer = PKCS115_SigScheme(public_key) print("Signature:", binascii.hexlify(signature)) try: signer.verify(hash, signature) print("Signature is valid.") except: print("Signature is invalid.")
def create_Signature(vote): # Sign the ballot using authenticator's private key auth_private_key = RSA.importKey(open('auth_private_key.pem').read()) ballot = vote.encode("utf-8") hash1 = SHA256.new(ballot) signer = PKCS115_SigScheme(auth_private_key) signature = signer.sign(hash1) with open("signature.txt", "wb") as f: f.write(signature)
def sign(self, data): """ Sign given data with RSA :param str data: data to be signed :return: signed data """ scheme = PKCS115_SigScheme(self._private_key) if scheme.can_sign(): return scheme.sign(SHA256.new(data)) raise RuntimeError("Cannot sign data")
def check_authenticator(self, key: RsaKey, authenticator: str) -> bool: msg = str(round(time.time()))[:-1] hash = SHA256.new(msg.encode()) verifier = PKCS115_SigScheme(key) try: verifier.verify(hash, b64decode(authenticator)) return True except ValueError: return False
def verifyPost(hashedTransaction, signature): # verifier = DSS.new(publicKey, 'fips-186-3') verifier = PKCS115_SigScheme(publicKey) try: verifier.verify(hashedTransaction, signature) print("The post is authentic") return True except ValueError: print("The post is NOT authentic") return False
def validate_signature(self, msg, signature, signing_public_key=None): signing_public_key = self.public_key if signing_public_key is None else signing_public_key if isinstance(signing_public_key, str): signing_public_key = self.get_key_from_str(signing_public_key) msg_hash = self.get_msg_hash(msg) try: PKCS115_SigScheme(signing_public_key).verify(msg_hash, signature) return True except: return False
def create_Signature(): #Sign the ballot using authenticator's private key auth_private_key = RSA.importKey(open('auth_private_key.pem').read()) ballot = b'This is Ballot' hash = SHA256.new(ballot) signer = PKCS115_SigScheme(auth_private_key) signature = signer.sign(hash) with open("signature.txt", "wb") as f: f.write(signature)
def sign(priv_key, msg) -> str: if isinstance(msg, str): msg = msg.encode('utf8') elif not isinstance(msg, bytes): raise ValueError hash = SHA256.new(msg) signer = PKCS115_SigScheme(priv_key) signature = signer.sign(hash) return b64encode(signature)
def verifySignature(filename, signature): file = open(filename, 'r') filedata = file.read() hash = SHA256.new(bytes(filedata.encode())) verifier = PKCS115_SigScheme(pubKey) try: verifier.verify(hash, signature) print("Signature is valid.") except: print("Signature is invalid.")
def sign_hash(h, node_id): file_priv = str(node_id) + "-private.pem" if not os.path.exists(file_priv): return None f = open(file_priv, 'r') priv_key = RSA.import_key(f.read()) # Read private key from file signer = PKCS115_SigScheme(priv_key) signature = signer.sign(h) f.close() return signature
def generateSignature(filename): file = open(filename, 'r') filedata = file.read() hash = SHA256.new(bytes(filedata.encode())) scheme = PKCS115_SigScheme(keyPair) signature = scheme.sign(hash) file = open('RSA_signature.txt', 'r+') file.write(str(signature)) print("Signature:", binascii.hexlify(signature)) return signature
def sign_message(msg, KeyPair): hash = SHA256.new(msg) signer = PKCS115_SigScheme(KeyPair) signature = signer.sign(hash) print "Signature" print "-----------------------------------------------------------------" print binascii.hexlify(signature) print print return signature
def sign(message): hash = SHA256.new(message) signer = PKCS115_SigScheme(private_key) signature = signer.sign(hash) print("hash: ", hash.hexdigest()) print("Signature:", binascii.hexlify(signature)) fo = open(filename + ".sig", 'wb') fo.write(signature) fo.close()
def verificar(): dict_document = request.json msg = bytes(dict_document['documento'], 'utf-8') signature_bytes = bytes.fromhex(dict_document['firma']) hash = SHA256.new(msg) verifier = PKCS115_SigScheme(pubKey) try: verifier.verify(hash, signature_bytes) return "Signature is valid." except: return "Signature is invalid."
def verificar(document,signature): if len(document) > 0 and len(signature) >0: msg = bytes(document, 'utf-8') signature_bytes = bytes.fromhex(signature) hash = SHA256.new(msg) verifier = PKCS115_SigScheme(pubKey) try: verifier.verify(hash, signature_bytes) return "Signature is valid." except: return "Signature is invalid."
def verify_sig(hc, signature, node_id): file_pub = str(node_id) + "-public.pem" if not os.path.exists(file_pub): raise Exception("Public key does not exist") f = open(file_pub, 'r') try: pub_key = RSA.import_key(f.read()) # Read public key from file f.close() signer = PKCS115_SigScheme(pub_key) signer.verify(hc, signature) except: raise Exception("Signature failed, integrity and/or signature value was not upheld")
def verify(signature): with open('authkeys.pem', 'r') as f: key = RSA.import_key(f.read()) if not isByte(signature): signature = binascii.unhexlify(signature) hash = SHA256.new(b'cryptobankapi') verifier = PKCS115_SigScheme(key.publickey()) try: verifier.verify(hash, signature) return True except: return False
def verify_sign(self, msg, signature, pub_key=None): if pub_key is None: pub_key = self.pubKey is_valid = True hashed_msg = SHA256.new(msg) verifier = PKCS115_SigScheme(pub_key) try: verifier.verify(hashed_msg, signature) except ValueError: is_valid = False return is_valid
def __verifySignature(self, signature, byteString): hashValue = SHA256.new(msg) isVerified = False verifier = PKCS115_SigScheme(pubKey) try: verifier.verify(hashValue, signature) log.debug("Signature is valid.") isVerified = True except: log.error("Signature is invalid.") return isVerified