Created private and public key step by step

Author: tas-indranil

Blockchain/Backend/core/EllepticCurve/EllepticCurve.py

@@ -0,0 +1,75 @@
+""" 
+Copyright (c) 2021 Codiesalert.com
+These scripts shouldn't be used for commercial purpose without Codies Alert Permission
+Any violations may lead to legal action
+"""
+
+
+class FieldElement:
+    def __init__(self, num, prime):
+        if num >= prime or num < 0:
+            error = "Num {} not in field range 0 to {}".format(num, prime - 1)
+            raise ValueError(error)
+        self.num = num
+        self.prime = prime
+
+    def __repr__(self):
+        return "FieldElement_{}({})".format(self.prime, self.num)
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        return self.num == other.num and self.prime == other.prime
+
+    def __ne__(self, other):
+        # this should be the inverse of the == operator
+        return not (self == other)
+
+    def __add__(self, other):
+        if self.prime != other.prime:
+            raise TypeError("Cannot add two numbers in different Fields")
+        # self.num and other.num are the actual values
+        # self.prime is what we need to mod against
+        num = (self.num + other.num) % self.prime
+        # We return an element of the same class
+        return self.__class__(num, self.prime)
+
+    def __sub__(self, other):
+        if self.prime != other.prime:
+            raise TypeError("Cannot subtract two numbers in different Fields")
+        # self.num and other.num are the actual values
+        # self.prime is what we need to mod against
+        num = (self.num - other.num) % self.prime
+        # We return an element of the same class
+        return self.__class__(num, self.prime)
+
+    def __mul__(self, other):
+        if self.prime != other.prime:
+            raise TypeError("Cannot multiply two numbers in different Fields")
+        # self.num and other.num are the actual values
+        # self.prime is what we need to mod against
+        num = (self.num * other.num) % self.prime
+        # We return an element of the same class
+        return self.__class__(num, self.prime)
+
+    def __pow__(self, exponent):
+        n = exponent % (self.prime - 1)
+        num = pow(self.num, n, self.prime)
+        return self.__class__(num, self.prime)
+
+    def __truediv__(self, other):
+        if self.prime != other.prime:
+            raise TypeError("Cannot divide two numbers in different Fields")
+        # self.num and other.num are the actual values
+        # self.prime is what we need to mod against
+        # use fermat's little theorem:
+        # self.num**(p-1) % p == 1
+        # this means:
+        # 1/n == pow(n, p-2, p)
+        num = (self.num * pow(other.num, self.prime - 2, self.prime)) % self.prime
+        # We return an element of the same class
+        return self.__class__(num, self.prime)
+
+    def __rmul__(self, coefficient):
+        num = (self.num * coefficient) % self.prime
+        return self.__class__(num=num, prime=self.prime)

Blockchain/Backend/core/EllepticCurve/FieldElement.py

@@ -0,0 +1,100 @@
+""" 
+Copyright (c) 2021 Codiesalert.com
+These scripts should be used for commercial purpose without Codies Alert Permission
+Any violations may lead to legal action
+"""
+from FieldElement import FieldElement
+
+
+class Point:
+    def __init__(self, x, y, a, b):
+        self.a = a
+        self.b = b
+        self.x = x
+        self.y = y
+        if self.x is None and self.y is None:
+            return
+        if self.y ** 2 != self.x ** 3 + a * x + b:
+            raise ValueError("({}, {}) is not on the curve".format(x, y))
+
+    # end::source1[]
+
+    def __eq__(self, other):
+        return (
+            self.x == other.x
+            and self.y == other.y
+            and self.a == other.a
+            and self.b == other.b
+        )
+
+    def __ne__(self, other):
+        # this should be the inverse of the == operator
+        return not (self == other)
+
+    def __repr__(self):
+        if self.x is None:
+            return "Point(infinity)"
+        elif isinstance(self.x, FieldElement):
+            return "Point({},{})_{}_{} FieldElement({})".format(
+                self.x.num, self.y.num, self.a.num, self.b.num, self.x.prime
+            )
+        else:
+            return "Point({},{})_{}_{}".format(self.x, self.y, self.a, self.b)
+
+    def __add__(self, other):
+        if self.a != other.a or self.b != other.b:
+            raise TypeError(
+                "Points {}, {} are not on the same curve".format(self, other)
+            )
+        # Case 0.0: self is the point at infinity, return other
+        if self.x is None:
+            return other
+        # Case 0.1: other is the point at infinity, return self
+        if other.x is None:
+            return self
+
+        # Case 1: self.x == other.x, self.y != other.y
+        # Result is point at infinity
+        if self.x == other.x and self.y != other.y:
+            return self.__class__(None, None, self.a, self.b)
+
+        # Case 2: self.x ≠ other.x
+        # Formula (x3,y3)==(x1,y1)+(x2,y2)
+        # s=(y2-y1)/(x2-x1)
+        # x3=s**2-x1-x2
+        # y3=s*(x1-x3)-y1
+        if self.x != other.x:
+            s = (other.y - self.y) / (other.x - self.x)
+            x = s ** 2 - self.x - other.x
+            y = s * (self.x - x) - self.y
+            return self.__class__(x, y, self.a, self.b)
+
+        # Case 4: if we are tangent to the vertical line,
+        # we return the point at infinity
+        # note instead of figuring out what 0 is for each type
+        # we just use 0 * self.x
+        if self == other and self.y == 0 * self.x:
+            return self.__class__(None, None, self.a, self.b)
+
+        # Case 3: self == other
+        # Formula (x3,y3)=(x1,y1)+(x1,y1)
+        # s=(3*x1**2+a)/(2*y1)
+        # x3=s**2-2*x1
+        # y3=s*(x1-x3)-y1
+        if self == other:
+            s = (3 * self.x ** 2 + self.a) / (2 * self.y)
+            x = s ** 2 - 2 * self.x
+            y = s * (self.x - x) - self.y
+            return self.__class__(x, y, self.a, self.b)
+
+    # tag::source3[]
+    def __rmul__(self, coefficient):
+        coef = coefficient
+        current = self  # <1>
+        result = self.__class__(None, None, self.a, self.b)  # <2>
+        while coef:
+            if coef & 1:  # <3>
+                result += current
+            current += current  # <4>
+            coef >>= 1  # <5>
+        return result

Blockchain/Backend/core/EllepticCurve/Point.py

@@ -0,0 +1,17 @@
+""" 
+Copyright (c) 2021 Codiesalert.com
+These scripts should be used for commercial purpose without Codies Alert Permission
+Any violations may lead to legal action
+"""
+from FieldElement import FieldElement
+from Point import Point
+
+P = 2 ** 256 - 2 ** 32 - 977
+
+
+class Sha256Field(FieldElement):
+    def __init__(self, num, prime=None):
+        super().__init__(num=num, prime=P)
+
+    def __repr__(self):
+        return "{:x}".format(self.num).zfill(64)

Blockchain/Backend/core/EllepticCurve/Sha256Field.py

@@ -0,0 +1,79 @@
+""" 
+Copyright (c) 2021 Codiesalert.com
+These scripts shouldn't be used for commercial purpose without Codies Alert Permission
+Any violations may lead to legal action
+"""
+from Blockchain.Backend.util.util import hash160
+from Blockchain.Backend.core.EllepticCurve.EllepticCurve import Sha256Point, Signature
+
+
+def op_dup(stack):
+
+    if len(stack) < 1:
+        return False
+    stack.append(stack[-1])
+
+    return True
+
+
+def op_hash160(stack):
+    if len(stack) < 1:
+        return False
+    element = stack.pop()
+    h160 = hash160(element)
+    stack.append(h160)
+    return True
+
+
+def op_equal(stack):
+    if len(stack) < 2:
+        return False
+
+    element1 = stack.pop()
+    element2 = stack.pop()
+
+    if element1 == element2:
+        stack.append(1)
+    else:
+        stack.append(0)
+
+    return True
+
+
+def op_verify(stack):
+    if len(stack) < 1:
+        False
+    element = stack.pop()
+
+    if element == 0:
+        return False
+
+    return True
+
+
+def op_equalverify(stack):
+    return op_equal(stack) and op_verify(stack)
+
+
+def op_checksig(stack, z):
+    if len(stack) < 1:
+        return False
+
+    sec_pubkey = stack.pop()
+    der_signature = stack.pop()[:-1]
+
+    try:
+        point = Sha256Point.parse(sec_pubkey)
+        sig = Signature.parse(der_signature)
+    except Exception as e:
+        return False
+
+    if point.verify(z, sig):
+        stack.append(1)
+        return True
+    else:
+        stack.append(0)
+        return False
+
+
+OP_CODE_FUNCTION = {118: op_dup, 136: op_equalverify, 169: op_hash160, 172: op_checksig}

Blockchain/Backend/core/EllepticCurve/__init__.py.txt

@@ -0,0 +1,9 @@
+from FieldElement import FieldElement
+from Point import Point
+a = FieldElement(num = 0, prime = 223)
+b = FieldElement(num = 7, prime = 223)
+x = FieldElement(num = 192, prime = 223)
+y = FieldElement(num = 105, prime = 223)
+
+p1 = Point(x, y, a, b)
+print(p1)

Blockchain/Backend/core/EllepticCurve/op.py

@@ -1,6 +1,12 @@
 import hashlib
+from Crypto.Hash import RIPEMD160
+from hashlib import sha256
 
 
 def hash256(s):
     """Two rounds of SHA256"""
     return hashlib.sha256(hashlib.sha256(s).digest()).digest()
+
+
+def hash160(s):
+    return RIPEMD160.new(sha256(s).digest()).digest()

Blockchain/Backend/core/EllepticCurve/test.py

@@ -0,0 +1,61 @@
+import sys
+import secrets
+
+sys.path.append('D:/xampp/htdocs/sand_box/get_job/custom-python-blockchain')
+from Blockchain.Backend.core.EllepticCurve.EllepticCurve import Sha256Point
+from Blockchain.Backend.util.util import hash160, hash256
+
+
+class Account:
+    def createKeys(self):
+        """Secp256k1 Curve Generator Points"""
+        Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+        Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
+
+        G = Sha256Point(Gx, Gy)
+
+        privateKey = secrets.randbits(256)
+
+        unCompressedPublicKey = privateKey * G
+        xpoint = unCompressedPublicKey.x
+        ypoint = unCompressedPublicKey.y
+
+        if ypoint.num % 2 == 0:
+            compressesKey = b"\x02" + xpoint.num.to_bytes(32, "big")
+        else:
+            compressesKey = b'\x03' + xpoint.num.to_bytes(32, 'big')
+
+        hsh160 = hash160(compressesKey)
+        """Prefix for Mainnet"""
+        main_prefix = b'\x00'
+
+        newAddr = main_prefix + hsh160
+
+        """Checksum"""
+        checksum = hash256(newAddr)[:4]
+        newAddr = newAddr + checksum
+        BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+        count = 0
+        for c in newAddr:
+            if c == 0:
+                count += 1
+            else:
+                break
+
+        """convert address to numeric form"""
+        num = int.from_bytes(newAddr, 'big')
+        prefix = '1' * count
+
+        result = ''
+        while num > 0:
+            num, mod = divmod(num, 58)
+            result = BASE58_ALPHABET[mod] + result
+
+        PublicAddress = prefix + result
+        return {"private Key": privateKey, "Public Address": PublicAddress}
+
+
+if __name__ == '__main__':
+    account = Account()
+    print(account.createKeys())

Blockchain/Backend/util/util.py

@@ -7,4 +7,4 @@ Under Backend, `core` and `util`.
 Height, Blocksize, BlockHeader, TxCount, Txs` variables
 3. Create a new module `blockheader.py`, create a class call `BlockHeader`. Inside the `__init__` method will take 
 `version, prevBlockHash, merkleRoot, timestamp, bits` and declare `self.nonce = 0 , self.blockHash = ''`
-4. Create a 
+4.