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
