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))