Exemplo n.º 1
0
def test():
    import _sha512

    a_str = "just a test string"

    assert _sha512.sha512().hexdigest() == sha512().hexdigest()
    assert _sha512.sha512(a_str).hexdigest() == sha512(a_str).hexdigest()
    assert _sha512.sha512(a_str*7).hexdigest() == sha512(a_str*7).hexdigest()

    s = sha512(a_str)
    s.update(a_str)
    assert _sha512.sha512(a_str+a_str).hexdigest() == s.hexdigest()
Exemplo n.º 2
0
def test():
    import _sha512

    a_str = b"just a test string"

    assert _sha512.sha512().hexdigest() == sha512().hexdigest()
    assert _sha512.sha512(a_str).hexdigest() == sha512(a_str).hexdigest()
    assert _sha512.sha512(a_str * 7).hexdigest() == sha512(a_str *
                                                           7).hexdigest()

    s = sha512(a_str)
    s.update(a_str)
    assert _sha512.sha512(a_str + a_str).hexdigest() == s.hexdigest()
Exemplo n.º 3
0
    def OnButtonCheck1(self, event):
        src = str(self.inputN.GetValue().encode('utf8'))
        m1 = md5.new()
        m1.update(src)
        self.Md5.SetValue(m1.hexdigest().decode('utf8'))

        m2 = _sha.new()
        m2.update(src)
        self.sha1.SetValue(m2.hexdigest().decode('utf8'))

        m3 = _sha256.sha224()
        m3.update(src)
        self.sha224.SetValue(m3.hexdigest().decode('utf8'))

        m4 = _sha256.sha256()
        m4.update(src)
        self.sha256.SetValue(m4.hexdigest().decode('utf8'))

        m5 = _sha512.sha384()
        m5.update(src)
        self.sha384.SetValue(m5.hexdigest().decode('utf8'))

        m6 = _sha512.sha512()
        m6.update(src)
        self.sha512.SetValue(m6.hexdigest().decode('utf8'))
Exemplo n.º 4
0
    def OnButtonCheckED(self, event):
        c = 'utf8'
        dlg = str(self.inputD.GetValue())
        with open(dlg, 'rb') as EDfile:
            p = EDfile.read()
        src = str(p)
        m1 = md5.new()
        m1.update(src)
        self.Md5.SetValue(m1.hexdigest().decode(c))

        m2 = _sha.new()
        m2.update(src)
        self.sha1.SetValue(m2.hexdigest().decode(c))

        m3 = _sha256.sha224()
        m3.update(src)
        self.sha224.SetValue(m3.hexdigest().decode(c))

        m4 = _sha256.sha256()
        m4.update(src)
        self.sha256.SetValue(m4.hexdigest().decode(c))

        m5 = _sha512.sha384()
        m5.update(src)
        self.sha384.SetValue(m5.hexdigest().decode(c))

        m6 = _sha512.sha512()
        m6.update(src)
        self.sha512.SetValue(m6.hexdigest().decode(c))
 def OnButtonCheckED(self, event):
     c = 'utf8'
     dlg = str(self.inputD.GetValue())
     with open(dlg,'rb') as EDfile:
         p = EDfile.read()
     src = str(p)
     m1 = md5.new()   
     m1.update(src)
     self.Md5.SetValue(m1.hexdigest().decode(c))
     
     m2 = _sha.new()   
     m2.update(src)   
     self.sha1.SetValue(m2.hexdigest().decode(c))
     
     m3 = _sha256.sha224()
     m3.update(src)   
     self.sha224.SetValue(m3.hexdigest().decode(c))
     
     m4 = _sha256.sha256()
     m4.update(src)   
     self.sha256.SetValue(m4.hexdigest().decode(c))
     
     m5 = _sha512.sha384()
     m5.update(src) 
     self.sha384.SetValue(m5.hexdigest().decode(c))  
     
     m6 = _sha512.sha512() 
     m6.update(src)   
     self.sha512.SetValue(m6.hexdigest().decode(c))
 def OnButtonCheck1(self, event):
     src = str(self.inputN.GetValue().encode('utf8'))
     m1 = md5.new()   
     m1.update(src)
     self.Md5.SetValue(m1.hexdigest().decode('utf8'))
     
     m2 = _sha.new()   
     m2.update(src)   
     self.sha1.SetValue(m2.hexdigest().decode('utf8'))
     
     m3 = _sha256.sha224()
     m3.update(src)   
     self.sha224.SetValue(m3.hexdigest().decode('utf8'))
     
     m4 = _sha256.sha256()
     m4.update(src)   
     self.sha256.SetValue(m4.hexdigest().decode('utf8'))
     
     m5 = _sha512.sha384()
     m5.update(src) 
     self.sha384.SetValue(m5.hexdigest().decode('utf8'))  
     
     m6 = _sha512.sha512() 
     m6.update(src)   
     self.sha512.SetValue(m6.hexdigest().decode('utf8'))
 def generateVerificationCodeChallenge(verification_code: str) -> str:
     """
     Generates a base64 encoded sha512 encrypted version of a given string.
     :param verification_code:
     :return: The encrypted code in base64 format.
     """
     encoded = sha512(verification_code.encode()).digest()
     return b64encode(encoded, altchars=b"_-").decode()
Exemplo n.º 8
0
def create_browser_id():
    agent = request.headers.get('User-Agent')
    if not agent:
        agent = str(agent).encode('utf-8')
    base_str = "%s|%s" % (get_remote_addr(), agent)
    h = sha512()
    h.update(base_str.encode('utf8'))
    return h.hexdigest()
Exemplo n.º 9
0
 def test_sha512_sanity(self):
     x = _sha512.sha512()
     self.assertEqual(x.block_size, 128)
     self.assertEqual(x.digest(),
             "\xcf\x83\xe15~\xef\xb8\xbd\xf1T(P\xd6m\x80\x07\xd6 \xe4\x05\x0bW\x15\xdc\x83\xf4\xa9!\xd3l\xe9\xceG\xd0\xd1<]\x85\xf2\xb0\xff\x83\x18\xd2\x87~\xec/c\xb91\xbdGAz\x81\xa582z\xf9'\xda>")
     self.assertEqual(x.digest_size, 64)
     self.assertEqual(x.digest_size, x.digestsize)
     self.assertEqual(x.hexdigest(),
             'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e')
     self.assertEqual(x.name, "SHA512")
     x.update("abc")
     self.assertEqual(x.hexdigest(),
             'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f')
     
     x_copy = x.copy()
     self.assertTrue(x!=x_copy)
     self.assertEqual(x.hexdigest(), x_copy.hexdigest())
Exemplo n.º 10
0
def _create_identifier():
    """
    To create a session id using the user agent, remote addr

    Encodes the generated using sha512
    Adds a random unique ID with encoded data
    :return:
    """
    user_agent = request.headers.get('User-Agent')
    if user_agent is not None:
        user_agent = user_agent.encode('utf-8')
    base = '{0}|{1}'.format(_get_remote_addr(), user_agent)
    if str is bytes:
        base = text_type(base, 'utf-8', errors='replace')  # pragma: no cover
    h = sha512()
    h.update(base.encode('utf8'))
    return h.hexdigest() + str(uuid.uuid4())
Exemplo n.º 11
0
def test_sha512_sanity():
    x = _sha512.sha512()
    AreEqual(x.block_size, 128)
    AreEqual(x.digest(),
             "\xcf\x83\xe15~\xef\xb8\xbd\xf1T(P\xd6m\x80\x07\xd6 \xe4\x05\x0bW\x15\xdc\x83\xf4\xa9!\xd3l\xe9\xceG\xd0\xd1<]\x85\xf2\xb0\xff\x83\x18\xd2\x87~\xec/c\xb91\xbdGAz\x81\xa582z\xf9'\xda>")
    AreEqual(x.digest_size, 64)
    AreEqual(x.digest_size, x.digestsize)
    AreEqual(x.hexdigest(),
             'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e')
    AreEqual(x.name, "SHA512")
    x.update("abc")
    AreEqual(x.hexdigest(),
             'ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f')
    
    x_copy = x.copy()
    Assert(x!=x_copy)
    AreEqual(x.hexdigest(), x_copy.hexdigest())
def password_generator(credentials, n):
    
    # Generates sha512 hash
    hash = _sha512.sha512(credentials.encode()).hexdigest()

    lst = []
    
    # Pairs every two hexadecimal numbers.
    # Discards values greater than 196 and normalizes
    # remaining values in range 32 to 128 for
    # easy conversation to ascii.
    # Saves values in lst.  
    for i in range(0,128,2):
        j =  int(hash[i]+hash[i+1], 16)
        if 96 <= j < 192:
            lst.append(j - 66)
        elif j < 96:
            lst.append(j+30)
        
    # If number of usable values is less than needed
    # then start again with hash as new credentials.
    # If false output list will have charecters insted of numbers.
    if (len(lst) < n):
        lst = password_generator(hash, n)
    
    # Converts integers in list to their ASCII eqvivalant
    # and discards values after 'n' index.
    if type(lst[0]) != str:
        for i in range(n):
            lst[i] = str(chr(lst[i]))
        lst = lst[:n]

    # Checks if password have upeercase, lowercase,
    # digit and special charecters.
    # If any is missing start again with hash as new input.
    if not (any(c.islower() for c in lst)
                and any(c.isupper() for c in lst)
                and any(c.isdigit() for c in lst)
                and any(isspecial(c) for c in lst)):
        lst = password_generator(hash, n)

    return lst
Exemplo n.º 13
0
 def __construct_merkel_tree(self, transactions):
     onward_transactions = []
     temp = None
     flag = True
     if transactions.__len__() == 1:
         self.__merkel_root = transactions[0]
         return
     if not transactions.__len__() % 2 == 0:
         transactions.append(transactions[-1])
     for transaction in transactions:
         if flag:
             temp = transaction
             flag = False
         else:
             flag = True
             string = temp.get_data() + transaction.get_data()
             data = sha512(string).hexdigest()
             node = MerkelNode(data)
             node.__left_child = temp
             node.__right_child = transaction
             onward_transactions.append(node)
     self.__construct_merkel_tree(onward_transactions)
Exemplo n.º 14
0
def gen_fn_hash(s):
    return sha512(s).hexdigest()
Exemplo n.º 15
0
def main():
    global desiredWorkload
    sha512 = _sha512.sha512()

    #Adjust desiredWorkload percentages to sum to 1
    sumPercentages = 0
    for workload in desiredWorkload:
        sumPercentages += desiredWorkload[workload]["traffic_percentage"]
    for workload in desiredWorkload:
        desiredWorkload[workload]["traffic_percentage"] /= sumPercentages
    del sumPercentages

    trafficJson = {"input": desiredWorkload, "workload": {}, "packets_n_sizes_formatting": {}}

    #For each desired application traffic
    for workload in desiredWorkload:
        #Create a new entry if one doesn't exist yet
        if workload not in trafficJson["workload"]:
            trafficJson["workload"][workload] = {"applications": {}}

        #Create traffic associated with a given application
        output = workload_generator[workload](**desiredWorkload[workload]["application_config"])

        #Calculate hash for the application
        outputJson = json.dumps(output)
        sha512.update(outputJson.encode())
        outputSha  = sha512.digest().__repr__()

        #Use the hash to address it
        trafficJson["workload"][workload]["applications"][outputSha] = output
        del outputJson


        #Convert whatever format it came from the charge_generator to a universal format for traffic injectors

        last_output_universal_traffic_format = {}
        time_accumulator = 0

        if workload == "iot":
            for i in range(len(output[0]["time_to_send"])):
                # Determine size of packet and time offset for when it should be transmitted
                last_output_universal_traffic_format[output[0]["time_to_send"][i]] = int(output[0]["packet_size"] + 1)
                pass
            pass
        elif workload == "voip":
            last_output_universal_traffic_format[time_accumulator] = int(output[0]["packet_size"]+1)

            for i in range(1, len(output[0]["time_between_packets"])):
                # Determine size of packet and time offset for when it should be transmitted
                last_output_universal_traffic_format[time_accumulator] = int(output[0]["packet_size"]+1)
                time_accumulator += output[0]["time_between_packets"][i - 1]
                pass
            pass
        elif workload == "stream":
            #Deal with first element and then proceed to others
            last_output_universal_traffic_format[time_accumulator] = int((output[0]["time_downloading"][0] * (
                        output[0]["video_codification"] / 8)) + 1)  # time downloading * byte rate

            for i in range(1, len(output[0]["time_downloading"])):
                #Determine size of packet and time offset for when it should be transmitted
                last_output_universal_traffic_format[time_accumulator] = int((output[0]["time_downloading"][i]*(output[0]["video_codification"]/8))+1) #time downloading * byte rate
                time_accumulator += output[0]["time_between_segments"][i-1]
                pass
            pass
        elif workload == "web":
            for i in range(len(output[0]["series"])):
                #Determine size of packet and time offset for when it should be transmitted
                last_output_universal_traffic_format[i] = int(output[0]["series"][i]+1) #bytes to download
                pass
            pass
        else:
            print("Something went pretty darn wrong")
            return -1

        trafficJson["packets_n_sizes_formatting"][(outputSha, workload)] = last_output_universal_traffic_format

        #Measure how many bytes were transmitted per application
        trafficJson["workload"][workload]["applications"][outputSha][0]["totalBytes"] = sum(last_output_universal_traffic_format.values())
        trafficJson["workload"][workload]["applications"][outputSha][0]["duration"] = sorted(list(last_output_universal_traffic_format.keys()))[-1]

        del outputSha, output, time_accumulator, last_output_universal_traffic_format
    del i, sha512

    #Measure overall traffic percentages for both applications and traffic workloads
    trafficTotalBytes = 0
    trafficTotalDuration = 0
    for workload in desiredWorkload:
        workloadTotalBytes = 0
        workloadTotalDuration = 0
        for application in trafficJson["workload"][workload]["applications"]:
            traffic  = trafficJson["workload"][workload]["applications"][application][0]["totalBytes"]
            duration = trafficJson["workload"][workload]["applications"][application][0]["duration"]
            workloadTotalBytes += traffic
            workloadTotalDuration += duration
        trafficTotalBytes += workloadTotalBytes
        trafficTotalDuration += workloadTotalDuration
        trafficJson["workload"][workload]["totalBytes"] = workloadTotalBytes
        trafficJson["workload"][workload]["duration"] = workloadTotalDuration
    del traffic

    maxDuration = 0
    for workload in desiredWorkload:
        for application in trafficJson["workload"][workload]["applications"]:
            trafficJson["workload"][workload]["applications"][application][0]["traffic_percentage"] = trafficJson["workload"][workload]["applications"][application][0]["totalBytes"]/trafficTotalBytes
        trafficJson["workload"][workload]["trafficPercentage"] = trafficJson["workload"][workload]["totalBytes"]/trafficTotalBytes
        maxDuration = trafficJson["workload"][workload]["duration"] if trafficJson["workload"][workload]["duration"] > maxDuration else maxDuration

    # Find application/workload with biggest gap to the expected traffic
    biggestPercentageGap = (0, None)
    for workload in desiredWorkload:
        gap = desiredWorkload[workload]["traffic_percentage"] - trafficJson["workload"][workload][
            "trafficPercentage"]
        if gap > biggestPercentageGap[0]:
            biggestPercentageGap = (gap, workload)

    #Adjust overall traffic to fit specified percentages
    iterations = 0
    while(biggestPercentageGap[0] > 0.001):
        iterations += 1
        workload = biggestPercentageGap[1]

        #If the application duration is not similar to the one with the maximum duration, randomly select a package from the already existing and append it
        if trafficJson["workload"][workload]["duration"] < (maxDuration*0.9):
            application = list(trafficJson["workload"][workload]["applications"])[0]

            packets = sorted(list(trafficJson["packets_n_sizes_formatting"][(application, workload)].items()))
            packets_to_copy = [int(random.gauss(len(packets), len(packets)) %len(packets)) for _ in range(10)]

            lastPacket = packets[-1]
            totalBytes = 0
            duration = 0
            for packet in packets_to_copy:
                currPacket = packets[packet]
                prevPacket = packets[(packet-1) % len(packets)]
                newPacket = (lastPacket[0]+(currPacket[0]-prevPacket[0]), currPacket[1])
                trafficJson["packets_n_sizes_formatting"][(application, workload)][newPacket[0]] = newPacket[1]
                packets.append(newPacket)
                totalBytes += newPacket[1]
                duration = newPacket[0]
                print()
                pass

            del newPacket, lastPacket, prevPacket, packets_to_copy, packets, currPacket, packet

            # Add sent bytes and replace with the new number
            trafficJson["workload"][workload]["totalBytes"] += totalBytes
            trafficJson["workload"][workload]["duration"] += duration

            # Update the total traffic bytes
            trafficTotalBytes += totalBytes

            # Recalculate the percentages for each workflow after the changes
            for workload in desiredWorkload:
                trafficJson["workload"][workload]["trafficPercentage"] = trafficJson["workload"][workload]["totalBytes"] / trafficTotalBytes
                pass
            pass
            del duration, application, totalBytes
        #If the application duration is similar to the one with the maximum duration, adjust packet sizes
        else:
            #assuming a single application per workload type
            multiplication_factor = desiredWorkload[workload]["traffic_percentage"]/trafficJson["workload"][workload]["trafficPercentage"]
            application = list(trafficJson["workload"][workload]["applications"])[0]
            totalBytes = 0

            #Adjust the byte size of packages by a multiplication factor
            for time_to_send in trafficJson["packets_n_sizes_formatting"][(application, workload)]:
                trafficJson["packets_n_sizes_formatting"][(application, workload)][time_to_send] *= multiplication_factor
                trafficJson["packets_n_sizes_formatting"][(application, workload)][time_to_send] += 1
                trafficJson["packets_n_sizes_formatting"][(application, workload)][time_to_send] = int(trafficJson["packets_n_sizes_formatting"][(application,workload)][time_to_send])
                totalBytes += trafficJson["packets_n_sizes_formatting"][(application, workload)][time_to_send]

            #Remove application old sent bytes and replace with the new number
            trafficJson["workload"][workload]["totalBytes"] -= trafficJson["workload"][workload]["applications"][application][0]["totalBytes"]
            trafficJson["workload"][workload]["totalBytes"] += totalBytes

            #Update the total traffic bytes
            #trafficJson["workload"][workload]["applications"][application][0]["totalBytes"] = totalBytes
            trafficTotalBytes -= trafficJson["workload"][workload]["applications"][application][0]["totalBytes"]
            trafficTotalBytes += totalBytes

            #Recalculate the percentages for each workflow after the changes
            for workload in desiredWorkload:
                trafficJson["workload"][workload]["trafficPercentage"] = trafficJson["workload"][workload]["totalBytes"]/trafficTotalBytes
                pass

            del multiplication_factor, application, totalBytes, time_to_send
            pass

        # Find application/workload with biggest gap to the expected traffic
        biggestPercentageGap = (0, None)
        for workload in desiredWorkload:
            gap = desiredWorkload[workload]["traffic_percentage"] - trafficJson["workload"][workload]["trafficPercentage"]
            if gap > biggestPercentageGap[0]:
                biggestPercentageGap = (gap, workload)
        pass
    del workload


    #Sort packet_n_sizes_formatting before dumping
    unsorted_traffic = trafficJson["packets_n_sizes_formatting"]
    sorted_traffic = {}
    for key, traffic in unsorted_traffic.items():
        sorted_traffic[key[0]] = sorted(list(traffic.items()))

    trafficJson["packets_n_sizes_formatting_sorted"] = sorted_traffic

    #Dump everything to a pickle
    with open("trafficJson.pickle", "wb") as fd:
        pickle.dump(trafficJson, fd)

    #And only the sorted and formatted traffic for the JSON
    with open("trafficJson.json", "w") as fd:
        json.dump(trafficJson["packets_n_sizes_formatting_sorted"], fd)

    print()
    pass
Exemplo n.º 16
0
    def post_parola_degistir(self):
        """Parola degistirme ekrani"""
        user = User.query.filter_by(id=current_user.get_id()).one()
        parola_form = PasswordChangeForm(request.form)

        if parola_form.validate():
            old_password = sha512(
                parola_form.old_password.data.encode()).hexdigest()
            new_password = sha512(
                parola_form.new_password.data.encode()).hexdigest()
            if current_user.password == old_password:
                try:
                    user.password = new_password
                    DB.session.commit()
                    flash(_("Parolanız güncellendi"))

                except SQLAlchemyError as error:
                    DB.session.rollback()
                    flash(
                        _("Parolanız güncellenirken bir hata oluştu. Girdiğiniz bilgileri lütfen kontrol ediniz."
                          ))
                    CustomErrorHandler.error_handler()

                signal_payload = {
                    "message_type":
                    USER_ACTIVITY_MESSAGES.get("common").get(
                        "parola_degisikligi").type_index,
                    "ekstra_mesaj":
                    "{} adlı kullanıcı parolasini degistirdi.".format(
                        current_user.username)
                }
                signal_sender(**signal_payload)

            else:
                flash(
                    _("Parolanız güncellenirken bir hata oluştu. Girdiğiniz bilgileri lütfen kontrol ediniz."
                      ))
                signal_payload = {
                    "message_type":
                    USER_ACTIVITY_MESSAGES.get("common").get(
                        "hatali_parola").type_index,
                    "ekstra_mesaj":
                    "{} adlı kullanıcı parolasini degistirirken"
                    "Eski parolasini hatali girdi.".format(
                        current_user.username)
                }
                signal_sender(**signal_payload)
        else:
            signal_payload = {
                "message_type":
                USER_ACTIVITY_MESSAGES.get("common").get(
                    "parola_degistirirken_hata").type_index,
                "ekstra_mesaj":
                "{} adlı kullanıcı parolasini degistiremedi.".format(
                    current_user.username)
            }
            signal_sender(**signal_payload)
            flash(
                _("Parolanız güncellenirken bir hata oluştu. Girdiğiniz bilgileri lütfen kontrol ediniz."
                  ))

        return render_template(
            "parola.html",
            parola_form=parola_form,
            user=user,
            avatar_url=self.avatar,
        )
Exemplo n.º 17
0
            return False
    return True


def gen_prime(l, r):
    n = random.randint(l, r)
    while not isPrime(n):
        n = random.randint(l, r)
    return n


def generate_keys():
    p = gen_prime(200, 300)
    q = gen_prime(300, 400)

    n = p * q
    e = 101

    # Здесь должен быть обратный эл-т в кольце по модулю!
    d = 1
    while (e * d) % n != 1:
        d += 1
    return PublicKey(e, n), PrivateKey(d, n)


public, private = generate_keys()
print("Address of our BLOCKCHAIN is ",
      sha512(public.dumps().encode()).hexdigest())
print("Save this pls", public.dumps())
print("Save this pls and keep it secret", private.dumps())
Exemplo n.º 18
0
from ._util import PY2, PY33


if PY2:
    import _md5
    import _sha
    import _sha256
    import _sha512


    md5 = type(_md5.new())
    sha1 = type(_sha.new())
    sha224 = type(_sha256.sha224())
    sha256 = type(_sha256.sha256())
    sha384 = type(_sha512.sha384())
    sha512 = type(_sha512.sha512())
elif PY33:
    import _md5
    import _sha1
    import _sha256
    import _sha512


    md5 = type(_md5.md5())
    sha1 = type(_sha1.sha1())
    sha224 = type(_sha256.sha224())
    sha256 = type(_sha256.sha256())
    sha384 = type(_sha512.sha384())
    sha512 = type(_sha512.sha512())

HASH = type(_hashlib.new('md5'))
Exemplo n.º 19
0
 def _genHashString(self):
     """Method outside the Database to Genrate HashString for Code and Token values."""
     return sha512(uuid4().hex).hexdigest()[0:OAUTH2_ACCESS_TOKEN_LENGTH]
class Blockchain:

    seed_hash = sha512("Genesis669666999".encode()).hexdigest()
    node_list = {}

    # The default constructor function for this class
    def __init__(self, chain=None, all_transactions=None):
        if all_transactions is None:
            all_transactions = []
        if chain is None:
            chain = []
        self.chain = chain
        self.all_transactions = all_transactions
        self.node_list = {
            "node1": 35500,
            "node2": 31000,
            "node3": 36500,
            "node4": 38000,
            "node5": 38500,
            "node6": 40000,
            "node7": 41000
        }

    # The genesis block which will be the starting of the chain; a parent block in some way
    def block_zero(self, node_id):
        # The genesis or zero block is initialized with a special key that is to be kept confidential
        # The previous hash for the Gen block is 0
        block = Block.Block([self.seed_hash], 0)
        self.chain.append(block)
        if self.validate_block(node_id):
            print("\nGENESIS BLOCK MINED!\n")
        else:
            print("\nGENESIS BLOCK CANNOT BE MINED!\n")

        return [self.chain, self.seed_hash]

    # The function that adds new blocks to the existing chain
    def add_block(self, transactions, node_id):

        import pymysql.cursors
        mysql_conn = pymysql.connect(host="localhost",
                                     user="******",
                                     password="******",
                                     db="user_information",
                                     charset='utf8mb4',
                                     cursorclass=pymysql.cursors.DictCursor)
        previous_block_hash = ""
        print(self.chain, len(self.chain))
        try:
            with mysql_conn.cursor() as cursor:
                sql = "select blockname from %s" % (node_id)
                print(sql)
                cursor.execute(sql)
                block_height = len(cursor.fetchall())
            mysql_conn.commit()
            with mysql_conn.cursor() as cursor:
                sql = "select blockname from %s" % node_id + " limit %s, %s"
                print(type(block_height))
                cursor.execute(sql, (block_height - 1, block_height))
        finally:
            mysql_conn.close()

        new_block = Block.Block(transactions, previous_block_hash)
        self.chain.append(new_block)
        return new_block

    # The function that validates the new blocks by comparing hashes
    def validate_block(self, node_id):
        import socket
        import pickle

        # Multicast the data to all blocks except the sender, for validation
        nodes = ["node1", "node2", "node3", "node4", "node5", "node6", "node7"]
        # you can send objects using pickle files
        dumping_variable = pickle.dumps(self.chain)
        chain_object = dumping_variable
        result = True
        print(nodes)
        for node in nodes:
            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            if node != node_id:
                port = self.node_list[node]
                # print(port)
                try:
                    server_socket.connect(("127.0.0.1", port))
                    server_socket.send(bytes(node_id.encode()))
                    m1 = server_socket.recv(1024)

                    server_socket.send(chain_object)
                    m1 = server_socket.recv(1024)

                    server_socket.send(bytes(str(self.seed_hash).encode()))

                    result_string = str(server_socket.recv(1024))
                    result_from_one_node = False
                    if str(result_string) == "b\'True\'":
                        result_from_one_node = True
                    print("Message received: ", result_from_one_node)
                    result &= result_from_one_node

                    server_socket.close()
                except ConnectionRefusedError as ce:
                    print("In Blockchain: ", ce.strerror, ce.__traceback__)
        print("Out of the loop")
        return result

    # The function that will print the whole blockchain
    def print_block_chain(self):
        for block_index in range(len(self.chain)):
            current_block = self.chain[block_index]
            print("Block {} {} ".format(block_index, current_block))
            current_block.print_block_content()
Exemplo n.º 21
0
 def get_query_tag(self, query_override=None):
     """ Creates a unique tag for these parameters."""
     url = self.Urls.task.format(**self.query.get_url_kwargs())
     query_params = self.get_parameters(query_override=query_override)
     key = json.dumps((self.query_id, url, query_params), ensure_ascii=True, sort_keys=True).encode('ascii')
     return sha512(key).hexdigest()[:36]