Implementación de Blockchain en Java

Blockchain es la tecnología principal de Digital CryptoCurrency BitCoin . 

• Una Blockchain es una lista de registros llamados bloques que se enlazan entre sí mediante listas enlazadas y utilizan la técnica criptográfica .
• Cada bloque contiene su propia huella digital llamada Hash , el hash del bloque anterior, una marca de tiempo y los datos de la transacción realizada, haciéndolo más seguro ante cualquier tipo de filtración de datos.
• Por lo tanto, si se cambian los datos de un bloque, también cambiará su hash. Si se cambia el hash, su hash será diferente del siguiente bloque que contiene el hash del bloque anterior y afectará a todos los hash de los bloques posteriores. Cambiar los hashes y luego compararlos con otros bloques nos permite verificar la string de bloques.

Implementación de Blockchain: Las siguientes son las funciones utilizadas en la implementación de Blockchain. 

• Creación de bloques: para crear un bloque, se implementa una clase Block . En el bloque de clase: 
  • hash contendrá el hash del bloque y
  • anteriorHash contendrá el hash del bloque anterior.
  • Los datos de string se utilizan para almacenar los datos del bloque y
  • «long timeStamp» se utiliza para almacenar la marca de tiempo del bloque. Aquí se utiliza el tipo de datos largo para almacenar el número de milisegundos.
  • calcularHash() para generar el hash

// Java implementation for creating
// a block in a Blockchain
   
import java.util.Date;
   
public class Block {
   
    // Every block contains
    // a hash, previous hash and
    // data of the transaction made
    public String hash;
    public String previousHash;
    private String data;
    private long timeStamp;
   
    // Constructor for the block
    public Block(String data,
                 String previousHash)
    {
        this.data = data;
        this.previousHash
            = previousHash;
        this.timeStamp
            = new Date().getTime();
        this.hash
            = calculateHash();
    }
   
    // Function to calculate the hash
    public String calculateHash()
    {
        // Calling the "crypt" class
        // to calculate the hash
        // by using the previous hash,
        // timestamp and the data
        String calculatedhash
            = crypt.sha256(
                previousHash
                + Long.toString(timeStamp)
                + data);
   
        return calculatedhash;
    }
}

• Generación de hashes: para generar hash, se utiliza el algoritmo  SHA256 .
  A continuación se muestra la implementación del algoritmo.

// Java program for Generating Hashes
 
import java.security.MessageDigest;
 
public class crypt {
 
    // Function that takes the string input
    // and returns the hashed string.
    public static String sha256(String input)
    {
        try {
            MessageDigest sha
                = MessageDigest
                      .getInstance(
                          "SHA-256");
            int i = 0;
 
            byte[] hash
                = sha.digest(
                    input.getBytes("UTF-8"));
 
            // hexHash will contain
            // the Hexadecimal hash
            StringBuffer hexHash
                = new StringBuffer();
 
            while (i < hash.length) {
                String hex
                    = Integer.toHexString(
                        0xff & hash[i]);
                if (hex.length() == 1)
                    hexHash.append('0');
                hexHash.append(hex);
                i++;
            }
 
            return hexHash.toString();
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

• Almacenamiento de los bloques: Ahora, almacenemos los bloques en el ArrayList de tipo Block , junto con sus valores hash llamando al constructor de Block Class .

// Java implementation to store
// blocks in an ArrayList
 
import java.util.ArrayList;
 
public class GFG {
 
    // ArrayList to store the blocks
    public static ArrayList<Block> blockchain
        = new ArrayList<Block>();
 
    // Driver code
    public static void main(String[] args)
    {
        // Adding the data to the ArrayList
        blockchain.add(new Block(
            "First block", "0"));
        blockchain.add(new Block(
            "Second block",
            blockchain
                .get(blockchain.size() - 1)
                .hash));
 
        blockchain.add(new Block(
            "Third block",
            blockchain
                .get(blockchain.size() - 1)
                .hash));
 
        blockchain.add(new Block(
            "Fourth block",
            blockchain
                .get(blockchain.size() - 1)
                .hash));
 
        blockchain.add(new Block(
            "Fifth block",
            blockchain
                .get(blockchain.size() - 1)
                .hash));
    }
}

• Validez de Blockchain: finalmente, debemos verificar la validez de BlockChain creando un método booleano para verificar la validez. Este método se implementará en la clase «Principal» y verifica si el hash es igual al hash calculado o no. Si todos los hashes son iguales a los hashes calculados, entonces el bloque es válido. 
  A continuación se muestra la implementación de la validez:

// Java implementation to check
// validity of the blockchain
 
// Function to check
// validity of the blockchain
public static Boolean isChainValid()
{
    Block currentBlock;
    Block previousBlock;
 
    // Iterating through
    // all the blocks
    for (int i = 1;
         i < blockchain.size();
         i++) {
 
        // Storing the current block
        // and the previous block
        currentBlock = blockchain.get(i);
        previousBlock = blockchain.get(i - 1);
 
        // Checking if the current hash
        // is equal to the
        // calculated hash or not
        if (!currentBlock.hash
                 .equals(
                     currentBlock
                         .calculateHash())) {
            System.out.println(
                "Hashes are not equal");
            return false;
        }
 
        // Checking of the previous hash
        // is equal to the calculated
        // previous hash or not
        if (!previousBlock
                 .hash
                 .equals(
                     currentBlock
                         .previousHash)) {
            System.out.println(
                "Previous Hashes are not equal");
            return false;
        }
    }
 
    // If all the hashes are equal
    // to the calculated hashes,
    // then the blockchain is valid
    return true;
}

Ventajas de la string de bloques: 

1. Blockchain es una red distribuida de sistemas . Por lo tanto, las violaciones de datos son muy difíciles de llevar a cabo.
2. Ya que, Blockchain generaba hashes de cada bloque, por lo tanto, es muy difícil realizar ataques maliciosos .
3. La manipulación de datos cambiará el hash de cada bloque, lo que invalidará la string de bloques