Skip to content
Snippets Groups Projects
Select Git revision
  • a8bca5b51f697f5311114da3373683d9b5e74864
  • master default protected
2 results

ITKoin_01_Prajczer_Peter.py

Blame
    • ITKoin_01_Prajczer_Peter.py 4.19 KiB
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113 
    

    

    

    from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA
import json
from Crypto.Signature import pkcs1_15
from base64 import b64encode, b64decode
from pprint import pprint


class ITKoin:
    def __init__ (self):
        self.pending_transactions = []
        self.unspent_transactions = []
        self.sender_inputs = []
        self.chain = []

    @staticmethod
    def generate_rsa_key(filename):
        # generálj 2048 bites RSA kulcsot
        rsakey = RSA.generate(2048)
        # a kulcs publikus része kerüljön ide
        rsapublickey = rsakey.publickey()
        # print(rsakey)
        # print(rsakey)
        # print(vars(rsakey))
        # print(vars(rsakey))
        # print(vars(rsakey))
        # print(vars(rsapublickey))
        # PEM formátumra alakítsd az RSA kulcsot
        PEMrsakey = rsakey.export_key('PEM')
        # print(PEMrsakey)
        # PEM formátumra alakítsd a kulcs publikus részét
        PEMrsapublickey = rsapublickey.export_key("PEM")
        # print(PEMrsapublickey)
        privatekeyfilename = filename + 'priv.pem'
        f = open(privatekeyfilename, 'wb')
        f.write(PEMrsakey)
        f.close()
        publickeyfilename = filename + 'pub.pem'
        f = open(publickeyfilename, 'wb')
        f.write(PEMrsapublickey)
        f.close()

    def load_key(self, filename):
        privatekeyfilename = filename + 'priv.pem'
        privatekeyfileobject = open(privatekeyfilename, 'r')
        privatekeyfilecontent = privatekeyfileobject.read()
        # print(privatekeyfilecontent)
        rsakey = RSA.import_key(privatekeyfilecontent)
        self.rsakey = rsakey
        # pprint(vars(self.rsakey))
        rsapublickey = rsakey.publickey()
        self.rsapublickey = rsapublickey
        # print("haha")
        # pprint(vars(self.rsapublickey))

    def load_public_key(self, filename):
        publickeyfilename = filename + 'pub.pem'
        publickeyfileobject = open(publickeyfilename, 'r')
        publickeyfilecontent = publickeyfileobject.read()
        # pprint(publickeyfilecontent)
        rsakey = RSA.import_key(publickeyfilecontent)
        rsapublickey = rsakey.publickey()
        self.rsapublickey = rsapublickey
        # pprint(vars(self.rsapublickey))


    @staticmethod
    def create_hashobject(data):
        stringdump = json.dumps(data)  # ez nem teljesen korrekt megoldás, de így egyszerű mindent byte stringgé konvertálni
        binarydump = stringdump.encode()
        # hozz létre egy hash objektumot
        hashobject = SHA256.new()
        # töltsd be az objektumba a lenyomatolni kívánt byte stringet
        hashhexvalue = hashobject.update(binarydump)
        # print(hashobject)
        # print(hashhexvalue)
        return hashobject

    def create_signature(self, data):
        # hozz létre egy signature objektumot
        signatureobject = pkcs1_15.new(self.rsakey)
        # az adatot töltsd be egy hash objektumba a create_hashobject(data) használatával
        hashobject =  self.create_hashobject(data)
        # készítsd el az aláírás értéket a sign függvénnyel
        signaturevalue = signatureobject.sign(hashobject)
        print(signaturevalue)
        b64signaturevalue = b64encode(signaturevalue)
        print(b64signaturevalue)
        print(b64signaturevalue.decode())
        return b64signaturevalue.decode()

    def verify_signature(self, data, b64signaturevalue, rsapublickey):
        # hozz létre egy verify objektumot
        verifyobject = pkcs1_15.new(rsapublickey)
        # az adatot töltsd be egy hash objektumba a create_hashobject(data) használatával
        hashobject =  self.create_hashobject(data)
        # dekódold base64 kódolással az aláírás értéket
        signaturevalue =  b64decode(b64signaturevalue)
        signatureerror =  verifyobject.verify(signaturevalue, hashobject)
        # értéke: True, ha az aláírás érvényes
        validsignature =  True
        return validsignature


if __name__ == '__main__':
    test_coin = ITKoin()
    # test_coin.generate_rsa_key("prajczer")
    test_coin.load_key("prajczer")
    test_coin.load_public_key("prajczer")
    test_coin.create_hashobject("random")
    test_coin.create_signature('random')
    test_coin.verify_signature(@fasz kivan)