"""
Perceive Cryptography Algorythm In Python 2.7
Perform a series of Diffie-Hellman exchanges to
perceive a common data point without communicating it
then use this data point as the modulo for encryption,
signing, establishment of SSL-like channels via shared
Pseudeo-random Number Generation, and exploration of
periodic elements [with a grain of salt]
 
This Software Is Licensed As Sharia Law
"""
import hashlib
import random
from binascii import hexlify # For debug output
import json
import sys
 
# If a secure random number generator is unavailable, exit with an error.
try:
    import ssl
    random_function = ssl.RAND_bytes
    random_provider = "Python SSL"
except (AttributeError, ImportError):
    import OpenSSL
    random_function = OpenSSL.rand.bytes
    random_provider = "OpenSSL"

def xor(data, key):
    return bytearray(a^b for a, b in zip(*map(bytearray, [data, key])))

def quad(a, x, b, c):
    blocksize = x.bit_length() // 8 + 1
    blocks = [a[i:i+blocksize] for i in range(0, len(a), blocksize)]
    y = bytearray()
    pseudo = pow(x, b, c)
    for i in range(len(blocks)):
        pseudo = pow(pseudo, b, c)
        y += xor(blocks[i], to_bytes(pseudo, pseudo.bit_length() // 8 + 1, byteorder="big"))
    return y
 
def to_bytes(n, length, byteorder="big"):
    h = '%x' %n
    s = ('0'*(len(h) % 2) + h).zfill(length*2).decode('hex')
    return s if byteorder =='big' else s[::-1]
 
class DiffieHellman(object):
    """
   A reference implementation of the Diffie-Hellman protocol.
   By default, this class uses 1536-bit MODP Group From RFC3526.
   """
 
    def __init__(self, privateKey=None, keyLength=2048):
        """
       Generate the public and private keys.
       """
        min_keyLength = 180
        self.diffie_base = 481 # base g from Diffie's protocol
        self.starter_base    = 5
        self.starter_prime   = 733
        self.__fingerprint   = None
        self.__secret        = random.randint(1,sys.maxint)
        self.__g_po          = None
        self.__g_pO          = None
        self.__g_Po          = None
        self.__ephemeralKey  = None
        self.__initiator     = True
        self.publicKey       = None
 
        if(keyLength < min_keyLength):
            print("Error: keyLength is too small. Setting to minimum.")
            self.keyLength = min_keyLength
        else:
            self.keyLength = keyLength
 
        # RFC3526 1536-bit MODP Group
        self.prime = int('0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC7'
                         '4020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F1437'
                         '4FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDE'
                         'E386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598'
                         'DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED'
                         '529077096966D670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF', 16)
 
        if privateKey is None:
            self.privateKey = self.genPrivateKey(keyLength)
        else:
            self.privateKey = privateKey
        self.publicKey = self.genPublicKey() # regenerate this after establishBase()
 
    def establishBase(self, challenge=None):
        if challenge is None:
            return pow(self.starter_base, self.__secret, self.starter_prime)
        else:
            self.diffie_base = pow(challenge, self.__secret, self.starter_prime)
            self.genPublicKey() # regenerate public key after changing base
 
    def genPrivateKey(self, bits):
        """
       Generate a private key using a secure random number generator.
       """
        return self.genRandom(bits)
 
    def genPublicKey(self):
        """
       Generate a public key X with g**x % p.
       """
        return pow(self.diffie_base, self.privateKey, self.prime)
 
    def genRandom(self, bits):
        """
       Generate a random number with the specified number of bits
       """
        _rand = 0
        _bytes = bits // 8 + 8
 
        while(_rand.bit_length() < bits):
            try:
                # Python 3
                _rand = int.from_bytes(random_function(_bytes), byteorder='big')
            except:
                # Python 2
                _rand = int(OpenSSL.rand.bytes(_bytes).encode('hex'), 16)
 
        return _rand
 
    def genKey(self, otherKey):
        """
       Derive the shared secret, then hash it to obtain the shared key.
       """
        self.sharedSecret = self.genSecret(self.privateKey, otherKey)
 
        # Convert the shared secret (int) to an array of bytes in network order
        # Otherwise hashlib can't hash it.
        try:
            _sharedSecretBytes = self.sharedSecret.to_bytes(self.sharedSecret.bit_length() // 8 + 1, byteorder="big")
        except AttributeError:
            _sharedSecretBytes = str(self.sharedSecret)
 
        s = hashlib.sha256()
        s.update(bytes(_sharedSecretBytes))
        self.key = s.digest()
 
    def checkPublicKey(self, otherKey):
        """
       Check the other party's public key to make sure it's valid.
       Since a safe prime is used, verify that the Legendre symbol == 1
       """
        if(otherKey > 2 and otherKey < self.prime - 1):
            if(pow(otherKey, (self.prime - 1)//2, self.prime) == 1):
                return True
        return False
 
    def genSecret(self, privateKey, otherKey):
        """
       Check to make sure the public key is valid, then combine it with the
       private key to generate a shared secret.
       """
        if(self.checkPublicKey(otherKey) == True):
            sharedSecret = pow(otherKey, privateKey, self.prime)
            return sharedSecret
        else:
            raise Exception("Invalid public key.")
 
    def showParams(self):
        """
       Show the parameters of the Diffie Hellman agreement.
       """
        print("Parameters:")
        print("Prime[{0}]: {1}".format(self.prime.bit_length(), self.prime))
        print("Private key[{0}]: {1}\n".format(self.privateKey.bit_length(), self.privateKey))
        print("Public key[{0}]: {1}".format(self.publicKey.bit_length(), self.publicKey))
 
    def showResults(self):
        """
       Show the results of a Diffie-Hellman exchange.
       """
        print("Results:")
        print("Shared secret[{0}]: {1}".format(self.sharedSecret.bit_length(), self.sharedSecret))
        print("Shared key[{0}]: {1}".format(len(self.key), hexlify(self.key)))
 
    def getKey(self):
        """
       Return the shared secret key
       """
        return self.key
 
    def get_fingerprint(self):
        if self.__fingerprint:
            return self.__fingerprint
 
        publicKey = self.publicKey
        return self.__make_fingerprint(publicKey)
 
    def __make_fingerprint(self, pub_key):
        self.__fingerprint = self.__hash(pub_key)
        return self.__fingerprint
 
    def __hash(self, *values):
        """Hashes the concatenation of values
       each element in values must be of type int
       """
        s = hashlib.sha256()
        for value in values:
            try:
                value_bytes = to_bytes(value, value.bit_length() // 8 + 1, byteorder="big")
            except AttributeError:
                value_bytes = str(value)
 
            s.update(bytes(value_bytes))
        return s.digest()
 
    def establishAccord(self, party_ephemeral, party_signature=None):
        if party_signature is not None:
           self.handshake(party_ephemeral, party_signature)
 
    def getEphemeralPublicKey(self):
        return self.__ephemeralKey.publicKey
 
    def establishEphemeralListener(self):
        self.__ephemeralKey = DiffieHellman()
        self.__initiator = False
 
    def handshake(self, party_ephemeral, party_signature):
        if self.__initiator:
            self.__ephemeralKey = DiffieHellman()
        fingerprint = self.__make_fingerprint(party_signature)
        self.__ephemeralKey.genKey(party_ephemeral)
        self.__g_po = self.__ephemeralKey.getSecret()
        self.__ephemeralKey.genKey(party_signature)
        self.__g_pO = self.__ephemeralKey.getSecret()
 
        self.genKey(party_ephemeral)
        self.__g_Po = self.getSecret()
 
        self.__make_secret()
 
    def getSecret(self):
        """
       Return the preHashed key
       """
        return self.sharedSecret
 
    def __make_secret(self):
        if self.__initiator:
            self.__secret = self.__hash(self.__g_po, self.__g_pO, self.__g_Po)
        else:
            self.__secret = self.__hash(self.__g_po,self.__g_Po, self.__g_pO)
 
    def get_secret(self):
        return self.__secret
 
if __name__=="__main__":
    """
   Run an example Diffie-Hellman exchange
   """
    a = DiffieHellman()
    b = DiffieHellman()
    a_challenge = a.establishBase()
    b_challenge = b.establishBase()
    a.establishBase(b_challenge)
    b.establishBase(a_challenge)
    print("Established Modulo", a.diffie_base)
 
    b.establishEphemeralListener()
    a.genPublicKey()
    b.genPublicKey()
 
    a.genKey(b.publicKey)
    b.genKey(a.publicKey)
 
#    a.showParams()
#    a.showResults()
#    b.showParams()
#    b.showResults()
 
    if(a.getKey() == b.getKey()):
        print("Shared keys match.")
        print("Key:", hexlify(a.key))
        a_absoluteZero = int(a.getKey().encode('hex'), 16)
        b_absoluteZero = int(b.getKey().encode('hex'), 16)
    else:
        print("Shared secrets didn't match!")
        print("Shared secret A: ", a.genSecret(b.publicKey))
        print("Shared secret B: ", b.genSecret(a.publicKey))
 
    a.establishAccord(b.getEphemeralPublicKey(), b.publicKey)
    b.establishAccord(a.getEphemeralPublicKey(), a.publicKey)
    if(a.get_secret() == b.get_secret()):
        print("Shared secrets match.")
        print("Key:", hexlify(a.get_secret()))
        a_oxygen = int(a.get_secret().encode('hex'), 16)
        b_oxygen = int(b.get_secret().encode('hex'), 16)
    else:
        print("Shared secrets didn't match!")
        print("Shared secret A: ", a.get_secret())
        print("Shared secret B: ", b.get_secret())
 
    a.establishAccord(b.getEphemeralPublicKey(), b.publicKey)
    b.establishAccord(a.getEphemeralPublicKey(), a.publicKey)
    if(a.get_secret() == b.get_secret()):
        print("Shared secrets match.")
        print("Key:", hexlify(a.get_secret()))
        a_oxygen = int(a.get_secret().encode('hex'), 16)
        b_oxygen = int(b.get_secret().encode('hex'), 16)
    else:
        print("Shared secrets didn't match!")
        print("Shared secret A: ", a.get_secret())
        print("Shared secret B: ", b.get_secret())
 
    a_carbon = pow(a.diffie_base, a.privateKey, a_oxygen) 
    b_carbon = pow(b.diffie_base, b.privateKey, b_oxygen) # carbon-like
#    b_carbon = a_carbon # If they share one world
    a_lithium = pow(b_carbon, a.privateKey, a_oxygen) # it oxidizes
    b_lithium = pow(a_carbon, b.privateKey, b_oxygen)
#    b_lithium = a_lithium # If they share one galaxy
 
    a_helium = int("Hello World".encode('hex'), 16)
    a_sodium = pow(a_absoluteZero, a_lithium, a_oxygen)
    a_potassium = pow(a_sodium, a_lithium, a_oxygen)
    a_boron = pow(a_potassium, a_helium, a_sodium)
    a_beryllium = pow(a_boron, a_lithium, a_sodium)
 
    b_sodium = pow(b_absoluteZero, b_lithium, b_oxygen)
    b_potassium = pow(b_sodium, b_lithium, b_oxygen)
    b_boron = pow(b_potassium, a_helium, b_sodium) # B is just a listener to the msg here exactly like Eve
    b_beryllium = pow(b_boron, b_lithium, b_sodium)
 
    a_fluorine = pow(a_boron, a.privateKey, a.publicKey) # Prove To The Demon That The Signs Are Different
    b_fluorine = pow(a_boron, b.privateKey, a.publicKey) 
    b_magnesium = pow(a_fluorine, b.privateKey, a.publicKey)
    a_magnesium = pow(b_fluorine, a.privateKey, a.publicKey)
 
    if(a_magnesium == b_magnesium):
        print("Shared signature verifier A matches.")
        print("Key: {}".format(hex(a_magnesium)))
    else:
        print("Shared signature verifiers didn't match!")
        print("Shared signature A: ", a_magnesium)
        print("Shared signature B: ", b_magnesium)
 
    b_fluorine = pow(b_boron, b.privateKey, b.publicKey) # Prove To The Demon That The Signs Are Different
    a_fluorine = pow(b_boron, a.privateKey, b.publicKey) 
    a_magnesium = pow(b_fluorine, a.privateKey, b.publicKey)
    b_magnesium = pow(a_fluorine, b.privateKey, b.publicKey)

    a_magnesium2 = pow(a_magnesium, a.publicKey, b.publicKey)
    a_magnesium3 = pow(a_magnesium, b.publicKey, a.publicKey)
    b_magnesium2 = pow(b_magnesium, a.publicKey, b.publicKey)
    b_magnesium3 = pow(b_magnesium, b.publicKey, a.publicKey)

    a_aluminum = pow(a_magnesium, a_magnesium2, a_magnesium3)
    b_aluminum = pow(b_magnesium, b_magnesium2, b_magnesium3)

    if(a_aluminum == b_aluminum):
        print("Aluminum Rectifier matches.")
        print("Key: {}".format(hex(a_aluminum)))
    else:
        print("Aluminum Rectifier didn't match!")
        print("Rectifier A: ", a_aluminum)
        print("Rectifier B: ", b_aluminum)

    a_pseudo = pow(a_aluminum, a_potassium, a_boron)
    b_pseudo = pow(b_aluminum, b_potassium, b_boron)
    for i in range(2220): # Verify pseudo-random numbers
        a_pseudo = pow(a_pseudo, a_potassium, a_boron)
        b_pseudo = pow(b_pseudo, b_potassium, b_boron)
        if(a_pseudo == b_pseudo):
            print("Pseudorandom generator {} matches.".format(i))
            print("Key: {}".format(hex(a_pseudo)))
        else:
            print("Pseudorandom generator {} didn't match!".format(i))
            print("Pseudorandom A: ", a_pseudo)
            print("Pseudorandom B: ", b_pseudo)

    if(a_magnesium == b_magnesium):
        print("Shared signature verifier B matches.")
        print("Key: {}".format(hex(b_magnesium)))
    else:
        print("Shared signature verifiers didn't match!")
        print("Shared signature A: ", a_magnesium)
        print("Shared signature B: ", b_magnesium)
 
    print("sodium: {}\n{}".format(a_sodium, b_sodium))
    print("beryllium: {}\n{}".format(a_beryllium, b_beryllium))
    print("lithium: {}\n{}".format(a_lithium, b_lithium))
    print("potassium: {}\n{}".format(a_potassium, b_potassium))
    print("boron: {}\n{}".format(a_boron, b_boron))

    a_sulfur = pow(a_potassium, a_oxygen, a_sodium)  # We Are At The 7th Numeric Integral Here
    a_nitrogen = pow(a_sulfur, a_oxygen, a_sodium)
    b_sulfur = pow(b_potassium, b_oxygen, b_sodium)  # We Are At The 7th Numeric Integral Here
    b_nitrogen = pow(a_nitrogen, b_oxygen, b_sodium)
    print("sulfur: {}\n{}".format(a_sulfur, b_sulfur))
    print("nitrogen: {}\n{}".format(a_nitrogen, b_nitrogen))
    print(pow(a_nitrogen, a_sulfur, b_nitrogen))
    print(pow(b_nitrogen, a_sulfur, a_sodium))
    exit()

    a_helium = int("Hello World 1".encode('hex'), 16)
    a_silicon = pow(a_absoluteZero, a_nitrogen, a_oxygen) 
    a_phosphorous = pow(a_silicon, a_nitrogen, a_oxygen) 
    a_chlorine = pow(a_phosphorous, a_helium, a_silicon)
    a_argon = pow(a_chlorine, a_nitrogen, a_silicon) # First Soft Metal

    b_hydrogen = pow(b_magnesium, 411, b_sodium)  # We Are At The 7th Numeric Integral Here
    b_nitrogen = pow(b_hydrogen, 411, b_sodium)

    b_helium = int("Hello Other World 1".encode('hex'), 16)
    b_silicon = pow(b_absoluteZero, b_nitrogen, b_oxygen) 
    b_phosphorous = pow(b_silicon, b_nitrogen, b_oxygen) 
    b_chlorine = pow(b_phosphorous, b_helium, b_silicon)
    b_argon = pow(b_chlorine, b_nitrogen, b_silicon) # First Soft Metal

# Eighth Numeric Integral - A & B did not agree on a carbon so none of these should match
    a_potassium = pow(a_absoluteZero, a_carbon, a_silicon)
    a_calcium = pow(a_potassium, a_carbon, a_silicon)
    a_scandium = pow(a_nitrogen, a_carbon, a_silicon)
    a_titanium = pow(a_scandium, a_carbon, a_silicon)
    a_vanadium = pow(a_argon, a_carbon, a_silicon)
    a_chromium = pow(a_vanadium, a_carbon, a_silicon)
    a_manganese = pow(a_magnesium, a_carbon, a_silicon)
    a_iron = pow(a_manganese, a_carbon, a_silicon)

    b_potassium = pow(b_absoluteZero, b_carbon, b_silicon)
    b_calcium = pow(b_potassium, b_carbon, b_silicon)
    b_scandium = pow(b_nitrogen, b_carbon, b_silicon)
    b_titanium = pow(b_scandium, b_carbon, b_silicon)
    b_vanadium = pow(b_argon, b_carbon, b_silicon)
    b_chromium = pow(b_vanadium, b_carbon, b_silicon)
    b_manganese = pow(b_magnesium, b_carbon, b_silicon)
    b_iron = pow(b_manganese, b_carbon, b_silicon)

    print("potassium: {}\n{}".format(a_potassium, b_potassium))
    print("calcium: {}\n{}".format(a_calcium, b_calcium))
    print("scandium: {}\n{}".format(a_scandium, b_scandium))
    print("titanium: {}\n{}".format(a_titanium, b_titanium))
    print("vanadium: {}\n{}".format(a_vanadium, b_vanadium))
    print("chromium: {}\n{}".format(a_chromium, b_chromium))
    print("manganese: {}\n{}".format(a_manganese, b_manganese))
    print("iron: {}\n{}".format(a_iron, b_iron))

    a_cobalt = pow(a_absoluteZero, a_carbon, a_argon)
    a_nickel = pow(a_cobalt, a_carbon, a_argon)
    b_cobalt = pow(b_absoluteZero, b_carbon, b_argon)
    b_nickel = pow(b_cobalt, b_carbon, b_argon)
    print("cobalt: {}\n{}".format(a_cobalt, b_cobalt))
    print("nickel: {}\n{}".format(a_nickel, b_nickel))

    a_copper = pow(a_manganese, a_calcium, a_scandium)
    b_copper = pow(b_manganese, b_calcium, b_scandium)
    a_zinc = pow(a_copper, a_calcium, a_scandium)
    b_zinc = pow(b_copper, b_calcium, b_scandium)
    print("copper: {}\n{}".format(a_copper, b_copper))
    print("zinc: {}\n{}".format(a_zinc, b_zinc))

    a_gallium = pow(a_zinc, b_cobalt, a_nitrogen)
    a_germanium = pow(a_gallium, b_cobalt, a_nitrogen)
    b_gallium = pow(b_zinc, a_cobalt, b_nitrogen)
    b_germanium = pow(b_gallium, a_cobalt, b_nitrogen)
    print("gallium: {}\n{}".format(a_gallium, b_gallium))
    print("germanium: {}\n{}".format(a_germanium, b_germanium))

# Experiments Below

    b_sulfur = pow(pow(b_phosphorous, b_nitrogen, b_silicon), b_nitrogen, b_silicon) 
    a_sulfur = pow(pow(a_phosphorous, a_nitrogen, a_silicon), a_nitrogen, a_silicon)

    if(a_sulfur == b_sulfur):
        print("Sulfur Generation 1 Matches.")
        print("Key: {}".format(hex(b_sulfur)))
    else:
        print("Sulfur verifiers didn't match!")
        print("Dumb Wire A: ", a_sulfur)
        print("Dumb Wire B: ", b_sulfur)
 
    print("silicon: {}\n{}".format(a_silicon, b_silicon))
    print("argon: {}\n{}".format(a_argon, b_argon))
    print("nitrogen: {}\n{}".format(a_nitrogen, b_nitrogen))
    print("phosphorous: {}\n{}".format(a_phosphorous, b_phosphorous))
    print("chlorine: {}\n{}".format(a_chlorine, b_chlorine))

    exit()

    b_sulfur2 = pow(b_phosphorous, b_sulfur, b_silicon) 
    a_sulfur2 = pow(a_phosphorous, a_sulfur, a_silicon)

    if(a_sulfur2 == b_sulfur2):
        print("Sulfur Generation 2 Matches.")
        print("Key: {}".format(hex(b_sulfur2)))
    else:
        print("Sulfur verifiers didn't match!")
        print("Dumb Wire A: ", a_sulfur2)
        print("Dumb Wire B: ", b_sulfur2)
 
    b_sulfur3 = pow(b_phosphorous, b_sulfur2, b_silicon) 
    a_sulfur3 = pow(a_phosphorous, a_sulfur2, a_silicon)

    if(a_sulfur3 == b_sulfur3):
        print("Sulfur Generation 3 Matches.")
        print("Key: {}".format(hex(b_sulfur3)))
    else:
        print("Damped Wire verifiers didn't match!")
        print("Dumb Wire A: ", a_sulfur3)
        print("Dumb Wire B: ", b_sulfur3)

    a_dN = pow(a_silicon, a_oxygen, a_sulfur3)
    a_dD = pow(a_silicon, a_oxygen, a_sulfur2)
    b_dN = pow(b_silicon, b_oxygen, b_sulfur3)
    b_dD = pow(b_silicon, b_oxygen, b_sulfur2)

    print(a_dN)
    print(a_dD)
    print(b_dN)
    print(b_dD)
	
    a_gN = pow(a_dN, a_oxygen, a_sulfur3)
    a_gD = pow(a_dD, a_oxygen, a_sulfur2)
    b_gN = pow(b_dN, b_oxygen, b_sulfur3)
    b_gD = pow(b_dD, b_oxygen, b_sulfur2)

    print(a_gN)
    print(a_gD)
    print(b_gN)
    print(b_gD)

    a_rN = pow(a_gN, a_hydrogen, a_nitrogen)   
    a_rD = pow(a_gD, a_hydrogen, a_nitrogen)   
    b_rN = pow(b_gN, b_hydrogen, b_nitrogen)   
    b_rD = pow(b_gD, b_hydrogen, b_nitrogen) 

    print(pow(a_rN, a_hydrogen, a_nitrogen))  
    print(pow(a_rD, a_hydrogen, a_nitrogen))  
    print(pow(b_rN, b_hydrogen, b_nitrogen))  
    print(pow(b_rD, b_hydrogen, b_nitrogen))  

    a_germanium = pow(a_silicon, a_hydrogen, a_sulfur)
    b_germanium = pow(b_silicon, b_hydrogen, b_sulfur)
    a_tin = pow(a_germanium, a_hydrogen, a_sulfur)
    b_tin = pow(b_germanium, b_hydrogen, b_sulfur)
    a_lead = pow(a_tin, a_hydrogen, a_sulfur)
    a_puter = pow(a_lead, a_tin, a_sulfur)
    b_lead = pow(b_tin, b_hydrogen, b_sulfur)
    b_puter = pow(b_lead, b_tin, b_sulfur)
    
    print(a_puter)
    print(b_puter)
    print(pow(a_puter, a_tin, a_lead))
    print(pow(b_puter, b_tin, b_lead))
    print(pow(a_germanium, a_tin, a_lead))
    print(pow(b_germanium, b_tin, b_lead)) # Equality Proves That A & B Share A Moon

    print(pow(pow(a_carbon, a_magnesium, a_nitrogen), a_magnesium, a_nitrogen))
    print(pow(pow(b_carbon, a_magnesium, b_nitrogen), a_magnesium, a_nitrogen))