Java 블록체인 구현 가이드 – 해시부터 채굴까지 단계별 코드로 배우기

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class HashUtil {

    /**
     * 문자열을 입력받아 SHA-256 해시값(16진수)을 반환
     */
    public static String sha256(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hashBytes = digest.digest(input.getBytes("UTF-8"));

            // byte 배열을 16진수 문자열로 변환
            StringBuilder hexString = new StringBuilder();
            for (byte b : hashBytes) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();

        } catch (Exception e) {
            throw new RuntimeException("해시 계산 중 오류 발생", e);
        }
    }
}

┌─────────────────────────┐
│      블록 #0 (제네시스)    │
│  previousHash: "0"      │
│  data: "Genesis Block"  │
│  hash: "0000a1b2c3..."  │
└──────────┬──────────────┘
           │ hash 전달
           ▼
┌─────────────────────────┐
│         블록 #1          │
│  previousHash: "0000a1b2c3..."  │
│  data: "Alice→Bob: 5BTC"│
│  hash: "0000d4e5f6..."  │
└──────────┬──────────────┘
           │ hash 전달
           ▼
┌─────────────────────────┐
│         블록 #2          │
│  previousHash: "0000d4e5f6..."  │
│  data: "Bob→Carol: 3BTC"│
│  hash: "0000g7h8i9..."  │
└─────────────────────────┘

public class Block {

    public String hash;           // 이 블록의 해시값
    public String previousHash;   // 이전 블록의 해시값
    public String data;           // 블록에 저장할 데이터 (거래 내역 등)
    public long timeStamp;        // 블록 생성 시각 (Unix 타임스탬프)
    public int nonce;             // Proof of Work에서 사용할 임시값

    /**
     * 생성자: 이전 해시와 데이터를 받아 블록을 초기화하고 해시를 계산
     */
    public Block(String previousHash, String data) {
        this.previousHash = previousHash;
        this.data = data;
        this.timeStamp = System.currentTimeMillis();
        this.nonce = 0;
        this.hash = calculateHash(); // 생성 즉시 해시 계산
    }

    /**
     * 이 블록의 해시값을 계산 (이전해시 + 타임스탬프 + nonce + 데이터 조합)
     */
    public String calculateHash() {
        String input = previousHash
                + Long.toString(timeStamp)
                + Integer.toString(nonce)
                + data;
        return HashUtil.sha256(input);
    }

    @Override
    public String toString() {
        return String.format(
            "[블록]\n  데이터: %s\n  이전해시: %s\n  해시: %s\n  nonce: %d\n",
            data, previousHash, hash, nonce
        );
    }
}

import java.util.ArrayList;
import java.util.List;

public class Blockchain {

    private List<Block> chain = new ArrayList<>();
    private int difficulty = 4; // 채굴 난이도 (앞에 0이 몇 개 와야 하는지)

    /**
     * 생성자: 제네시스 블록을 자동으로 생성
     */
    public Blockchain() {
        chain.add(createGenesisBlock());
    }

    /**
     * 제네시스 블록 생성 (이전 해시 없음)
     */
    private Block createGenesisBlock() {
        Block genesis = new Block("0", "Genesis Block");
        genesis.mineBlock(difficulty);
        return genesis;
    }

    /**
     * 새 블록을 채굴하여 체인에 추가
     */
    public void addBlock(String data) {
        Block lastBlock = chain.get(chain.size() - 1);
        Block newBlock = new Block(lastBlock.hash, data);
        newBlock.mineBlock(difficulty);
        chain.add(newBlock);
        System.out.println("✅ 블록 추가 완료: " + newBlock.data);
    }

    /**
     * 블록 목록 반환
     */
    public List<Block> getChain() {
        return chain;
    }
}

/**
 * 난이도(difficulty)에 맞는 해시값이 나올 때까지 nonce를 증가시키며 반복
 * 예: difficulty=4이면 해시값이 "0000"으로 시작해야 함
 */
public void mineBlock(int difficulty) {
    // 목표 접두사: difficulty 개수만큼 '0' 반복
    String target = "0".repeat(difficulty);

    long startTime = System.currentTimeMillis();

    while (!hash.startsWith(target)) {
        nonce++;                    // nonce 1 증가
        hash = calculateHash();     // 새 해시 계산
    }

    long elapsedTime = System.currentTimeMillis() - startTime;
    System.out.printf("⛏ 채굴 완료! nonce: %d | 소요 시간: %dms | 해시: %s%n",
                      nonce, elapsedTime, hash);
}

/**
 * 체인 전체의 무결성을 검증
 * 1) 각 블록의 해시가 재계산값과 일치하는지 확인
 * 2) 각 블록의 previousHash가 이전 블록의 hash와 일치하는지 확인
 */
public boolean isChainValid() {
    for (int i = 1; i < chain.size(); i++) {
        Block current = chain.get(i);
        Block previous = chain.get(i - 1);

        // 현재 블록의 해시가 유효한지 검사
        if (!current.hash.equals(current.calculateHash())) {
            System.out.println("❌ 블록 #" + i + " 해시 불일치 – 데이터 변조 감지!");
            return false;
        }

        // 이전 블록과의 연결이 끊어지지 않았는지 검사
        if (!current.previousHash.equals(previous.hash)) {
            System.out.println("❌ 블록 #" + i + " 이전 해시 불일치 – 체인 연결 오류!");
            return false;
        }
    }
    System.out.println("✅ 체인 무결성 검증 통과!");
    return true;
}

public class Main {

    public static void main(String[] args) {

        System.out.println("=== Java 블록체인 시작 ===\n");

        // 블록체인 생성 (제네시스 블록 자동 생성)
        Blockchain blockchain = new Blockchain();

        // 블록 추가
        blockchain.addBlock("Alice → Bob: 10 BTC");
        blockchain.addBlock("Bob → Carol: 5 BTC");
        blockchain.addBlock("Carol → Dave: 2 BTC");

        System.out.println("\n=== 체인 출력 ===");
        for (Block block : blockchain.getChain()) {
            System.out.println(block);
        }

        System.out.println("\n=== 무결성 검증 ===");
        System.out.println("체인 유효: " + blockchain.isChainValid());

        // --- 변조 시뮬레이션 ---
        System.out.println("\n=== 변조 시도 (블록 #1 데이터 조작) ===");
        blockchain.getChain().get(1).data = "Alice → Hacker: 10 BTC";
        // 해시는 업데이트하지 않음 → 불일치 발생

        System.out.println("변조 후 체인 유효: " + blockchain.isChainValid());
    }
}

=== Java 블록체인 시작 ===

⛏ 채굴 완료! nonce: 8243 | 소요 시간: 312ms | 해시: 0000a3f1...
✅ 블록 추가 완료: Alice → Bob: 10 BTC
⛏ 채굴 완료! nonce: 14852 | 소요 시간: 487ms | 해시: 00004c2b...
✅ 블록 추가 완료: Bob → Carol: 5 BTC
...
✅ 체인 무결성 검증 통과!

=== 변조 시도 (블록 #1 데이터 조작) ===
❌ 블록 #1 해시 불일치 – 데이터 변조 감지!
변조 후 체인 유효: false