def elgamal():
#伪随机数生成器
random_generator = Random.new().read
#生成elgamal Key
elgKey = ElGamal.generate(256, random_generator)
#生成私钥
while 1:
alpha = random.StrongRandom().randint(1, elgKey.p - 1)
if GCD(alpha, elgKey.p - 1) == 1:
break
h = mod(elgKey.g, alpha, elgKey.p)
message = [33, 14, 22, 62, 00, 17, 4, 62, 24, 14, 20, 66]
print('message: ', message)
#加密过程
#1.随机选择整数y
y = random.StrongRandom().randint(1, elgKey.p - 1)
#2.计算c1
c1 = mod(elgKey.g, y, elgKey.p)
#3.计算s
s = mod(h, y, elgKey.p)
#4.对message进行加密
ciphertext = [(m * s) % (elgKey.p) for m in message]
print('ciphetext: ', ciphertext)
#解密过程
#1.通过c1计算得到s
de_s = mod(c1, alpha, elgKey.p)
#2.获得明文
x, y, r = ex_gcd(elgKey.p, de_s)
s_reverse = y % (elgKey.p)
if s_reverse < 0:
s_reverse += elgKey.p
plaintext = [(m * s_reverse) % (elgKey.p) for m in ciphertext]
print('plaintext: ', plaintext)
def _test_random_key(self, bits):
elgObj = ElGamal.generate(bits, Random.new().read)
self._check_private_key(elgObj)
self._exercise_primitive(elgObj)
pub = elgObj.publickey()
self._check_public_key(pub)
self._exercise_public_primitive(elgObj)
def _test_random_key(self, bits):
elgObj = ElGamal.generate(bits, Random.new().read)
self._check_private_key(elgObj)
self._exercise_primitive(elgObj)
pub = elgObj.publickey()
self._check_public_key(pub)
self._exercise_public_primitive(elgObj)
def get_key():
key = ElGamal.generate(256, get_random_bytes)
comps = ('p','g','y','x')
out = '\n'.join(["{} = {}".format(comp,getattr(key, comp)) for comp in comps])
with open('./key', 'w+') as k:
k.write(out)
key.set_key(user, out['y'],out['x'])
return key
def generate_ElGamal_key(keysize):
"""
Genera una clave ElGamal del tamaño especificado.
:param keysize: El tamaño de la clave.
:returns: Una clave ElGamal.
"""
return ElGamal.generate(keysize, Random.new().read)
def elgamal_reg(usr, name, sex_zh, unit, title):
# Database connection
conn = MySQLdb.connect(
host='localhost',
user='******',
passwd='123456',
db='project',
charset='utf8'
)
cur = conn.cursor()
# Gender transfer
if sex_zh == u'男':
sex = 0
elif sex_zh == u'女':
sex = 1
# Unit transfer
sql_unit = "SELECT * FROM unit WHERE unit_name = '%s'" % unit
cur.execute(sql_unit)
result_unit = cur.fetchall()
unitid = result_unit[0][0]
# Avoid duplication
sql_search = "SELECT * FROM users WHERE loginid = '%s'" % usr
if cur.execute(sql_search) == 0L:
# Insert into database
sql = "insert into users(loginid, pass_word, name, sex, unitid, title) values('%s', '', '%s', '%d', '%d', '%s')" % (usr, name, sex, unitid, title)
cur.execute(sql)
conn.commit()
cur.close()
conn.close()
# Key generation
key = ElGamal.generate(256, Random.new().read)
# Key data
p = key.p
g = key.g
y = key.y
x = key.x
# Save user's public key
f = open('auth/elgamal/keys/%s.pub' % usr,'w')
f.write(str(p) + ' ' + str(g) + ' ' + str(y))
f.close()
return 1, p, g, y, x
# Registeration failed
else:
return 2, 0, 0, 0, 0
def generateKeyPair(keySize):
privateKey = ElGamal.generate(keySize, Random.new().read)
privateKey.x = int(privateKey.x)
privateKey.y = int(privateKey.y)
privateKey.p = int(privateKey.p)
privateKey.g = int(privateKey.g)
publicKey = privateKey.publickey()
publicKey.p = int(publicKey.p)
publicKey.g = int(publicKey.g)
return privateKey, publicKey
def pyCrypto():
import Crypto
from Crypto.Cipher import AES, DES, DES3, ARC2, ARC4, Blowfish, CAST, PKCS1_v1_5, PKCS1_OAEP, XOR
from Crypto.PublicKey import ElGamal
Crypto.Cipher.AES.new() # Noncompliant
Crypto.Other.AES.new() # OK
AES.new(key=key) # Noncompliant
DES.new(key=key) # Noncompliant
DES3.new(key=key) # Noncompliant
ARC2.new(key=key) # Noncompliant
ARC4.new(key=key) # Noncompliant
Blowfish.new(key=key) # Noncompliant
CAST.new(key=key) # Noncompliant
PKCS1_v1_5.new(key=key) # Noncompliant
PKCS1_OAEP.new(key=key) # Noncompliant
XOR.new(key=key) # Noncompliant
ElGamal.generate(key_size) # Noncompliant
def generate_elgamal_keypair():
"""Return an ElGamal object with newly generated keypair"""
if 'SFLVAULT_IN_TEST' in os.environ:
print "WARNING: IN TEST MODE, EVERY KEYPAIR GENERATION IS BYPASSED AND USES A PRE-GENERATED AND WORLD-KNOWN KEYPAIR. REMOVE 'SFLVAULT_IN_TEST' FROM YOUR ENVIRONMENT IF YOU ARE DOING THIS ON PRODUCTION"
eg = ElGamal.ElGamalobj()
keys = [(177089723724552644256797243527295142469255734138493329314329932362154457094059269514887621456192343485606008571733849784882603220703971587460034382850082611103881050702039214183956206957248098956098183898169452181835193285526486693996807247957663965314452283162788463761928354944430848933147875443419511844733534867714246125293090881680286010834371853006350372947758409794906981881841508329191534306452090259107460058479336274992461969572007575859837L, 2368830913657867259423174096782984007672147302922056255072161233714845396747550413964785336340342087070536608406864241095864284199288769810784864221075742905057068477336098276284927890562488210509136821440679916802167852789973929164278286140181738520594891315446533462206307248550944558426698389577513200698569512147125339722576147002382255876258436727504192479647579172625910816774587488928783787624267035610900290120258307919121453927670441700811482181614216947L, 5861471316007038922650757021308043193803646029154275389954930654765928019938681282006482343772842302607960473277926921384673235972813815577111985557701858831111694263179407993690846841997398288866685890418702914928188654979371728552059661796422031090374692580710906447170464105162673344042938184790777466702148445760745296149876416417949678454708511011740073066144877868339403040477747772225977519821312965207L, 1169412825199936698700035513185825593893938895474876750007859746409857305379860678064015124546593449912724002752383066585681624318254362438491372548721947497497739043831382430104856590871057670575051579668363576657397472353061812950884556034822611307705562237354213497368218843244103113882159981178841442771150519161251285978446459307942619668439466357674240712609844734284943761543870187004331653216116937988266963743961096619840352159665738163357566198583064435L),
(363126185715790250119395282425017818083421673278440118808474954552806007436370887232958142538070938460903011757636551318850215594111019699633958587914824512339681573953775134121488999147928038505883131989323638021781157246124428000084118138446325126739005521403114471077697023469488488105229388102971903306007555362613775010306064798678761753948810755236011346132218974049446116094394433461746597812371697367173395113014824646850943586174124632464143L, 1989666736598081965365973787349938627625613245335951894925228395719349924579514682166704542464221001327015131231101009506582078440087637470784673000661958376397578391397303146171320274531265903747455382524598808613766406694744319576824028880703970997080651320662468590292703565426391011134523391035995750230341849776175803186815053305823053143914398318121693692044542134832809759905437953710838534372887584358442203447387293183908262967797038874535690090799742911L, 133850088107174975861015682594827971956767368440585898108600141692889215241539178575381178799995195531301157505453120993980045956642227472649664668888717884598815932243844750408878011387532720932159839454554017574665882963054750224693505390054364096154711586190837517112644639757613967217614109546151313073865262488626822109764294618345504453742784825659007630866924661811701179640013729327586347L, 742665583685283032188129474839034185107068199926583417281240975739235100098517297493350864258177674271267050862217567671938790648634008735784684115797768392310253433978502694449565453913758801583487678024491118014887051643096970952295790434950566748516670079663712282848262006606082748685002561868381598918739708181310245226480020229450553192469536632519293406262550081671717685585065331112633947328611250435010734072352883491446355872734313855711051794348490960L)]
eg.g, eg.p, eg.x, eg.y = keys[random.randint(0, 1)]
return eg
# Otherwise, generate, really :)
return ElGamal.generate(1536, randfunc)
def pyCrypto():
import Cryptodome
from Cryptodome.Cipher import AES, ChaCha20, DES, DES3, ARC2, ARC4, Blowfish, CAST, PKCS1_v1_5, PKCS1_OAEP, ChaCha20_Poly1305, Salsa20
from Cryptodome.PublicKey import ElGamal
Cryptodome.Cipher.AES.new() # Noncompliant
Cryptodome.Other.AES.new() # OK
AES.new(key=key) # Noncompliant
ChaCha20.new(key=key) # Noncompliant
DES.new(key=key) # Noncompliant
DES3.new(key=key) # Noncompliant
ARC2.new(key=key) # Noncompliant
ARC4.new(key=key) # Noncompliant
Blowfish.new(key=key) # Noncompliant
CAST.new(key=key) # Noncompliant
PKCS1_v1_5.new(key=key) # Noncompliant
PKCS1_OAEP.new(key=key) # Noncompliant
ChaCha20_Poly1305.new(key=key) # Noncompliant
Salsa20.new(key=key) # Noncompliant
ElGamal.generate(key_size) # Noncompliant
def keygen(keyfile):
key = ElGamal.generate(1024, Random.new().read)
comps_priv = ('p', 'g', 'y', 'x')
comps_pub = ('p', 'g', 'y')
out = ",".join(["{}".format(getattr(key, comp)) for comp in comps_priv])
with open(keyfile, 'w') as key_file:
key_file.write(out)
out = ",".join(["{}".format(getattr(key, comp)) for comp in comps_pub])
with open(keyfile + ".pub", 'w') as key_file:
key_file.write(out)
def generate_elgamal(klength, privatekey):
key = ElGamal.generate(klength, Random.new().read)
h = SHA.new(privatekey).digest()
while 1:
k = random.StrongRandom().randint(1,key.p-1)
if GCD(k, key.p-1) == 1: break
sig = key.sign(h,k)
if key.verify(h,sig):
print "OK"
return key, h , sig
else:
print "Incorrect signature"
return None
def initiate_DH(self):
# send first DH parameter to all users
print 'Generating Diffie-Hellman parameters'
self.DH_params = ElGamal.generate(p_size, Random.new().read)
print 'Generated'
params_string = str(self.DH_params.y) + '|' + str(
self.DH_params.g) + '|' + str(self.DH_params.p)
DH_msg1 = DH_INIT + '|' + params_string
self.process_outgoing_message(msg_raw=DH_msg1,
originates_from_console=False)
self.symm_key = number.long_to_bytes(
random.StrongRandom().getrandbits(128))
self.save_symm_key()
def make_key_objects(pub_algorithm_type, key_size):
if pub_algorithm_type == 17:
secret_key = DSA.generate(key_size)
elif pub_algorithm_type in (1, 3):
secret_key = RSA.generate(key_size)
elif pub_algorithm_type == 20:
# TODO: This should not be allowed except for testing purposes.
# XXX: This can take a really long time
secret_key = ElGamal.generate(key_size, Random.new().read)
else:
# TODO: complete
raise ValueError
public_key = secret_key.publickey()
return secret_key, public_key
def make_key_objects(pub_algorithm_type, key_size):
if pub_algorithm_type == 17:
secret_key = DSA.generate(key_size)
elif pub_algorithm_type in (1, 3):
secret_key = RSA.generate(key_size)
elif pub_algorithm_type == 20:
# TODO: This should not be allowed except for testing purposes.
# XXX: This can take a really long time
secret_key = ElGamal.generate(key_size, Random.new().read)
else:
# TODO: complete
raise ValueError
public_key = secret_key.publickey()
return secret_key, public_key
def init_with(self, key_size, repr_file='elg.cry'):
self.key_size = self.key_sizes[key_size]
self.private_key = ElGamal.generate(self.key_size, Random.new().read)
self.public_key = self.private_key.publickey()
self.p = self.public_key.p
io_util.elg_key_to_file('pub_' + repr_file, self.public_key,
self.key_size)
io_util.elg_key_to_file('priv_' + repr_file,
self.private_key,
self.key_size,
private=True)
self.sign_key = cip_PKCS1.new(self.private_key)
self.verify_key = cip_PKCS1.new(self.public_key)
self.private_key = cip_PKCS1.new(self.private_key)
self.public_key = cip_PKCS1.new(self.public_key)
def subscribe(self):
print "Subscribing please wait..."
self.rsa = RSA_gen(4096)
self.n, self.e, self.d = RSA_keys(self.rsa)
self.ElGkey = ElGamal.generate(256, Random.new().read)
self.rsa_sign = RSA_gen(1024)
self.n_sign, self.e_sign, self.d_sign = RSA_keys(self.rsa_sign)
self.ust = UST(self.server_pk_n, self.server_pk_e)
self.ust_lock.acquire()
self.ust.prepare()
args = {
"blinded_nonce": self.ust.blinded_nonce,
"client_username": self.username,
"client_pk_n": self.n,
"client_pk_e": self.e,
"client_sign_pk_n": self.n_sign,
"client_sign_pk_e": self.e_sign
}
r = send_request(SUBSCRIBE, args)
if r == ERROR:
print "ERROR: could not subscribe"
sys.exit(0)
self.ust.receive(r['blinded_sign'])
self.ust_lock.release()
user = r['user']
if user['client_pk_n'] == self.n and user['client_pk_e'] == self.e \
and user['client_sign_pk_n'] == self.n_sign \
and user['client_sign_pk_e'] == self.e_sign:
pass
else:
print "Username is taken, please try again"
sys.exit(0)
self.user_id = user['client_user_id']
self.user_table_ptr = 0
self.client_new_conversations_table_ptr = 0
return
def elgamal(message):
"""
Randomly generate a fresh, new ElGamal key.
The key will be safe for use for both encryption and signature.
"""
key = ElGamal.generate(1024, Random.new().read)
while 1:
k = random.StrongRandom().randint(1, key.p - 1)
if GCD(k, key.p - 1) == 1:
break
"""Encrypts and decrypts the message"""
e = key.encrypt(message, k)
d = key.decrypt(e)
print('encrypted message: {}'.format(e))
print('decrypted message: {}'.format(d))
def setUpClass(cls):
cls.A = ''.join(random.choice(string.ascii_letters) for _ in range(12))
cls.B = ''.join(random.choice(string.ascii_letters) for _ in range(12))
keyA = ElGamal.generate(cls.NUM_BITS, Random.new().read)
with open(cls.A, 'w') as f:
f.write(export_elgamal_key(keyA))
with open(cls.A + '.pub', 'w') as f:
f.write(export_elgamal_key(keyA.publickey()))
x = random.randint(1 + 1, keyA.p - 1 - 1)
y = pow(keyA.g, x, keyA.p)
tup = (keyA.p, keyA.g, y, x)
keyB = ElGamal.construct(tup)
with open(cls.B, 'w') as f:
f.write(export_elgamal_key(keyB))
with open(cls.B + '.pub', 'w') as f:
keyB = ElGamal.construct(tup)
f.write(export_elgamal_key(keyB.publickey()))
def subscribe(self):
print "Subscribing please wait..."
self.rsa = RSA_gen(4096)
self.n, self.e, self.d = RSA_keys(self.rsa)
self.ElGkey = ElGamal.generate(256, Random.new().read)
self.rsa_sign = RSA_gen(1024)
self.n_sign, self.e_sign, self.d_sign = RSA_keys(self.rsa_sign)
self.ust = UST(self.server_pk_n, self.server_pk_e)
self.ust_lock.acquire()
self.ust.prepare()
args = {"blinded_nonce" : self.ust.blinded_nonce,
"client_username" : self.username,
"client_pk_n" : self.n,
"client_pk_e" : self.e,
"client_sign_pk_n" : self.n_sign,
"client_sign_pk_e" : self.e_sign}
r = send_request(SUBSCRIBE, args)
if r == ERROR:
print "ERROR: could not subscribe"
sys.exit(0)
self.ust.receive(r['blinded_sign'])
self.ust_lock.release()
user = r['user']
if user['client_pk_n'] == self.n and user['client_pk_e'] == self.e \
and user['client_sign_pk_n'] == self.n_sign \
and user['client_sign_pk_e'] == self.e_sign:
pass
else:
print "Username is taken, please try again"
sys.exit(0)
self.user_id = user['client_user_id']
self.user_table_ptr = 0
self.client_new_conversations_table_ptr = 0
return
def verify_cipher_suite(self, cipher, data):
ciphers = cipher.split('-')
print ciphers[0]
if ciphers[0] == 'ECDHE':
pass
elif ciphers[0] == 'ElGamal':
key = ElGamal.generate(1024, Random.new().read)
h = SHA.new(data).digest()
while 1:
k = random.StrongRandom().randint(1, key.p - 1)
if GCD(k, key.p - 1) == 1:
break
sig = key.sign(h, k)
#
if key.verify(h, sig):
print "OK"
else:
print "Incorrect signature"
else:
pass
def generate_elgamal_keypair():
"""Return an ElGamal object with newly generated keypair"""
if 'SFLVAULT_IN_TEST' in os.environ:
print "WARNING: IN TEST MODE, EVERY KEYPAIR GENERATION IS BYPASSED AND USES A PRE-GENERATED AND WORLD-KNOWN KEYPAIR. REMOVE 'SFLVAULT_IN_TEST' FROM YOUR ENVIRONMENT IF YOU ARE DOING THIS ON PRODUCTION"
eg = ElGamal.ElGamalobj()
keys = [
(177089723724552644256797243527295142469255734138493329314329932362154457094059269514887621456192343485606008571733849784882603220703971587460034382850082611103881050702039214183956206957248098956098183898169452181835193285526486693996807247957663965314452283162788463761928354944430848933147875443419511844733534867714246125293090881680286010834371853006350372947758409794906981881841508329191534306452090259107460058479336274992461969572007575859837L,
2368830913657867259423174096782984007672147302922056255072161233714845396747550413964785336340342087070536608406864241095864284199288769810784864221075742905057068477336098276284927890562488210509136821440679916802167852789973929164278286140181738520594891315446533462206307248550944558426698389577513200698569512147125339722576147002382255876258436727504192479647579172625910816774587488928783787624267035610900290120258307919121453927670441700811482181614216947L,
5861471316007038922650757021308043193803646029154275389954930654765928019938681282006482343772842302607960473277926921384673235972813815577111985557701858831111694263179407993690846841997398288866685890418702914928188654979371728552059661796422031090374692580710906447170464105162673344042938184790777466702148445760745296149876416417949678454708511011740073066144877868339403040477747772225977519821312965207L,
1169412825199936698700035513185825593893938895474876750007859746409857305379860678064015124546593449912724002752383066585681624318254362438491372548721947497497739043831382430104856590871057670575051579668363576657397472353061812950884556034822611307705562237354213497368218843244103113882159981178841442771150519161251285978446459307942619668439466357674240712609844734284943761543870187004331653216116937988266963743961096619840352159665738163357566198583064435L
),
(363126185715790250119395282425017818083421673278440118808474954552806007436370887232958142538070938460903011757636551318850215594111019699633958587914824512339681573953775134121488999147928038505883131989323638021781157246124428000084118138446325126739005521403114471077697023469488488105229388102971903306007555362613775010306064798678761753948810755236011346132218974049446116094394433461746597812371697367173395113014824646850943586174124632464143L,
1989666736598081965365973787349938627625613245335951894925228395719349924579514682166704542464221001327015131231101009506582078440087637470784673000661958376397578391397303146171320274531265903747455382524598808613766406694744319576824028880703970997080651320662468590292703565426391011134523391035995750230341849776175803186815053305823053143914398318121693692044542134832809759905437953710838534372887584358442203447387293183908262967797038874535690090799742911L,
133850088107174975861015682594827971956767368440585898108600141692889215241539178575381178799995195531301157505453120993980045956642227472649664668888717884598815932243844750408878011387532720932159839454554017574665882963054750224693505390054364096154711586190837517112644639757613967217614109546151313073865262488626822109764294618345504453742784825659007630866924661811701179640013729327586347L,
742665583685283032188129474839034185107068199926583417281240975739235100098517297493350864258177674271267050862217567671938790648634008735784684115797768392310253433978502694449565453913758801583487678024491118014887051643096970952295790434950566748516670079663712282848262006606082748685002561868381598918739708181310245226480020229450553192469536632519293406262550081671717685585065331112633947328611250435010734072352883491446355872734313855711051794348490960L
)
]
eg.g, eg.p, eg.x, eg.y = keys[random.randint(0, 1)]
return eg
# Otherwise, generate, really :)
return ElGamal.generate(1536, randfunc)
def test(module):
m = b"Hello! Welcome to 6260 Applied Cryptography :)"
# p = 2q + 1, both p, q is prime
elg = ElGamal.generate(256, Random.new().read)
(r, s), k = sign(elg, m)
q = (elg.p - 1) // 2
adv_x, adv_k = module.A({
"p": int(elg.p),
"q": int(q),
"s": s,
"r": r,
"y": int(elg.y),
"h": SHA1.new(m).hexdigest(),
"g": int(elg.g),
"m": m.decode()
})
return {
"status": "success" if elg.x % q == adv_x and k == adv_k else "failure"
}
def gen(args):
name = unicode(raw_input("Please enter your preferred username: "))
with open('identity', 'w') as f:
f.write(name.encode('utf-8'))
if args.key_size:
el_gamal = ElGamal.generate(args.key_size, Random.new().read)
elif args.parameter_from:
parameters = [
int(value) for value in args.parameter_from.read().splitlines()
]
assert len(parameters) >= 2
p = parameters[0]
g = parameters[1]
x = random.randint(1 + 1, p - 1 - 1)
y = pow(g, x, p)
el_gamal = ElGamal.construct((p, g, y, x))
else:
raise RuntimeError
with open(name, 'w') as f:
f.write(export_elgamal_key(el_gamal))
with open(name + '.pub', 'w') as f:
f.write(export_elgamal_key(el_gamal.publickey()))
def test_elgamal(self):
'''Test ElGamal algorithm'''
# Based on
# http://stackoverflow.com/questions/4232389/signing-and-verifying-data-using-pycrypto-rsa
# Generates a fresh public/private key pair
key = ElGamal.generate(1024, os.urandom)
# Sign the hash
K = getPrime(128, os.urandom)
while GCD(K, key.p - 1) != 1:
K = getPrime(128, os.urandom)
signature = key.sign(self.hash, K)
# Get public key
pubkey = key.publickey()
result = 'Could not verify signature'
self.assertTrue(pubkey.verify(self.hash, signature), result)
result = 'Succesfully verified bad hash!!'
self.assertFalse(pubkey.verify(self.hash[:-1], signature), result)
def generate_elgamal_keypair():
"""Return an ElGamal object with newly generated keypair"""
return ElGamal.generate(1536, randfunc)
return r
def findQR(p):
r = Crypto.Random.random.randrange(2, p - 1)
return pow(r, 2, p)
"""
Main
"""
if __name__ == '__main__':
try:
while True:
key = ElGamal.generate(512, Random.new().read)
runs = 1000
successful_tries = 0
send_message('(y, p) = ({0}, {1})'.format(key.y, key.p))
for i in xrange(runs):
plaintexts = dict()
plaintexts[0] = findQNR(key.p)
plaintexts[1] = findQR(key.p)
challenge_bit = Crypto.Random.random.randrange(0, 2)
eprint('[{0}][INFO] Bit {1} was generated.'.format(
time.strftime("%Y-%m-%d. %H:%M:%S"), challenge_bit))
r = Crypto.Random.random.randrange(1, key.p - 1)
challenge = key.encrypt(plaintexts[challenge_bit], r)
def gen_key(self):
self.key = CryptoElGamal.generate(self.key_size, Random.new().read)
def genk(self):
self.k = ElGamal.generate(self.bits, Random.new().read)
return self.k
def generate_key(cls, bitlength):
key = ElGamal.generate(bitlength, Random.new().read)
return cls(key)
def keyGen(security):
key = ElGamal.generate(2 * security, Random.new().read)
return key
from Crypto.PublicKey import ElGamal
from Crypto import Random
import cPickle as Pickle
v_priv_key = ElGamal.generate(128, Random.new().read)
v_pub_key = v_priv_key.publickey()
s_priv_key = ElGamal.generate(128, Random.new().read)
s_pub_key = s_priv_key.publickey()
Pickle.dump(v_priv_key, open("vending_key.priv", 'w'))
Pickle.dump(v_pub_key, open("vending_key.pub", 'w'))
Pickle.dump(s_priv_key, open("server_key.priv", 'w'))
Pickle.dump(s_pub_key, open("server_key.pub", 'w'))
def __init__(self, length):
self.key = ElGamal.generate(length, Random.new().read)
self.p = self.key.p
self.g = self.key.g
self.h = self.key.y
self.x = self.key.x
from os.path import dirname, isfile, join
from Crypto import Random
from Crypto.PublicKey import ElGamal
BASE_DIR = dirname(__file__)
MASTER_NODE = "100.100.100.111:8000"
NODES = ["100.100.%s.10:8000" % i for i in range(1, 11)]
NODES.insert(0, MASTER_NODE)
KEY_FILE = "key.dat"
if isfile(join(BASE_DIR, KEY_FILE)):
with open(join(BASE_DIR, KEY_FILE)) as f:
PRIVATE_KEY = f.read()
else:
key = ElGamal.generate(1024, Random.new().read)
PRIVATE_KEY = ",".join(map(str, [key.p, key.g, key.y, key.x]))
with open(join(BASE_DIR, KEY_FILE), "w") as f:
f.write(PRIVATE_KEY)
MAX_CODE_SIZE = 4096
INTERVAL = 15
PORT = 8000
DB_SETTINGS = {
"host": "db",
"database": "smoothychain",
"user": "******",
"password": "******"
def decode_message(m):
return number.long_to_bytes(m)
def encrypt(m):
pt = encode_message(m)
return pubkey.encrypt(pt, K)
def recvline(req):
buf = b""
while not buf.endswith(b"\n"):
buf += req.recv(1)
return buf
print("Now generating keys...")
privkey = ElGamal.generate(384, urandom)
pubkey = privkey.publickey()
(p, g, y) = (pubkey.p, pubkey.g, pubkey.y)
K = number.getPrime(128, urandom)
while number.GCD(K, p-1) != 1:
print("[-] K not relatively prime with {}".format(p-1))
K = number.getPrime(128, urandom)
print("Encrypting FLAG...")
c1, c2 = encrypt(FLAG)
print("Done!")
def gen_key(self, key_len=4096):
self.key = ElGamal.generate(key_len, Random.new().read)
args = parser.parse_args()
print int(args.k)
def exp_and_sqr(m, sk, mod_N):
r = 1
bits = "{0:b}".format(sk)
for i, bit in enumerate(bits):
if bit == '1':
r = (((r**2) * m) % mod_N)
else:
r = ((r**2) % mod_N)
return r % mod_N
key = El.generate(int(args.k), Random.new().read)
#key=El.generate(2048, Random.new().read)
print "p is: ", int(key.p)
print "g is: ", int(key.g)
#print "sk is: ", int(key.x)
#print "pk is: ", int(key.y)
#print "============"
#print exp_and_sqr(int(key.g), int(key.x), int(key.p))
p = int(key.p)
g = int(key.g)
sk = int(key.x)
pk = int(key.y)
bastion = {}
bastion['p'] = p
bastion['g'] = g
def __init__(self):
super(ELGamal, self).__init__()
self.key = ElGamal.generate(1024, Random.new().read)
self.k = random.StrongRandom().randint(1, self.key.p - 1)
def genk(self):
self.k = ElGamal.generate(self.bits, Random.new().read)
return self.k
from Crypto.Hash import SHA
import ast
import numpy as np
import matplotlib.pyplot as plt
from array import *
from datetime import datetime
import time
plt.rc('font', family='Verdana')
entime = array('d')
detime = array('d')
x = np.arange(1, 100, 1)
for i in range(1, 100):
random_generator = Random.new().read
key = ElGamal.generate(24, Random.new().read) #generate pub and priv key
publickey = key.publickey() # pub key export for exchange
msg = "InternetofThingsIoTis the future"
first = datetime.now().microsecond
encrypted = publickey.encrypt(msg, 32)
delta = (datetime.now().microsecond - first)
entime.append(delta)
time.sleep(0.001)
#decrypted code below
first = datetime.now().microsecond
decrypted = key.decrypt(ast.literal_eval(str(encrypted)))
delta = (datetime.now().microsecond - first)
detime.append(delta)
# Take the private input from Alice
x = int(input("Enter your integer: "))
# If the number is negative exit the system
if x < 0:
sys.exit("You entered a negative number")
# Calculate the binary and then reverse the binary string
# for ease of indexing
x = bin(x)[2:]
x = x[::-1]
# Generate the Elgamal key and print the time requires to do so
start = time()
key = ElGamal.generate(256, Random.new().read)
print("Time taken to generate the key:", time() - start, "seconds")
# Prepare a 2 x n table named T
# T[xi, i] = E(1)
# T[xi', i] = E(r)
T0 = []
T1 = []
for i in range(len(x)):
while 1:
k = random.StrongRandom().randint(1, key.p - 1)
if GCD(k, key.p - 1) == 1:
break
r = random.StrongRandom().randint(1, key.p - 1)
if x[i] == '0':
T0.append(key.encrypt(1, k))
