02 – Blocos, Cadeias e Hashes: Os Pilares da Segurança Blockchain

🧱 O que é um Bloco na Blockchain?

Um bloco é a unidade fundamental da blockchain, como uma página em um livro-razão digital ou um nó de uma lista encadeada.
Ele contém informações essenciais que garantem a integridade da cadeia:

Conteúdo típico de um bloco:

1. Transações: registros (ex.: “João envia 1 BTC para Maria”).
2. Timestamp: data e hora da criação do bloco.
3. Hash do bloco anterior: a “assinatura digital” que conecta esse bloco ao anterior.
4. Hash atual: a impressão digital única do próprio bloco, calculada a partir de todos os seus dados.

👉 Analogia com estruturas de dados:
Em programação, cada nó de uma lista encadeada armazena dados + ponteiro para o próximo nó.
Na blockchain, cada bloco armazena transações + hash anterior + timestamp.
A diferença é que, em vez de um simples ponteiro de memória, temos uma referência criptográfica extremamente robusta.

📌 Curiosidade:
No Bitcoin, o “cabeçalho do bloco” ocupa 80 bytes e inclui campos como versão, timestamp, nonce (usado na mineração) e o famoso Merkle Root, que é o hash de todas as transações do bloco.

🔗 Como funciona a Cadeia de Blocos?

A blockchain nada mais é do que uma lista encadeada de blocos imutáveis.

• Cada novo bloco contém o hash do bloco anterior.
• Alterar qualquer informação em um bloco invalida o hash de todos os seguintes.
• Isso cria a famosa corrente de blocos (block-chain).

👉 Exemplo prático:

• Bloco 1 contém hash abc123.
• Bloco 2 guarda esse hash (abc123) e cria o seu próprio (def456).
• Bloco 3 aponta para def456.
  Se alguém tentar modificar o Bloco 1, o hash mudará → Bloco 2 se torna inválido → Bloco 3 também → e assim por diante.

👉 Analogia:
É como um diário numerado e autenticado: cada página é carimbada com um selo que depende do selo da página anterior.
Se alguém tenta arrancar ou modificar uma página, todo o diário perde consistência.

📌 Curiosidade:
O primeiro bloco do Bitcoin (Bloco Gênese, 2009) ainda existe e contém uma mensagem deixada por Satoshi Nakamoto no campo de transação:
“The Times 03/Jan/2009 Chancellor on brink of second bailout for banks” — uma crítica política e um carimbo de data.

🧮 Hashes: O Elo de Confiança

O hash é a função matemática que dá “identidade” a cada bloco.
Um hash transforma os dados (transações, timestamp, hash anterior, etc.) em uma sequência única de 64 caracteres hexadecimais (no caso do SHA-256).

Propriedades fundamentais:

1. Determinístico: mesma entrada = mesmo resultado.
2. Avalanche: mínima alteração no dado → resultado completamente diferente.
3. Unidirecional: não dá para “desfazer” e voltar aos dados originais.
4. Tamanho fixo: não importa se o dado é pequeno ou gigante, o resultado sempre tem o mesmo tamanho.

👉 Exemplo didático:

• Entrada: “DevsGeek é brabo!” → Hash: e71f…7a8c
• Entrada: “DevsGeek é braba!” → Hash: bf0c…59a1

Só trocar o “o” por “a” já muda totalmente o resultado.

👉 Analogia com estruturas de dados:
É parecido com como usamos funções de hash em tabelas de dispersão (hash tables) para localizar itens rapidamente.
Mas na blockchain, o objetivo não é a busca, e sim a integridade: o hash é a prova de que os dados não foram alterados.

📌 Curiosidade:
O Bitcoin exige que o hash de cada bloco seja menor que um valor-alvo específico. Isso é o que chamamos de dificuldade da mineração.

import hashlib
import time

class Bloco:
    def __init__(self, transacoes, anterior_hash="0"):
        self.transacoes = transacoes
        self.timestamp = time.time()
        self.anterior_hash = anterior_hash
        self.hash = self.gerar_hash()

    def gerar_hash(self):
        conteudo = str(self.transacoes) + str(self.timestamp) + self.anterior_hash
        return hashlib.sha256(conteudo.encode()).hexdigest()

# Criando blocos
bloco1 = Bloco("João envia 10 para Maria")
bloco2 = Bloco("Maria envia 5 para Pedro", bloco1.hash)

print("Bloco 1:")
print(" Transações:", bloco1.transacoes)
print(" Timestamp:", bloco1.timestamp)
print(" Hash Anterior:", bloco1.anterior_hash)
print(" Hash Atual:", bloco1.hash)
print("\nBloco 2:")
print(" Transações:", bloco2.transacoes)
print(" Timestamp:", bloco2.timestamp)
print(" Hash Anterior:", bloco2.anterior_hash)
print(" Hash Atual:", bloco2.hash)

python blockchain.py

using System;
using System.Security.Cryptography;
using System.Text;

class Bloco
{
    public string Transacoes { get; set; }
    public string Timestamp { get; set; }
    public string AnteriorHash { get; set; }
    public string Hash { get; set; }

    public Bloco(string transacoes, string anteriorHash = "0")
    {
        Transacoes = transacoes;
        Timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        AnteriorHash = anteriorHash;
        Hash = GerarHash();
    }

    private string GerarHash()
    {
        using (SHA256 sha256 = SHA256.Create())
        {
            var conteudo = Transacoes + Timestamp + AnteriorHash;
            byte[] bytes = Encoding.UTF8.GetBytes(conteudo);
            byte[] hash = sha256.ComputeHash(bytes);
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }
}

class Program
{
    static void Main()
    {
        var bloco1 = new Bloco("João envia 10 para Maria");
        var bloco2 = new Bloco("Maria envia 5 para Pedro", bloco1.Hash);

        Console.WriteLine("Bloco 1:");
        Console.WriteLine($" Transações: {bloco1.Transacoes}");
        Console.WriteLine($" Timestamp: {bloco1.Timestamp}");
        Console.WriteLine($" Hash Anterior: {bloco1.AnteriorHash}");
        Console.WriteLine($" Hash Atual: {bloco1.Hash}");

        Console.WriteLine("\nBloco 2:");
        Console.WriteLine($" Transações: {bloco2.Transacoes}");
        Console.WriteLine($" Timestamp: {bloco2.Timestamp}");
        Console.WriteLine($" Hash Anterior: {bloco2.AnteriorHash}");
        Console.WriteLine($" Hash Atual: {bloco2.Hash}");
    }
}

dotnet new console -o BlockchainDemo
mv Program.cs BlockchainDemo/
cd BlockchainDemo
dotnet run

import crypto from "crypto";

class Bloco {
  constructor(transacoes, anteriorHash = "0") {
    this.transacoes = transacoes;
    this.timestamp = new Date().toISOString();
    this.anteriorHash = anteriorHash;
    this.hash = this.gerarHash();
  }

  gerarHash() {
    const conteudo = this.transacoes + this.timestamp + this.anteriorHash;
    return crypto.createHash("sha256").update(conteudo).digest("hex");
  }
}

const bloco1 = new Bloco("João envia 10 para Maria");
const bloco2 = new Bloco("Maria envia 5 para Pedro", bloco1.hash);

console.log("Bloco 1:");
console.log(" Transações:", bloco1.transacoes);
console.log(" Timestamp:", bloco1.timestamp);
console.log(" Hash Anterior:", bloco1.anteriorHash);
console.log(" Hash Atual:", bloco1.hash);

console.log("\nBloco 2:");
console.log(" Transações:", bloco2.transacoes);
console.log(" Timestamp:", bloco2.timestamp);
console.log(" Hash Anterior:", bloco2.anteriorHash);
console.log(" Hash Atual:", bloco2.hash);

node blockchain.js

A segurança da blockchain vem da união de três pilares:

1. Integridade por hash:
   Alterar uma transação dentro de um bloco altera seu hash → quebra a corrente.
2. Imutabilidade estrutural:
   Para reescrever a história, seria necessário recalcular todos os blocos seguintes.
   E como cada bloco depende do anterior, o esforço cresce exponencialmente.
3. Distribuição descentralizada:
   A blockchain não está em um único servidor, mas replicada em milhares de nós pelo mundo.
   Para fraudar, seria necessário alterar a maioria dessas cópias ao mesmo tempo.
4. Protocolos de consenso (PoW, PoS):
   Mesmo que você tente recalcular hashes, ainda precisa “convencer” a rede pelo mecanismo de consenso.
   No Bitcoin (PoW), isso significa gastar energia elétrica e poder computacional astronômico.

👉 Analogia prática:
É como tentar falsificar uma moeda em circulação: você não precisa só criar uma cópia parecida, precisa convencer milhões de pessoas a aceitarem que sua cópia é válida.

📌 Curiosidade:
O chamado ataque de 51% só é viável em blockchains pequenas. No Bitcoin, seria necessário controlar mais poder de processamento que países inteiros.

👉 É como uma história contada em público: se alguém tenta alterar um capítulo, todos que ouviram sabem que é mentira.