def sign(message): pp = PublicParams.get_default() params = LocalParams.get_default() G = pp.ec_group digest = pp.hash_func(message).digest() kinv_rp = do_ecdsa_setup(G, params.sig.sk) sig = do_ecdsa_sign(G, params.sig.sk, digest, kinv_rp=kinv_rp) return sig
def __init__(self, key_bytes, public=True): """ Make a key given a public or private key in bytes """ self.G = _globalECG if public: self.sec = None self.pub = EcPt.from_binary(key_bytes, self.G) self.optim = None else: self.sec = Bn.from_binary(sha256(key_bytes).digest()) self.pub = self.sec * self.G.generator() self.optim = do_ecdsa_setup(self.G, self.sec)
def __init__(self, key_bytes, public=True): """ Make a key given a public or private key in bytes """ self.G = _globalECG if public: self.sec = None self.pub = EcPt.from_binary(key_bytes, self.G) self.optim = None else: self.sec = Bn.from_binary(sha256(key_bytes).digest()) self.pub = self.sec * self.G.generator() self.optim = do_ecdsa_setup(self.G, self.sec)
def ecdsa_sign(G, priv_sign, message): """ Sign the SHA256 digest of the message using ECDSA and return a signature """ plaintext = message.encode("utf8") ## YOUR CODE HERE G = EcGroup() ver_key = priv_sign * G.generator() digest = sha256(plaintext).digest() kinv_rp = do_ecdsa_setup(G, priv_sign) sig = do_ecdsa_sign(G, priv_sign, digest, kinv_rp=kinv_rp) return sig
def sign(message): """Sign a message. :param bytes message: Message :return: Tuple of bignums (``petlib.bn.Bn``) """ pp = PublicParams.get_default() params = LocalParams.get_default() G = pp.ec_group digest = pp.hash_func(message).digest() kinv_rp = do_ecdsa_setup(G, params.sig.sk) sig = do_ecdsa_sign(G, params.sig.sk, digest, kinv_rp=kinv_rp) return sig
from collections import defaultdict, Counter import binascii import json import uuid import random import qrcode G = EcGroup(934) order = G.order() h = G.generator() sleeve = "nothing_up_my_sleeve" g = G.hash_to_point(sleeve.encode('utf-8')) #secret!!! sig_key = order.random() kinv_rp = do_ecdsa_setup(G, sig_key) #not secret ver_key = sig_key * h def commit(a, r): return a * h + r * g def genRealCommitments(vote, k, R): real_commitment = commit(vote, R) rb = [order.random() for i in range(k)] masks = [commit(vote, R + rb[i]) for i in range(k)] return real_commitment, masks, rb
failed = 0 result = True for a, b in zip(hashes, sigs): res = do_ecdsa_verify(Gx, pub_verifyx, b, a) if (res == False): result = False return result # ---------------------- Signing Phase --------------------------------- # G = EcGroup(714) print("G is: ", G) priv_sign = G.order().random() print("priv_sign: ", priv_sign) kinv_rp = do_ecdsa_setup(G, priv_sign) pub_verify = priv_sign * G.generator() print("pub_verify: ", pub_verify) VariantsArr = OpenVCFfileAsArray(VCFfilePath) SegmentedVariantsArr = SegmentArr(VariantsArr, Segments) SegmentedVariantsArrEncoded = EncodeArr(SegmentedVariantsArr) signatures = [] def signit(Gx, priv_signx, pub_verifyx, SigsFile, segs, VCFfilePath, HType, ArrFName): global signatures global SegmentedVariantsArrEncoded hashesToBeSigned = CreateHashListOfVariants(SegmentedVariantsArrEncoded,
See also http://andrea.corbellini.name/2015/05/30/elliptic-curve-cryptography-ecdh-and-ecdsa/ The first thing we are going to do is sign a peice of text. Signing is an important foundational part of our contract design. Before signing we create a digest of the text as it might be very long. """ digest = sha1(b"Something I wish to sign").digest() print hexlify(digest) """Next we can sign it. We need the elliptic curve parameter `G` which we can get from the params we created in the setup. We pass it the public key we generated earlier""" (G, _, _, _) = params kinv_rp = do_ecdsa_setup(G, private_key) """Now we can sign our digest""" sig = do_ecdsa_sign(G, private_key, digest, kinv_rp=kinv_rp) print pack(sig) """Finally we can verify it using the public key from our keypair""" do_ecdsa_verify(G, public_key, sig, digest) """Here is a bunch of crypto functions for [homomorphic encryption](https://en.wikipedia.org/wiki/Homomorphic_encryption) See [here](https://crypto.stackexchange.com/questions/45040/can-elliptic-curve-cryptography-encrypt-with-public-key-and-decrypt-with-private) for an answer about doing encryption with elliptic curve cryptography. In order to do [asymetric encryption](https://en.wikipedia.org/wiki/Public-key_cryptography) using ECC you first have to turn your message into a point on the curve,you can then encrypt using a public key which can be decrypted with the private key. There is a scheme for more general encrpytion, the https://en.wikipedia.org/wiki/Integrated_Encryption_Scheme which allows two parties to generate a symetric key that they can use to encrypt a message between them