def ring_signature(siging_key, key_idx, M, y, G=SECP256k1.generator, hash_func=hashlib.sha3_256): """ Generates a ring signature for a message given a specific set of public keys and a signing key belonging to one of the public keys in the set. PARAMS ------ signing_key: (int) The with which the message is to be anonymously signed. key_idx: (int) The index of the public key corresponding to the signature private key over the list of public keys that compromise the signature. M: (str) Message to be signed. y: (list) The list of public keys which over which the anonymous signature will be compose. G: (ecdsa.ellipticcurve.Point) Base point for the elliptic curve. hash_func: (function) Cryptographic hash function that recieves an input and outputs a digest. RETURNS ------- Signature (c_0, s, Y) : c_0: Initial value to reconstruct signature. s = vector of randomly generated values with encrypted secret to reconstruct signature. Y = Link for current signer. """ n = len(y) c = [0] * n s = [0] * n # STEP 1 H = H2(y, hash_func=hash_func) Y = H * siging_key # STEP 2 u = randrange(SECP256k1.order) c[(key_idx + 1) % n] = H1([y, Y, M, G * u, H * u], hash_func=hash_func) # STEP 3 for i in [ i for i in range(key_idx + 1, n) ] + [i for i in range(key_idx)]: s[i] = randrange(SECP256k1.order) z_1 = (G * s[i]) + (y[i] * c[i]) z_2 = (H * s[i]) + (Y * c[i]) c[(i + 1) % n] = H1([y, Y, M, z_1, z_2], hash_func=hash_func) # STEP 4 s[key_idx] = (u - siging_key * c[key_idx]) % SECP256k1.order return (c[0], s, Y)
def secret_split(secret, t, n, G=SECP256k1.generator, O=SECP256k1.order): """ Splits a secret into n shares out which t can reconstruct the key. PARAMS ------ secret: (int) Secret to be split. t: (int) Size of the sub set that should be able to reconstruct key. n: (int) Number of shares into which the secret is split. G: (ecdsa.ellipticcurve.Point) Base point for the elliptic curve. O: (int) Order of elliptic curve RETURNS ------- secret_share: (list) A list containing the splits of the secret. F: (list) list of public parameters used to generate secret_share. coeficients used multiplied by the EC generator to make them public. """ assert (n >= t) coef = [secret] + [randrange(SECP256k1.order) for i in range(1, t)] f = lambda x: sum([coef[i] * pow(x, i) for i in range(t)]) % O secret_share = list(map(f, list(range(1, n + 1)))) F = [coef[j] * G for j in range(t)] return (secret_share, F)
def encrypt(pub_key, message, G=SECP256k1.generator, O=SECP256k1.order): """ Encrypts a message with an ECC threshold public key. Standard ECC encryption. PARAMS ------ pub_key: (ecdsa.ellipticcurve.Point) public key with which to encrypt message. message: (int) message to be encrypted. G: (ecdsa.ellipticcurve.Point) Base point for the elliptic curve. O: (int) Order of elliptic curve RETURNS ------- (P, c) touple with encrypted message. """ k = randrange(O) P = k * G H = k * pub_key c = message * H.y() % O return (P, c)
def main(): secret_key = randrange(SECP256k1.order) pkey_file = sys.argv[1] f = open(pkey_file, 'w') f.write(str(secret_key) + '\n') print("Key is : %s" % (str(secret_key)))
def generate_ephid(): curve = SECP128r1 secexp = randrange(curve.order) sk = SigningKey.from_secret_exponent(secexp, curve) ephid = sk.to_string() return secexp, ephid
def encrypt(pub_key, message, G=SECP256k1.generator, O=SECP256k1.order): k = randrange(O) P = k * G H = k * pub_key c = message * H.y() % O return (P, c)
def generate_ring_sig_default(message): number_participants = 10 x = [randrange(SECP256k1.order) for i in range(number_participants)] i = 2 y = list(map(lambda xi: SECP256k1.generator * xi, x)) signature = ring_signature(x[i], i, message, y) try: assert verify_ring_signature(message, y, *signature) except AssertionError as e: print(e) return (message, y, signature)
def main(): number_participants = 10 x = [ randrange(SECP256k1.order) for i in range(number_participants)] y = list(map(lambda xi: SECP256k1.generator * xi, x)) message = "Every move we made was a kiss" i = 2 signature = ring_signature(x[i], i, message, y) assert(verify_ring_signature(message, y, *signature))
def generate_key(order=SECP256k1.order): """ Generates a private key for use with ECC. Basically a random number generator with mod order. PARAMS ------ order: (int) the order of the curve. RETURNS ------- (int) private key. """ return randrange(order)
def main(): number_participants = 3 # number_participants = 10 x = [randrange(SECP256k1.order) for i in range(number_participants)] y = list(map(lambda xi: SECP256k1.generator * xi, x)) ''' faculty = [ 'Amey Karkare', 'Anil Seth', 'Arnab Bhattacharya', 'Debadatta Mishra', 'Mainak Chaudhari', 'Nitin Saxena', 'Rajat Mittal', 'Sandeep Shukla', 'SK Mehta', 'Sumit Ganguly', ] assert(len(faculty) == number_participants) private_key_dict = [] public_key_dict = [] for i in range(number_participants): private_key_dict.append([faculty[i], x[i]]) public_key_dict.append([faculty[i], y[i]]) pickle.dump(private_key_dict, open('faculty.prv', 'wb')) pickle.dump(public_key_dict, open('faculty.pub', 'wb')) ''' print(x, y) message = "Every move we made was a kiss" i = 2 for i in range(0, number_participants): print(i) signature = ring_signature(x[i], i, message, y) print(signature) assert (verify_ring_signature(message, y, *signature)) for i in range(0, number_participants): print(i) signature = ring_signature(x[i], i, message + "join", y) assert (verify_ring_signature(message + "join", y, *signature))
from pycoin.networks import registry import pprint #bitcoin.SelectParams('regtest') ecdsa_signingkey = SigningKey.generate() # Generate a random private key valid_private_key = False while not valid_private_key: my_secret = 1 #util.randrange(ecdsa.generator_secp256k1.order()) valid_private_key = 0 < my_secret < ecdsa.generator_secp256k1.order() print("") my_prng = util.PRNG(util.randrange(ecdsa.generator_secp256k1.order())) print("PRNG (random generator) 32 bytes: ", b2h(my_prng.__call__(32))) my_netcode = "BTC" # mainnet: BTC, testnet3: XTN my_key = Key(secret_exponent=my_secret, is_compressed=True, netcode=my_netcode) ## netcode list: pycoin.networks.all.py pp = pprint.PrettyPrinter(indent=2) my_network = registry.network_for_netcode(my_netcode) my_addr_prefix = registry._lookup(my_netcode, "address") getattr(my_network, "address") pp.pprint(my_network.__dict__) pprint.pprint(my_network.__dict__.keys(), width=60, depth=2) privkey_hex = b2h(encoding.to_bytes_32(my_key.secret_exponent()))
#!/usr/bin/python3 import os import sys sys.path.insert( 0, os.path.abspath(__file__ + '/../../ecc_linkable_ring_signatures')) from ecdsa import SECP256k1 from ecdsa.util import randrange if len(sys.argv) <= 1: sys.exit(0) file_name_prefix = sys.argv[1] sk = randrange(SECP256k1.order) pk = SECP256k1.generator * sk open(file_name_prefix + '_private.int', 'wb').write(str(sk).encode()) open(file_name_prefix + '_public.int', 'wb').write(str(pk).encode())
def generate_ring_sig_default(message): number_participants = 10 x = [randrange(SECP256k1.order) for i in range(number_participants)] i = 2 y = list(map(lambda xi: SECP256k1.generator * xi, x)) signature = ring_signature(x[i], i, message, y) try: assert verify_ring_signature(message, y, *signature) except AssertionError as e: print(e) return (message, y, signature) number_participants = 10 x = [randrange(SECP256k1.order) for i in range(0, number_participants)] y = list(map(lambda xi: SECP256k1.generator * xi, x)) # message = "Every move we made was a kiss" # i = 2 # signature = ring_signature(x[i], i, message, y) # print(message) # print("======") # print(signature) # print("======") # print(verify_ring_signature(message, y, *signature)) # assert(verify_ring_signature(message, y, *signature)) print("===========") print("===========") print(generate_ring_sig_default("hello world"))
from ecdsa import SigningKey from ecdsa import VerifyingKey from ecdsa.ecdsa import generator_secp256k1 from ecdsa.util import string_to_number, number_to_string from electrumq.utils.base58 import hash_160, b58encode_check, b58decode_check from electrumq.utils.key import SecretToASecret, GetPubKey, EC_KEY, ser_to_point from electrumq.utils.mnemonic import Mnemonic from electrumq.utils.parameter import Parameter from electrumq.utils.parser import write_uint32 __author__ = 'zhouqi' ###################################### BIP32 ############################## random_seed = lambda n: "%032x" % util.randrange(pow(2, n)) BIP32_PRIME = 0x80000000 def get_pubkeys_from_secret(secret): # public key private_key = SigningKey.from_string(secret, curve=SECP256k1) public_key = private_key.get_verifying_key() K = public_key.to_string() K_compressed = GetPubKey(public_key.pubkey, True) return K, K_compressed # Child private key derivation function (from master private key) # k = master private key (32 bytes) # c = master chain code (extra entropy for key derivation) (32 bytes)
def main(): parser = argparse.ArgumentParser( description='Linakble Ring Signature Voting Tool') voting_group = parser.add_argument_group(title='Vote') home = os.path.expanduser("~") ring_path = os.path.join(home, 'Downloads', 'my_ring.csv') threshold_path = os.path.join(home, 'Downloads', 'thresholdKey.csv') voting_group.add_argument( '--ring', default=ring_path, type=str, metavar='RING', help='Path to csv file with public keys over which to compute signature' ) voting_group.add_argument( '--seckey', default=None, type=str, metavar='SK', help= 'Path to file with secret key corresponding to one of the public keys to perform signature' ) voting_group.add_argument( '--thkey', default=threshold_path, type=str, metavar='THKEY', help='Path to csv file with threshold key to generate vote') voting_group.add_argument( '--vote', default=None, type=int, metavar='VOTE', help='Integer representation of voting option to encrypt and sign') voting_group.add_argument('--exp', default=os.path.join('.', 'my_sig.txt'), type=str, metavar='VOTE', help='Path of file to export signature too.') key_gen_group = parser.add_argument_group(title='Key Generation') key_gen_group.add_argument( '--keygen', default=os.path.join('.', 'priv_key.txt'), type=str, metavar='KEYGEN', help= 'Generate a new private key and save to file [Default: ./priv_key.txt]' ) args = parser.parse_args() if args.ring and args.seckey and args.thkey and args.vote: ring = [ pointify(pk[:-1].split(',')) for pk in open(args.ring, 'r').readlines() ] thresholdKey = pointify( open(args.thkey, 'r').readlines()[0][:-1].split(',')) v = encrypt(thresholdKey, args.vote) vote = [v[0].x(), v[0].y(), v[1]] seckey = int(open(args.seckey, 'r').readlines()[0][:-1]) j = 0 for i, pk in enumerate(ring): if SECP256k1.generator * seckey == pk: j = i sig = ring_signature(seckey, j, H1(vote), ring) assert (verify_ring_signature(H1(vote), ring, *sig)) export_signature(ring, vote, sig, '.', args.exp) elif args.keygen: s_key = randrange(SECP256k1.order) open(args.keygen, 'w').write(str(s_key) + '\n') print('Key Generated : {}'.format(s_key)) else: print('Wrong usage, run: {} --help'.format(sys.argv[0]))
def generatePrivateKey(): return randrange(SECP256k1.order)