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)
