def verify_signature(public_key, signature, data):
"""
Verifies transaction signature
"""
message = json.dumps(data)
try:
Ecdsa.verify(message, signature, public_key)
return True
except Exception as e:
return False
def starbank_ecdsa(count, loop):
privateKey = PrivateKey()
publicKey = privateKey.publicKey()
message = "This is the right message"
message_f = b"This is the right messages"
time_list_sign = []
for l in range(loop):
start = time.time()
for c in range(count):
signature = Ecdsa.sign(message, privateKey)
end = time.time() - start
# print("["+str(l)+"th starbank_ecdsa:sign second is "+ str(end) + "/"+str(count)+" signature")
time_list_sign.append(end)
ave_sign = numpy.mean(numpy.array(time_list_sign))
time_list_vrfy = []
for l in range(loop):
start = time.time()
for c in range(count):
if (Ecdsa.verify(message, signature, publicKey) == False):
print("err")
end = time.time() - start
# print("["+str(l)+"th starbank_ecdsa:vrfy second is "+ str(end) + "/"+str(count)+" signature")
time_list_vrfy.append(end)
ave_vrfy = numpy.mean(numpy.array(time_list_vrfy))
print("starbank_ecdsa:sign average second is " + str(ave_sign) + "/" +
str(count) + " signature")
print("starbank_ecdsa:vrfy average second is " + str(ave_vrfy) + "/" +
str(count) + " signature")
return time_list_sign, time_list_vrfy
def _verify_signature(content, signature, user=None, refresh=False):
signature = Signature.fromBase64(signature)
public_key = cache.get("starkbank-public-key")
if public_key is None or refresh:
pem = _get_public_key_pem(user)
public_key = PublicKey.fromPem(pem)
cache["starkbank-public-key"] = public_key
return Ecdsa.verify(message=content, signature=signature, publicKey=public_key)
def isValid(self, senderCoins, senderPk):
if (self.getSignature() == None):
print("Transaction must be signed by Coin Owner")
return False
for coin in self.__coins:
if (coin not in senderCoins):
return False
return Ecdsa.verify(str(self), self.getSignature(), senderPk)
def testVerifyRightMessage(self):
privateKey = PrivateKey()
publicKey = privateKey.publicKey()
message = "This is the right message"
signature = Ecdsa.sign(message, privateKey)
self.assertTrue(Ecdsa.verify(message, signature, publicKey))
def testVerifyWrongMessage(self):
privateKey = PrivateKey()
publicKey = privateKey.publicKey()
message1 = "This is the right message"
message2 = "This is the wrong message"
signature = Ecdsa.sign(message1, privateKey)
self.assertFalse(Ecdsa.verify(message2, signature, publicKey))
def verify_signature(wallet, message, signature):
''' Returns True of False if the signature matches the wallet's
public key for the given message. (NB: Each signature is associated
a specific message!)
Inputs:
- wallet (namedtuple instance)
- message (string)
- signature (output from sign_tx)
'''
flag = Ecdsa.verify(message, signature, wallet["publickey"])
return flag
def testAssign(self):
# Generated by: openssl ecparam -name secp256k1 -genkey -out privateKey.pem
privateKeyPem = File.read("./privateKey.pem")
privateKey = PrivateKey.fromPem(privateKeyPem)
message = File.read("./message.txt")
signature = Ecdsa.sign(message=message, privateKey=privateKey)
publicKey = privateKey.publicKey()
self.assertTrue(Ecdsa.verify(message=message, signature=signature, publicKey=publicKey))
def verify(dictionary_msg, signature, sender_public_key):
vk, _ = ppk_get_back_object(public_key=sender_public_key)
if config.DIGITAL_SIGNATURE_ALGO == 'ECDSA':
h = str(dictionary_msg)
check = Ecdsa.verify(h, Signature.fromPem(signature), vk) # True
# log_info("[security.digital_signature.verify] ECDSA Verify result: {}".format(check))
return check
elif config.DIGITAL_SIGNATURE_ALGO == 'SCHNORR':
h = dict_to_hash(dictionary_msg)
check = schnorr_verify(h, vk, signature)
# log_info("[security.digital_signature.verify] Schnorr Verify result: {}".format(check))
return check
else:
log_error("[security.digital_signature.verify] Unknown DSA in config -- cannot verify signature!")
def valid_signature(self, transaction):
"""
Validates the transaction signature : was the transaction really created by the sender ?
:param transaction: <dict>
:return: <bool>
"""
transaction_copy = transaction.copy() # les dictionnaires sont passés par référence
signature = transaction_copy.pop("signature")
ecdsa_signature = ellipticcurve.signature.Signature.fromBase64(signature)
key = transaction_copy['sender']
ecdsa_key = PublicKey.fromPem(key)
try:
return Ecdsa.verify(self.hash(transaction_copy), ecdsa_signature, ecdsa_key)
except:
return False
def testVerifySignature(self):
# openssl ec -in privateKey.pem -pubout -out publicKey.pem
publicKeyPem = File.read("./publicKey.pem")
# openssl dgst -sha256 -sign privateKey.pem -out signature.binary message.txt
signatureDer = File.read("./signatureDer.txt", "rb")
message = File.read("./message.txt")
publicKey = PublicKey.fromPem(publicKeyPem)
signature = Signature.fromDer(string=signatureDer)
self.assertTrue(Ecdsa.verify(message=message, signature=signature, publicKey=publicKey))
def verify_signature(self, payload, signature, timestamp, public_key=None):
"""
Verify signed event webhook requests.
:param payload: event payload in the request body
:type payload: string
:param signature: value obtained from the 'X-Twilio-Email-Event-Webhook-Signature' header
:type signature: string
:param timestamp: value obtained from the 'X-Twilio-Email-Event-Webhook-Timestamp' header
:type timestamp: string
:param public_key: elliptic curve public key
:type public_key: PublicKey
:return: true or false if signature is valid
"""
timestamped_payload = timestamp + payload
decoded_signature = Signature.fromBase64(signature)
key = public_key or self.public_key
return Ecdsa.verify(timestamped_payload, decoded_signature, key)
def write_slogan():
filename1 = fd.askopenfilename()
f2 = fd.askopenfilename()
y = cv2.imread(f2)
y = cv2.resize(y, (128, 60), interpolation=cv2.INTER_CUBIC)
x = cv2.imread(filename1)
x = cv2.resize(x, (128, 60), interpolation=cv2.INTER_CUBIC)
def rgb2gray(rgb):
return np.dot(rgb[..., :3], [0.2989, 0.5870, 0.1140])
x = rgb2gray(x)
y=rgb2gray(y)
x = x.astype(str)
y = y.astype(str)
from ellipticcurve.ecdsa import Ecdsa
from ellipticcurve.privateKey import PrivateKey
privateKey = PrivateKey()
publicKey = privateKey.publicKey()
a = []
for i in x:
for j in i:
m = j.encode(encoding='UTF-8', errors='strict')
signature = Ecdsa.sign(m, privateKey)
a.append(signature)
n = 0
f = 0
for i in y:
for j in i:
m = j.encode(encoding='UTF-8', errors='strict')
valid = Ecdsa.verify(m, a[n], publicKey)
if (valid == False):
f = 1
break
n += 1
if (f == 0):
T.insert(tk.END, "Succeessfully Verified!"+'\n')
else:
T.insert(tk.END, "Verification Unsuccessful."+'\n')
def verify(publickey, hash, signature):
return Ecdsa.verify(hash, signature, publickey)
f_signature.close()
else:
print("select key error")
else:
print('No message')
elif option == 4:
if message != None and signature != None:
print('Select key to verify the signature')
print("1 - public key")
print("2 - private key")
selectKey = int(input("\ninput: "))
status = False
try:
if selectKey == 1:
status = Ecdsa.verify(message, signature, publicKey)
elif selectKey == 2:
status = Ecdsa.verify(message, signature, privateKey)
else:
print("select key error")
except:
status = False
print('\nSignature status: ', status)
else:
print('No signature or message')
elif option == 5:
finish = True
else:
print('Option erro')
finish = True
def verify_signature(self, hash_b64_str, decoded_signature, verify_key):
return Ecdsa.verify(hash_b64_str, decoded_signature, verify_key)
publicKey = privateKey.publicKey()
# pega o arquivo da mensagem a ser decriptada
mensagem = "mensagem.txt"
#Encriptação da mensagem
signature = Ecdsa.sign(mensagem, privateKey)
# mensagem encriptada em base 64
signature_base = (signature.toBase64())
# Generate mensagem encriptada em txt
mensagem_encriptada = "mensagem_encriptada.txt"
file = open(mensagem_encriptada, 'w')
file.write(signature_base)
file.close()
# verificacao que a mensagem nao foi alterada usando a public key:
print(
"------------------------------------------------------------------------------"
)
print(
"Verificação de que a mensagem decripatada usando a public key não foi alterada"
)
print(Ecdsa.verify(mensagem, signature, publicKey))
print(
"------------------------------------------------------------------------------"
)
def verify(msg: str, sign, pb_key):
return Ecdsa.verify(msg, sign, pb_key)
def verify_ecdsas(input, signature, publicKey):
return Ecdsa.verify(input, signature, publicKey)
from ellipticcurve.ecdsa import Ecdsa
from ellipticcurve.privateKey import PrivateKey
# Generate new Keys
privateKey = PrivateKey.fromPem("""
-----BEGIN EC PARAMETERS-----
BgUrgQQACg==
-----END EC PARAMETERS-----
-----BEGIN EC PRIVATE KEY-----
MHQCAQEEIODvZuS34wFbt0X53+P5EnSj6tMjfVK01dD1dgDH02RzoAcGBSuBBAAK
oUQDQgAE/nvHu/SQQaos9TUljQsUuKI15Zr5SabPrbwtbfT/408rkVVzq8vAisbB
RmpeRREXj5aog/Mq8RrdYy75W9q/Ig==
-----END EC PRIVATE KEY-----
""")
publicKey = privateKey.publicKey()
message = "1345890371588410854.30135125cargo_info"
# Generate Signature
signature = Ecdsa.sign(message, privateKey)
# To verify if the signature is valid
print(Ecdsa.verify(message, signature, publicKey))
#privateKey = '8d1f80536cd8df3948f4a0d54565f0b65dc8a9f8969fb979a2f21ab1f21e05'
#publicKey = '0404fb2416c38f8e0e4790973d6cfcae0bffd02db79f651ecba976f55e84406d49218d39cb1adee8a3a911ddfe0fae85491e990d48a8ce451224ab32143c8ac736'
#message = "1345890371588410854.30135125cargo_info"
def verify_Signature(message, sign64, publicKey_input):
signature = Signature.fromBase64(sign64)
a = publicKey_input.split(".")
pt = Point(int(a[0]), int(a[1]), int(a[2]))
publicKey = PublicKey(point = pt, curve = secp256k1)
return (Ecdsa.verify(message, signature, publicKey))
def validate(
self,
payload,
signature,
):
return Ecdsa.verify(self.payload, self.sign, self.publicKey)
def isValid(self, scroogePk):
if (self.__signature == None):
return False
return Ecdsa.verify(str(self), self.__signature, scroogePk)
def verify_Signature(message, signature_input, publicKey_input):
publicKey_input = '-----BEGIN PUBLIC KEY-----\n' + publicKey_input + '\n-----END PUBLIC KEY-----\n'
signature = Signature.fromBase64(signature_input)
publicKey = PublicKey.fromPem(publicKey_input)
return (Ecdsa.verify(message, signature, publicKey))
def verify_signature(message: str, signature: Signature, public_key: PublicKey) -> bool:
return Ecdsa.verify(message, signature, public_key)
def isValid(self, scroogePk):
if (self.getSignature() == None):
print("Transaction must be signed by scrooge")
return False
return Ecdsa.verify(str(self), self.getSignature(), scroogePk)
from ellipticcurve.ecdsa import Ecdsa from ellipticcurve.privateKey import PrivateKey # Gerando as chaves chave_privada = PrivateKey() chave_publica = chave_privada.publicKey() mensagem = "Segredo secreto :O" # Gerando a assinatura carloscabral = Ecdsa.sign(mensagem, chave_privada) # Verificando Resposta = Ecdsa.verify(mensagem, carloscabral, chave_publica) print(Resposta)
def verify_Signature(message, sign64, str1):
signature = Signature.fromBase64(sign64)
publicKey = PublicKey.fromPem(str1)
return (Ecdsa.verify(message, signature, publicKey))