Blockchain Technology

2.4.1. Advantages of a Blockchain

2.4.2. Disadvantages of a Blockchain

3.1.1. SHA-256

1. Algorithm
   
   1. Read the input
   2. Convert it into binary
   3. Append a bit with value 1, to the end of this sequence.
   4. Pad this sequence with enough 0s to span across 448 bits.
   5. Pad the length of the original message with enough 0s to span across 64 bits.

   6. Define the working variables:

      H0 = 6a09e667
      H1 = bb67ae85
      H2 = 3c6ef372
      H3 = a54ff53a
      H4 = 510e527f
      H5 = 9b05688c
      H6 = 1f83d9ab
      H7 = 5be0cd19
      

      Initialize variables a, b, c, d, e, f, g, h with H0, H1, H2, H3, H4, H5, H6, H7 respectively.

   7. Define the round constants:
      • These are 64 words each of size 32 bits.

      • These are derived from the decimal part (eg. 2 from the number 1.2) of the cube roots of the first 64 prime numbers.

           K0 = 0x428a2f98
           K1 = 0x71374491
           K2 = 0xb5c0fbcf
           K3 = 0xe9b5dba50x3956c25b
           K4 = 0x59f111f1
           K5 = 0x923f82a4
           K6 = 0xab1c5ed50xd807aa98
           K7 = 0x12835b01
           ...
           K63 = 0xc67178f2
        

   8. Split the block of 512 bits into 16 unsigned words w0, w1, w2, .. w15 (each would be 32 bits).
   9. Expand these 16 words into 64 words (create w16, w17, … w63) using rotations, shifts and XOR. Each word is created as: \[W_i = \sigma_1(W_{i-2}) + W_{i-7} + \sigma_0(W_{i-15}) + W_{i-16} \] for \(16 \le i \le 63\)
      • The current word \(w_{i}\) depends on 4 different previous words (\(w_{i-2}\), \(w_{i-7}\), \(w_{i-15}\) and \(w_{i-16}\)).
      • The helper functions defined are:
        • \(\operatorname{ROTR}^{n}(x)\): Rotate right (right circular shift) all the bits of word \(x\), \(n\) times.
        • \(\operatorname{SHR}^{n}(x)\): Logical right shift (bits of the right are discarded on right shifting) all the bits of word \(x\), \(n\) times.
        • \(\sigma_{0}(x) = \operatorname{ROTR}^{7}(x) \oplus \operatorname{ROTR}^{18}(x) \oplus \operatorname{SHR}^{3}(x)\)
        • \(\sigma_{1}(x) = \operatorname{ROTR}^{17}(x) \oplus \operatorname{ROTR}^{19}(x) \oplus \operatorname{SHR}^{10}(x)\)
   10. For 64 times:
       1. Calculate: \[T_1 = h + \Sigma_1(e) + \operatorname{Ch}(e,f,g) + K[i] + W[i] \] \[T_2 = \Sigma_0(a) + \operatorname{Maj}(a,b,c) \] The helper functions/variables are defined as:
          • \(h\): This variable is one of the 8 variables defined earlier
          • \(\Sigma_{0}(x) = \operatorname{ROTR}^{2} \oplus \operatorname{ROTR}^{13} \oplus \operatorname{ROTR}^{22}\)
          • \(\Sigma_{1}(x) = \operatorname{ROTR}^{6} \oplus \operatorname{ROTR}^{11} \oplus \operatorname{ROTR}^{25}\)
          • \(\operatorname{Ch}(e, f, g) = (e \wedge f) \oplus (\not e \vee g)\)
            
            • This is called the Choice function and \(e\), \(f\) and \(g\) are 3 of the 8 working variables.
            • For every bit position, if the bit of \(c\) is 0, then the corresponding bit is taken from \(f\) and if the bit of \(c\) is 1, then the corresponding bit is taken from \(g\).
          • \(\operatorname{Maj}(a, b, c) = (a \wedge b) \oplus (a \wedge c) \oplus (b \wedge c)\)
            • This is the Majority function and for each bit position, the output is the bit value (0 or 1) that appears in at least two of the three inputs.
       2. Update the worker variables as:
          • \(\verb|H7| = \verb|H6|\)
          • \(\verb|H6| = \verb|H5|\)
          • \(\verb|H5| = \verb|H4|\)
          • \(\verb|H4| = (\verb|H3| + T_{1}) \mod(2^{32})\)
          • \(\verb|H3| = \verb|H2|\)
          • \(\verb|H2| = \verb|H1|\)
          • \(\verb|H1| = \verb|H0|\)
          • \(\verb|H0| = (T_{1} + T_{2}) \mod(2^{32})\)
   11. Concatenate all the worker variables and convert the result into hexadecimal.
2. Rough Implementation in Python
   

   def main():
       message = "quickbrown"
       output = convert_string_to_binary(message)
       output+='1'
       output = pad_till_n(output, 448)
       output+= f"{len(message):0{64}b}"
       
       # working variables:
       H = [
           f"{int(x,16):032b}" for x in
           [
                "6a09e667",
                "bb67ae85",
                "3c6ef372",
                "a54ff53a",
                "510e527f",
                "9b05688c",
                "1f83d9ab",
                "5be0cd19",
            ]
       ]
       # round constants
       K = [
            0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
            0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
            0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
            0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
            0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
            0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
            0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
            0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
            0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
            0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
            0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
            0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
            0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
            0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
            0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
            0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
       ]
       # split the block into 16 words (w0, w1, ... w15) of 32 bits each
       w = []
       for i in range(0, 512, 32):
           w.append(output[i:i+32])
        
       # creating words w16, w17, ... w63 (helper functions defined later)
       for i in range(16, 64):
           value = (sigma_1(w[i-2]) + int(w[i-7], 2) + sigma_0(w[i-15]) + int(w[i-16], 2)) % (2**32)
           w.append(f"{value:032b}")
        
       # the 64 rounds (helper functions defined later)
       for i in range(64):
           T1 = (int(H[7], 2) + SIGMA_1(H[4]) + Ch(H[4], H[5], H[6]) + K[i] + int(w[i], 2)) % (2**32)
           T2 = (SIGMA_0(H[0]) + Maj(H[0], H[1], H[2])) % (2**32)
           H[7] = H[6]
           H[6] = H[5]
           H[5] = H[4]
           H[4] = f"{(int(H[3],2) + T1) % (2**32):032b}"
           H[3] = H[2]
           H[2] = H[1]
           H[1] = H[0]
           H[0] = f"{(T1 + T2) % (2**32):032b}"
        
       print(hex(int("".join(H), 2)))
    
    
    
    
   def convert_string_to_binary(txt: str):
       binary = ""
       for c in txt:
           binary += f"{ord(c)-96:08b}"
       return binary
    
   def pad_till_n(txt: str, n):
       return txt.rjust(n, "0")
    
    
   # helper functions for creating words w16, w17, ... w63
   def ROTR(w, n): 
       n = n%len(w)
       return w[-n:] + w[:-n]
    
   def SHR(w, n):
       return w[:-n].rjust(len(w), "0")
    
   def sigma_0(x):
       return int(ROTR(x, 7), 2) ^ int(ROTR(x, 18), 2) ^ int(SHR(x, 3), 2)
    
   def sigma_1(x):
       return int(ROTR(x, 17), 2) ^ int(ROTR(x, 19), 2) ^ int(SHR(x, 10), 2)
           
    
    
    
   # helper functions for the 64 rounds
   def SIGMA_0(x):
       return int(ROTR(x, 2), 2) ^ int(ROTR(x, 13), 2) ^ int(ROTR(x, 22), 2)
       
   def SIGMA_1(x):
       return int(ROTR(x, 6), 2) ^ int(ROTR(x, 11), 2) ^ int(ROTR(x, 25), 2)
    
   def Ch(e, f, g):
       return (int(e, 2) & int(f, 2)) ^ (~int(e, 2) & int(g, 2))
       
   def Maj(a, b, c):
       return (int(a, 2) & int(b, 2)) ^ (int(a, 2) & int(c, 2)) ^ (int(b, 2) & int(c, 2))
    
   main()
   
   

   0xc072e1042417d4a9c774c9ffeaea3d25440a6479978c2adc1cacdc9a894c35bc
   

3. Using hashlib
   

   The steps in which this works is given below:

   1. Make bytes Object
      
      • A bytes object in Python is an immutable sequence of integers ranging from 0 to 255.

      • You can make it using by passing a list of integers as the parameter to the bytes function:

        list_bytes = bytes([72, 101, 108, 108, 111])
        print(list_bytes)
        

          b'Hello'
        

      • You can also use a b suffix to a string:

        list_bytes = b'hello'
        print(list_bytes)
        

          b'hello'
        

      • You can also use the .encode() method and it gives the same thing:

        list_bytes = 'hello'.encode()
        print(list_bytes)
        

          b'hello'
        

      • If you index a bytes object, you get the ASCII value:

        print(b'ABC'[0])
        

          65
        

   2. Use .sha256() method
      

      • From the hashlib module, the .sha256() method takes a bytes object as a parameter, and returns a HASH object:

        import hashlib
        print(type(hashlib.sha256(b'ABC')))
        

          <class '_hashlib.HASH'>
        

   3. Use .hexdigest() method
      

      • On the HASH object, you can call the .hexdigest() method to return the hashed value as hexadecimal characters:

        import hashlib
        hash_value = hashlib.sha256("text".encode()).hexdigest()
        print(hash_value)
        

          982d9e3eb996f559e633f4d194def3761d909f5a3b647d1a851fead67c32c9d1
        

3.2.1. Based on Number of Keys

1. RSA (Rivest Shamir Adelman) Algorithm
   
   • This is the model widely used Public Key Cryptography (PKC).
   • To encrypt a message there is no need to exchange a secret key separately.
   1. Key Generation
      
      • Select \(p\), \(q\), where \(p\) and \(q\) are prime.
      • Calculate \(n = p \times q\)
      • Select integer \(e\), such that \(\text{gcd}(\phi(n), e) = 1; 1 < e < \phi(n)\)
      • Calculate \(d = e^{-1}\mod(\phi(n))\)
      • Public Key \(\text{KU} = {e,n}\)
      • Private Key \(\text{KR} = {d,n}\)
   2. Encryption (through an example)
      
      • \(p=3\), \(q=11\)
      • \(n=p \times q = 3 \times 11 = 33\)
      • \(\phi(n) = \phi(33) = \phi(3 \times 11) = 2 \times 10 = 20\)
        • Verification of φ(33): \(Z_{33}^{*}\) = (all the numbers from 1 to 33, coprime with \(33\)) = [1,2,4,5,7,8,10,13,14,16,17,19,20,23,25,26,28,29,31,32]
      • Consider \(e=7\) (because it satisifies the GCD criteria):

      • \(d = e^{-1} \mod(20)\)

        • \(d = 7^{-1} \mod(20)\)

        \(q\)	\(a\)	\(m\)	\(r\)	\(u_{0}\)	\(u_{1}\)	\(u\)
        0	7	20	6	1	0	1

3.5.1. What it is

3.5.2. How it works