콘텐츠 대표 이미지 - 암호학: 다중 서명(Multisignature) 월렛 완전 정복 — 설계부터 구현까지
🔐 암호학 · 보안 · 프로그램개발

암호학: 다중 서명(Multisignature) 월렛 완전 정복 — 설계부터 구현까지

혼자 지키기엔 너무 소중한 자산, 여러 키로 함께 잠그는 멀티시그의 모든 것 🗝️✨

금고 🗝️ 서명자 1 Alice 🗝️ 서명자 2 Bob 🗝️ 서명자 3 Carol 다중 서명(Multisig) 월렛 2-of-3 서명 구조 — 3명 중 2명이 서명해야 트랜잭션 실행! 단일 키 → 해킹 취약 다중 키 → 보안 극강 🔒

🤔 멀티시그가 뭔데? 진짜 쉽게 설명해줄게

야 솔직히 말해서, 비트코인이나 이더리움 같은 암호화폐 들어봤지? 근데 그걸 보관하는 월렛(지갑)이 해킹당하거나 개인키 하나 잃어버리면 그냥 끝이잖아 ㅠㅠ
그래서 나온 게 바로 다중 서명(Multisignature, 줄여서 멀티시그) 월렛이야!

개념 자체는 엄청 직관적이야. 예를 들어 회사 금고 열려면 사장님 혼자 열 수 있으면 위험하잖아? 그래서 사장님 + 재무팀장 + 감사 이렇게 3명 중 2명이 동시에 열쇠를 꽂아야 열리게 만드는 거야. 이게 바로 2-of-3 멀티시그의 개념임 ㅋㅋ

암호학적으로 표현하면: m-of-n 서명 구조라고 해. n개의 키 중에서 최소 m개의 서명이 있어야 트랜잭션이 유효하다는 뜻이지.

📌 m-of-n 멀티시그 핵심 개념

n = 전체 서명자(키) 수
m = 트랜잭션 실행에 필요한 최소 서명 수 (m ≤ n)

예시:
1-of-1 일반 단일 서명 (그냥 일반 지갑)
2-of-2 2명 모두 서명해야 실행
2-of-3 3명 중 2명 서명으로 실행 (가장 많이 씀!)
3-of-5 5명 중 3명 서명으로 실행

근데 이게 단순히 "여러 명이 동의해야 한다"는 개념을 넘어서, 실제로 암호학적 수학으로 구현되는 거야. 그냥 소프트웨어 레벨에서 "2명이 OK 눌러야 함" 이런 게 아니라, 블록체인 프로토콜 자체에 박혀있는 보안 메커니즘이라는 거지. 이게 핵심 포인트임!


🔑 암호학 기초: 멀티시그를 이해하려면 이것부터

공개키 암호화(Public Key Cryptography) 빠르게 복습

멀티시그 이해하려면 먼저 공개키 암호화를 알아야 해. 이미 알고 있어도 잠깐 복습하고 가자!

기본 원리는 이래: 수학적으로 연결된 개인키(Private Key)와 공개키(Public Key) 쌍을 만들어. 개인키로 서명하면, 공개키로 그 서명이 진짜인지 검증할 수 있어. 반대로는 안 됨 — 공개키로 개인키를 역산하는 건 수학적으로 불가능에 가까워 (이산 로그 문제, Discrete Logarithm Problem).

🧮 타원 곡선 암호화(ECC) — 비트코인/이더리움의 핵심

비트코인과 이더리움은 secp256k1 타원 곡선을 사용해.

타원 곡선 방정식: y² = x³ + 7 (mod p)
여기서 p는 엄청 큰 소수 (2²⁵⁶ - 2³² - 977)

개인키 k (256비트 랜덤 숫자) → 공개키 K = k × G
(G는 타원 곡선의 생성점, Generator Point)

이 연산은 한 방향으로만 쉬워. K에서 k를 역산하는 건 현재 컴퓨터로 우주 나이보다 오래 걸림 ㄷㄷ

디지털 서명(ECDSA) 동작 원리

멀티시그에서 각 서명자가 사용하는 서명 알고리즘이야. ECDSA(Elliptic Curve Digital Signature Algorithm)라고 해.

📝 메시지(트랜잭션)
→
🔢 해시 생성 (SHA-256)
→
🗝️ 개인키로 서명
→
✅ 서명값 (r, s)

서명 검증 과정:
1. 서명값 (r, s)와 공개키 Q를 가지고
2. 원본 메시지 해시 e를 계산
3. 수학적 연산으로 서명이 해당 공개키의 개인키로 만들어진 게 맞는지 확인

멀티시그에서는 이 과정을 여러 키에 대해 반복하고, 충분한 수의 유효한 서명이 모였을 때만 트랜잭션을 실행하는 거야!


비트코인 P2SH 멀티시그 트랜잭션 흐름 ① 리딤 스크립트 생성 (Redeem Script) m, n, 공개키 목록 ② P2SH 주소 리딤스크립트 해시 → 3으로 시작하는 주소 ③ 자금 수신 P2SH 주소로 비트코인 전송 ④ 서명 수집 m개의 서명자가 각자 서명 ⑤ 트랜잭션 브로드캐스트 서명 + 리딤스크립트 포함 블록체인 네트워크에 전파 ⑥ 검증 및 실행 ✅ 노드가 서명 유효성 검증 후 실행

⛓️ 비트코인에서의 멀티시그 구현

P2SH (Pay-to-Script-Hash) 방식

비트코인에서 멀티시그를 구현하는 가장 대표적인 방법이 P2SH야. 2012년 BIP-16으로 표준화됐어.

핵심 아이디어: 복잡한 잠금 조건(스크립트)을 직접 노출하지 않고, 그 스크립트의 해시값만 주소에 담는 거야. 그래서 주소가 짧고 깔끔해지고, 실제 조건은 자금을 쓸 때만 공개돼.

🔧 리딤 스크립트(Redeem Script) 구조

2-of-3 멀티시그의 리딤 스크립트:

OP_2 <공개키1> <공개키2> <공개키3> OP_3 OP_CHECKMULTISIG


OP_2: 최소 2개의 서명 필요
공개키들: 서명자들의 공개키 (33바이트 압축 형식)
OP_3: 총 3개의 공개키
OP_CHECKMULTISIG: 멀티시그 검증 실행

P2SH 주소 생성 과정

1
리딤 스크립트 직렬화 (바이트 배열로 변환)
2
SHA-256 해시 → RIPEMD-160 해시 적용 (= Hash160)
3
버전 바이트(0x05) 앞에 붙이기
4
체크섬 계산 (SHA-256 두 번 적용 후 앞 4바이트)
5
Base58Check 인코딩 → 3으로 시작하는 주소 완성!
# Python으로 P2SH 주소 생성 예시
import hashlib
import base58

def hash160(data: bytes) -> bytes:
    """SHA-256 후 RIPEMD-160 적용"""
    sha256_hash = hashlib.sha256(data).digest()
    ripemd160 = hashlib.new('ripemd160')
    ripemd160.update(sha256_hash)
    return ripemd160.digest()

def p2sh_address(redeem_script: bytes) -> str:
    """리딤 스크립트로부터 P2SH 주소 생성"""
    script_hash = hash160(redeem_script)
    
    # 버전 바이트 0x05 (메인넷 P2SH)
    versioned = b'\x05' + script_hash
    
    # 체크섬 계산
    checksum = hashlib.sha256(
        hashlib.sha256(versioned).digest()
    ).digest()[:4]
    
    # Base58Check 인코딩
    return base58.b58encode(versioned + checksum).decode()

# 리딤 스크립트 예시 (2-of-3)
# OP_2 = 0x52, OP_3 = 0x53, OP_CHECKMULTISIG = 0xae
redeem_script = (
    b'\x52'           # OP_2
    + b'\x21' + pubkey1  # 공개키1 (33바이트)
    + b'\x21' + pubkey2  # 공개키2
    + b'\x21' + pubkey3  # 공개키3
    + b'\x53'         # OP_3
    + b'\xae'         # OP_CHECKMULTISIG
)

address = p2sh_address(redeem_script)
print(f"P2SH 주소: {address}")  # 3으로 시작!

P2WSH (SegWit 버전) — 더 효율적인 멀티시그

2017년 SegWit 업그레이드 이후 P2WSH(Pay-to-Witness-Script-Hash)가 등장했어. P2SH랑 개념은 비슷한데 서명 데이터를 위트니스(Witness) 영역에 분리해서 저장해. 이렇게 하면:

✅ 트랜잭션 크기 줄어듦 → 수수료 절감 (약 30~40%)
✅ 트랜잭션 가변성(Malleability) 문제 해결
✅ bc1로 시작하는 bech32 주소 사용

# P2WSH 주소 생성 (bech32 인코딩)
import hashlib

def p2wsh_address(redeem_script: bytes, network='mainnet') -> str:
    """P2WSH 주소 생성"""
    # SHA-256 한 번만 적용 (P2SH의 Hash160과 다름!)
    script_hash = hashlib.sha256(redeem_script).digest()
    
    # bech32 인코딩 (witness version 0)
    hrp = 'bc' if network == 'mainnet' else 'tb'
    return bech32_encode(hrp, 0, script_hash)
    # 결과: bc1q... 로 시작하는 주소

💎 이더리움에서의 멀티시그 구현

스마트 컨트랙트 기반 멀티시그

이더리움은 비트코인이랑 접근 방식이 달라. 비트코인은 스크립트 레벨에서 멀티시그를 처리하지만, 이더리움은 스마트 컨트랙트로 구현해. 이게 훨씬 유연하고 강력함!

가장 유명한 구현체는 Gnosis Safe(현재 Safe{Wallet})야. 수십억 달러 규모의 자산을 관리하는 데 쓰이고 있어 ㄷㄷ

🏗️ 이더리움 멀티시그 스마트 컨트랙트 핵심 구조

주요 상태 변수:
- owners: 서명자 주소 목록
- required: 필요한 최소 서명 수
- transactions: 제안된 트랜잭션 목록
- confirmations: 각 트랜잭션에 대한 서명 현황

주요 함수:
- submitTransaction(): 트랜잭션 제안
- confirmTransaction(): 서명 추가
- executeTransaction(): 조건 충족 시 실행
- revokeConfirmation(): 서명 취소

// Solidity로 구현한 간단한 멀티시그 월렛
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract MultiSigWallet {
    
    // 이벤트 정의
    event Deposit(address indexed sender, uint amount);
    event SubmitTransaction(
        address indexed owner,
        uint indexed txIndex,
        address indexed to,
        uint value,
        bytes data
    );
    event ConfirmTransaction(address indexed owner, uint indexed txIndex);
    event RevokeConfirmation(address indexed owner, uint indexed txIndex);
    event ExecuteTransaction(address indexed owner, uint indexed txIndex);

    // 상태 변수
    address[] public owners;
    mapping(address => bool) public isOwner;
    uint public numConfirmationsRequired;

    // 트랜잭션 구조체
    struct Transaction {
        address to;
        uint value;
        bytes data;
        bool executed;
        uint numConfirmations;
    }

    // 트랜잭션 목록
    Transaction[] public transactions;
    
    // 서명 현황: txIndex => owner => confirmed
    mapping(uint => mapping(address => bool)) public isConfirmed;

    // 수정자(Modifier)
    modifier onlyOwner() {
        require(isOwner[msg.sender], "서명자가 아닙니다");
        _;
    }

    modifier txExists(uint _txIndex) {
        require(_txIndex < transactions.length, "트랜잭션 없음");
        _;
    }

    modifier notExecuted(uint _txIndex) {
        require(!transactions[_txIndex].executed, "이미 실행됨");
        _;
    }

    modifier notConfirmed(uint _txIndex) {
        require(!isConfirmed[_txIndex][msg.sender], "이미 서명함");
        _;
    }

    // 생성자
    constructor(address[] memory _owners, uint _numConfirmationsRequired) {
        require(_owners.length > 0, "서명자 필요");
        require(
            _numConfirmationsRequired > 0 &&
            _numConfirmationsRequired <= _owners.length,
            "잘못된 서명 수"
        );

        for (uint i = 0; i < _owners.length; i++) {
            address owner = _owners[i];
            require(owner != address(0), "잘못된 주소");
            require(!isOwner[owner], "중복 서명자");
            
            isOwner[owner] = true;
            owners.push(owner);
        }

        numConfirmationsRequired = _numConfirmationsRequired;
    }

    // ETH 수신
    receive() external payable {
        emit Deposit(msg.sender, msg.value);
    }

    // 트랜잭션 제안
    function submitTransaction(
        address _to,
        uint _value,
        bytes memory _data
    ) public onlyOwner {
        uint txIndex = transactions.length;

        transactions.push(Transaction({
            to: _to,
            value: _value,
            data: _data,
            executed: false,
            numConfirmations: 0
        }));

        emit SubmitTransaction(msg.sender, txIndex, _to, _value, _data);
    }

    // 트랜잭션 서명
    function confirmTransaction(uint _txIndex)
        public
        onlyOwner
        txExists(_txIndex)
        notExecuted(_txIndex)
        notConfirmed(_txIndex)
    {
        Transaction storage transaction = transactions[_txIndex];
        transaction.numConfirmations += 1;
        isConfirmed[_txIndex][msg.sender] = true;

        emit ConfirmTransaction(msg.sender, _txIndex);
    }

    // 트랜잭션 실행
    function executeTransaction(uint _txIndex)
        public
        onlyOwner
        txExists(_txIndex)
        notExecuted(_txIndex)
    {
        Transaction storage transaction = transactions[_txIndex];

        require(
            transaction.numConfirmations >= numConfirmationsRequired,
            "서명 부족"
        );

        transaction.executed = true;

        (bool success, ) = transaction.to.call{value: transaction.value}(
            transaction.data
        );
        require(success, "트랜잭션 실행 실패");

        emit ExecuteTransaction(msg.sender, _txIndex);
    }

    // 서명 취소
    function revokeConfirmation(uint _txIndex)
        public
        onlyOwner
        txExists(_txIndex)
        notExecuted(_txIndex)
    {
        require(isConfirmed[_txIndex][msg.sender], "서명하지 않음");

        Transaction storage transaction = transactions[_txIndex];
        transaction.numConfirmations -= 1;
        isConfirmed[_txIndex][msg.sender] = false;

        emit RevokeConfirmation(msg.sender, _txIndex);
    }
}

위 코드가 기본적인 이더리움 멀티시그 월렛의 뼈대야. 실제 프로덕션에서는 여기에 더 많은 보안 검사, 타임락(Timelock), 가스 최적화 등이 추가돼. 재능넷 같은 플랫폼에서 블록체인 개발자를 찾는다면 이런 스마트 컨트랙트 구현 능력이 핵심 스킬 중 하나야!


이더리움 멀티시그 트랜잭션 라이프사이클 📝 제안 submitTransaction Alice가 트랜잭션 제안 및 서명 ✍️ 서명1 confirmTransaction Bob이 서명 확인 수: 1/2 ✍️ 서명2 confirmTransaction Carol이 서명 확인 수: 2/2 ✅ 🚀 실행! executeTransaction 서명 수 충족 확인 ETH/토큰 전송 실행 2-of-3 구조: Alice 제안 + Bob 서명 + Carol 서명 → 3명 중 2명 서명 완료 → 자동 실행 가능!

🔬 고급 멀티시그 기술: Schnorr 서명과 MPC

Schnorr 서명 — 멀티시그의 게임 체인저

비트코인 Taproot 업그레이드(2021년 11월)와 함께 Schnorr 서명이 도입됐어. 이게 왜 혁명적이냐면... 기존 ECDSA 멀티시그는 서명자 수만큼 서명 데이터가 커지는데, Schnorr은 서명을 하나로 합칠 수 있거든!

이걸 MuSig(Multi-Signature Scheme)이라고 해.

⚡ Schnorr vs ECDSA 멀티시그 비교
항목 ECDSA 멀티시그 Schnorr/MuSig
서명 크기 서명자 수 × ~72바이트 단일 서명 ~64바이트
프라이버시 멀티시그임이 온체인에 노출 일반 단일 서명과 구분 불가
수수료 높음 낮음 (최대 50% 절감)
선형성 없음 있음 (키 집계 가능)

Schnorr 서명의 수학적 원리

Schnorr 서명이 왜 집계(Aggregation)가 가능한지 수학적으로 살펴보자. 겁먹지 마, 생각보다 직관적이야 ㅋㅋ

🧮 Schnorr 서명 생성 과정

단일 서명자의 경우:
1. 개인키: x, 공개키: X = x·G
2. 랜덤 nonce: r, R = r·G
3. 챌린지: e = H(R || X || 메시지)
4. 서명: s = r + e·x (mod n)
5. 서명값: (R, s)

검증:
s·G = R + e·X 인지 확인
(s·G = (r + e·x)·G = r·G + e·x·G = R + e·X ✅)

2-of-2 MuSig의 경우:
- 공개키 집계: X_agg = X₁ + X₂ (단순화 버전)
- 서명 집계: s_agg = s₁ + s₂
- 검증: s_agg·G = R_agg + e·X_agg
→ 외부에서 보면 그냥 단일 서명처럼 보임! 🎭

# Python으로 간단한 Schnorr 서명 구현 (교육용)
# 실제 프로덕션에서는 검증된 라이브러리 사용할 것!

from cryptography.hazmat.primitives.asymmetric.ec import (
    SECP256K1, generate_private_key, EllipticCurvePublicKey
)
import hashlib
import secrets

# secp256k1 파라미터
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8

def point_add(P, Q):
    """타원 곡선 점 덧셈"""
    if P is None: return Q
    if Q is None: return P
    if P[0] == Q[0] and P[1] != Q[1]: return None
    
    if P == Q:
        lam = (3 * P[0] * P[0] * pow(2 * P[1], p-2, p)) % p
    else:
        lam = ((Q[1] - P[1]) * pow(Q[0] - P[0], p-2, p)) % p
    
    x = (lam * lam - P[0] - Q[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def point_mul(k, P):
    """타원 곡선 스칼라 곱셈"""
    R = None
    while k:
        if k & 1:
            R = point_add(R, P)
        P = point_add(P, P)
        k >>= 1
    return R

G = (Gx, Gy)

def schnorr_sign(private_key: int, message: bytes) -> tuple:
    """Schnorr 서명 생성"""
    # 공개키 계산
    P = point_mul(private_key, G)
    
    # 랜덤 nonce
    k = secrets.randbelow(n - 1) + 1
    R = point_mul(k, G)
    
    # 챌린지 해시
    rx_bytes = R[0].to_bytes(32, 'big')
    px_bytes = P[0].to_bytes(32, 'big')
    e = int.from_bytes(
        hashlib.sha256(rx_bytes + px_bytes + message).digest(), 
        'big'
    ) % n
    
    # 서명값 s
    s = (k + e * private_key) % n
    
    return (R[0], s)  # (r, s)

def schnorr_verify(public_key: tuple, message: bytes, sig: tuple) -> bool:
    """Schnorr 서명 검증"""
    r, s = sig
    P = public_key
    
    # 챌린지 재계산
    rx_bytes = r.to_bytes(32, 'big')
    px_bytes = P[0].to_bytes(32, 'big')
    e = int.from_bytes(
        hashlib.sha256(rx_bytes + px_bytes + message).digest(),
        'big'
    ) % n
    
    # 검증: s*G == R + e*P
    sG = point_mul(s, G)
    eP = point_mul(e, P)
    R_check = point_add(sG, point_add(eP, (eP[0], (-eP[1]) % p)))
    # 실제로는 R + e*P 계산
    R_expected = point_add(point_mul(s, G), 
                           point_mul(n - e, P))
    
    return R_expected[0] == r

# 사용 예시
private_key = secrets.randbelow(n - 1) + 1
public_key = point_mul(private_key, G)
message = b"Hello, Multisig World!"

signature = schnorr_sign(private_key, message)
is_valid = schnorr_verify(public_key, message, signature)
print(f"서명 유효: {is_valid}")  # True

MPC(Multi-Party Computation) 기반 멀티시그

최근에는 MPC(다자간 연산) 기반 멀티시그도 많이 쓰여. 이건 개념이 좀 달라 — 기존 멀티시그는 여러 개의 키가 온체인에 노출되지만, MPC는 키 자체를 분산해서 아무도 완전한 키를 갖지 않아.

예를 들어 2-of-3 MPC 방식이면:
- Alice, Bob, Carol이 각자 키 조각(Key Share)을 가짐
- 2명이 협력해서 연산하면 서명이 생성됨
- 하지만 실제 개인키는 어디에도 존재하지 않음!

이 방식의 장점은 온체인에서 보면 그냥 일반 단일 서명처럼 보인다는 거야. 프라이버시 극강!

⚠️ MPC vs 전통 멀티시그 선택 기준

전통 멀티시그 선택 시:
✅ 온체인 투명성이 필요한 경우 (DAO, 기업 금고)
✅ 스마트 컨트랙트 기반 복잡한 로직 필요
✅ 감사(Audit) 가능성이 중요한 경우

MPC 선택 시:
✅ 프라이버시가 최우선인 경우
✅ 수수료 최소화가 중요한 경우
✅ 키 관리 인프라를 완전히 통제 가능한 경우
✅ 거래소, 커스터디 서비스 등 기관용


🛠️ 실전 구현: Python으로 비트코인 멀티시그 월렛 만들기

필요한 라이브러리 설치

# 필요한 패키지 설치
pip install bitcoin-utils
pip install python-bitcoinlib
pip install cryptography
pip install base58

키 생성 및 멀티시그 주소 생성

"""
비트코인 2-of-3 멀티시그 월렛 구현
bitcoin-utils 라이브러리 활용
"""
from bitcoinutils.setup import setup
from bitcoinutils.keys import PrivateKey, P2shAddress
from bitcoinutils.script import Script
from bitcoinutils.transactions import Transaction, TxInput, TxOutput
from bitcoinutils.utils import to_satoshis

# 테스트넷 설정
setup('testnet')

class MultiSigWallet:
    """2-of-3 비트코인 멀티시그 월렛"""
    
    def __init__(self, m: int, n: int):
        """
        m: 필요한 서명 수
        n: 전체 서명자 수
        """
        self.m = m
        self.n = n
        self.private_keys = []
        self.public_keys = []
        self.redeem_script = None
        self.address = None
    
    def generate_keys(self):
        """n개의 키 쌍 생성"""
        for i in range(self.n):
            priv_key = PrivateKey()  # 랜덤 개인키 생성
            pub_key = priv_key.get_public_key()
            
            self.private_keys.append(priv_key)
            self.public_keys.append(pub_key)
            
            print(f"서명자 {i+1}:")
            print(f"  개인키 (WIF): {priv_key.to_wif()}")
            print(f"  공개키: {pub_key.to_hex()}")
        
        return self.private_keys, self.public_keys
    
    def create_multisig_address(self):
        """멀티시그 P2SH 주소 생성"""
        # 공개키 목록으로 리딤 스크립트 생성
        pub_key_hexes = [pk.to_hex() for pk in self.public_keys]
        
        # OP_m <pubkey1> <pubkey2> ... <pubkeyN> OP_n OP_CHECKMULTISIG
        self.redeem_script = Script([
            f'OP_{self.m}',
            *pub_key_hexes,
            f'OP_{self.n}',
            'OP_CHECKMULTISIG'
        ])
        
        # P2SH 주소 생성
        self.address = P2shAddress.from_script(self.redeem_script)
        
        print(f"\n멀티시그 주소: {self.address.to_string()}")
        print(f"리딤 스크립트: {self.redeem_script.to_hex()}")
        
        return self.address
    
    def create_spending_transaction(
        self, 
        utxo_txid: str,
        utxo_vout: int,
        utxo_amount: float,
        recipient_address: str,
        send_amount: float,
        fee: float,
        signing_key_indices: list
    ) -> Transaction:
        """
        멀티시그 지출 트랜잭션 생성 및 서명
        
        signing_key_indices: 서명할 키의 인덱스 목록 (m개)
        """
        # 트랜잭션 입력 생성
        tx_input = TxInput(utxo_txid, utxo_vout)
        
        # 트랜잭션 출력 생성
        from bitcoinutils.keys import P2pkhAddress
        recipient = P2pkhAddress(recipient_address)
        tx_output = TxOutput(
            to_satoshis(send_amount),
            recipient.to_script_pub_key()
        )
        
        # 잔돈 출력 (있는 경우)
        change_amount = utxo_amount - send_amount - fee
        outputs = [tx_output]
        
        if change_amount > 0:
            change_output = TxOutput(
                to_satoshis(change_amount),
                self.address.to_script_pub_key()
            )
            outputs.append(change_output)
        
        # 트랜잭션 생성
        tx = Transaction([tx_input], outputs)
        
        # 서명 수집
        signatures = []
        for key_idx in signing_key_indices[:self.m]:
            priv_key = self.private_keys[key_idx]
            sig = priv_key.sign_input(
                tx, 0, self.redeem_script
            )
            signatures.append(sig)
            print(f"서명자 {key_idx+1} 서명 완료")
        
        # 서명스크립트 설정
        # OP_0 <sig1> <sig2> ... <redeem_script>
        tx_input.script_sig = Script([
            'OP_0',  # CHECKMULTISIG 버그 우회용
            *signatures,
            self.redeem_script.to_hex()
        ])
        
        print(f"\n서명된 트랜잭션 hex:")
        print(tx.serialize())
        
        return tx

# 사용 예시
def main():
    print("=== 2-of-3 멀티시그 월렛 생성 ===\n")
    
    wallet = MultiSigWallet(m=2, n=3)
    
    # 키 생성
    wallet.generate_keys()
    
    # 멀티시그 주소 생성
    address = wallet.create_multisig_address()
    
    print(f"\n이 주소로 테스트넷 BTC를 보내세요:")
    print(f"주소: {address.to_string()}")
    print(f"\n자금 수신 후 지출 트랜잭션을 생성하려면")
    print(f"UTXO 정보(txid, vout, amount)가 필요합니다.")

if __name__ == "__main__":
    main()

PSBT(Partially Signed Bitcoin Transaction) 활용

실제 멀티시그 워크플로우에서는 PSBT(BIP-174)를 많이 써. 여러 서명자가 오프라인에서 순차적으로 서명을 추가할 수 있는 표준 포맷이야.

📋 PSBT 워크플로우
1
Creator: 미서명 트랜잭션 생성 → PSBT 파일 생성
2
Updater: UTXO 정보, 리딤 스크립트 등 메타데이터 추가
3
Signer 1: 자신의 키로 서명 추가 → PSBT 업데이트
4
Signer 2: 자신의 키로 서명 추가 → PSBT 업데이트
5
Finalizer: 서명 결합, 최종 트랜잭션 완성
6
Extractor: 완성된 트랜잭션 추출 → 브로드캐스트
# python-bitcoinlib으로 PSBT 처리 예시
from bitcoin.core.psbt import PSBT, PartiallySignedInput
from bitcoin.core import CMutableTransaction, CMutableTxIn, CMutableTxOut
from bitcoin.core.script import CScript, OP_2, OP_3, OP_CHECKMULTISIG
from bitcoin.wallet import CBitcoinSecret
import bitcoin

bitcoin.SelectParams('testnet')

def create_psbt_multisig(
    utxo_txid: bytes,
    utxo_vout: int,
    recipient_script: bytes,
    amount_satoshi: int,
    redeem_script: bytes
) -> PSBT:
    """PSBT 멀티시그 트랜잭션 생성"""
    
    # 미서명 트랜잭션 생성
    tx_in = CMutableTxIn(
        prevout=bitcoin.core.COutPoint(utxo_txid, utxo_vout)
    )
    tx_out = CMutableTxOut(
        nValue=amount_satoshi,
        scriptPubKey=CScript(recipient_script)
    )
    
    unsigned_tx = CMutableTransaction(
        vin=[tx_in],
        vout=[tx_out]
    )
    
    # PSBT 생성
    psbt = PSBT(unsigned_tx)
    
    # 입력에 리딤 스크립트 추가
    psbt.inputs[0].redeem_script = CScript(redeem_script)
    
    return psbt

def sign_psbt(psbt: PSBT, private_key_wif: str, input_index: int) -> PSBT:
    """PSBT에 서명 추가"""
    priv_key = CBitcoinSecret(private_key_wif)
    
    # 서명 해시 계산 및 서명
    sig_hash = psbt.inputs[input_index].get_sighash(
        psbt.unsigned_tx, input_index
    )
    signature = priv_key.sign(sig_hash)
    
    # 서명을 PSBT에 추가
    pub_key = priv_key.pub
    psbt.inputs[input_index].partial_sigs[pub_key] = signature
    
    return psbt

# PSBT를 base64로 인코딩해서 다른 서명자에게 전달
import base64

def psbt_to_base64(psbt: PSBT) -> str:
    return base64.b64encode(psbt.serialize()).decode()

def psbt_from_base64(psbt_b64: str) -> PSBT:
    return PSBT.deserialize(base64.b64decode(psbt_b64))

🔒 보안 고려사항 — 이거 모르면 진짜 위험해

1. 키 생성 보안

멀티시그의 보안은 결국 각 개인키의 보안에서 시작해. 키 생성 시 반드시 암호학적으로 안전한 난수 생성기(CSPRNG)를 사용해야 해.

🚨 절대 하면 안 되는 것들

❌ random.randint() 같은 일반 난수 사용 (예측 가능!)
❌ 시드값으로 날짜/시간 사용
❌ 같은 nonce를 두 번 사용 (개인키 노출됨!)
❌ 키를 평문으로 저장
❌ 인터넷 연결된 환경에서 키 생성 (에어갭 권장)

# 올바른 키 생성 방법
import secrets
import os

# ✅ 올바른 방법: os.urandom() 또는 secrets 모듈 사용
def generate_secure_private_key() -> int:
    """암호학적으로 안전한 개인키 생성"""
    while True:
        # 32바이트 = 256비트 랜덤
        key_bytes = os.urandom(32)
        key_int = int.from_bytes(key_bytes, 'big')
        
        # secp256k1 범위 확인 (1 ~ n-1)
        n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
        if 1 <= key_int < n:
            return key_int

# ❌ 잘못된 방법 (절대 사용 금지!)
# import random
# bad_key = random.randint(1, n-1)  # 예측 가능!

2. 키 분산 보관 전략

2-of-3 멀티시그를 쓴다면 3개의 키를 어떻게 보관할지가 핵심이야. 일반적인 모범 사례:

🏠 개인 사용자

키 1: 하드웨어 월렛 (Ledger/Trezor)
키 2: 다른 하드웨어 월렛
키 3: 금고에 보관된 종이 지갑

→ 하드웨어 월렛 하나 잃어도 OK!

🏢 기업/조직

키 1: CTO 하드웨어 월렛
키 2: CFO 하드웨어 월렛
키 3: 법무팀 에스크로 서비스

→ 한 명 이탈해도 자산 안전!

3. 스마트 컨트랙트 보안 감사

이더리움 멀티시그 스마트 컨트랙트는 배포 전에 반드시 보안 감사(Security Audit)를 받아야 해. 역사적으로 멀티시그 컨트랙트 취약점으로 엄청난 피해가 있었거든:

📚 역사적 멀티시그 해킹 사례

2017년 Parity 멀티시그 버그 (1차)
- 취약점: 초기화 함수가 public으로 노출
- 피해: 약 3,000만 달러 ETH 탈취

2017년 Parity 멀티시그 버그 (2차)
- 취약점: 라이브러리 컨트랙트의 self-destruct 호출 가능
- 피해: 약 1억 5천만 달러 ETH 영구 동결 (탈취 아님, 잠김)

교훈: 아무리 유명한 팀이 만들어도 감사 필수!

// 보안 취약점 예시 및 수정

// ❌ 취약한 코드 - 초기화 함수가 누구나 호출 가능
contract VulnerableMultiSig {
    address[] public owners;
    bool public initialized;
    
    // 누구나 호출 가능! 공격자가 owners를 덮어쓸 수 있음
    function initWallet(address[] memory _owners) public {
        require(!initialized);
        owners = _owners;
        initialized = true;
    }
}

// ✅ 안전한 코드 - 생성자에서만 초기화
contract SafeMultiSig {
    address[] public owners;
    
    // 생성자는 배포 시 한 번만 실행됨
    constructor(address[] memory _owners) {
        require(_owners.length > 0, "서명자 필요");
        for (uint i = 0; i < _owners.length; i++) {
            require(_owners[i] != address(0));
            owners.push(_owners[i]);
        }
    }
}

// ✅ 재진입 공격 방지 (Reentrancy Guard)
contract SafeExecute {
    bool private locked;
    
    modifier nonReentrant() {
        require(!locked, "재진입 금지");
        locked = true;
        _;
        locked = false;
    }
    
    function executeTransaction(uint _txIndex) 
        public 
        nonReentrant  // 재진입 방지!
    {
        // ... 실행 로직
    }
}

4. 오프체인 서명 조율 보안

여러 서명자가 협력할 때 통신 채널의 보안도 중요해. 서명 요청을 중간에서 가로채거나 변조하는 공격을 막아야 해.

🛡️ 안전한 서명 조율 방법

✅ E2E 암호화 채널로 PSBT 전달
✅ 서명 전 트랜잭션 내용 독립적으로 검증 (수신 주소, 금액 확인)
✅ 하드웨어 월렛의 화면에서 직접 내용 확인
✅ 대용량 트랜잭션은 타임락(Timelock) 설정
✅ 서명자 간 대역외(Out-of-Band) 확인 (전화 통화 등)


🌐 실제 멀티시그 솔루션들

비트코인 멀티시그 솔루션

솔루션 방식 특징
Electrum P2SH / P2WSH 오픈소스, 데스크탑 앱, 하드웨어 월렛 연동
Specter Desktop P2WSH / Taproot 비트코인 전용, 에어갭 지원, PSBT 완벽 지원
Caravan P2SH / P2WSH Unchained Capital 제공, 오픈소스 웹앱
Casa P2WSH 3-of-5 멀티시그, 키 복구 서비스 포함

이더리움 멀티시그 솔루션

솔루션 방식 특징
Safe (Gnosis Safe) 스마트 컨트랙트 업계 표준, 수백억 달러 TVL, 모듈 시스템
Argent 스마트 컨트랙트 소셜 복구 기능, 모바일 친화적
Fireblocks MPC-CMP 기관용, MPC 기반, 정책 엔진
Zengo MPC 시드 프레이즈 없음, 생체인증 복구

Safe 스마트 컨트랙트 아키텍처 (심화)

Gnosis Safe는 단순한 멀티시그를 넘어서 모듈 시스템을 갖추고 있어. 이게 왜 강력하냐면, 기본 멀티시그 기능 위에 다양한 기능을 플러그인처럼 추가할 수 있거든.

// Safe 스마트 컨트랙트 핵심 구조 (단순화 버전)
// 실제 Safe 컨트랙트는 훨씬 복잡함

contract GnosisSafe {
    
    // EIP-712 도메인 구분자
    bytes32 public domainSeparator;
    
    // 서명자 관련
    mapping(address => address) internal owners;  // 연결 리스트
    uint256 internal ownerCount;
    uint256 public threshold;  // 필요 서명 수
    
    // 트랜잭션 nonce (재사용 공격 방지)
    uint256 public nonce;
    
    // 모듈 시스템
    mapping(address => address) internal modules;
    
    // 가드 (트랜잭션 전/후 검사)
    address internal guard;
    
    // 핵심 실행 함수
    function execTransaction(
        address to,
        uint256 value,
        bytes calldata data,
        Enum.Operation operation,  // CALL 또는 DELEGATECALL
        uint256 safeTxGas,
        uint256 baseGas,
        uint256 gasPrice,
        address gasToken,
        address payable refundReceiver,
        bytes memory signatures  // 인코딩된 서명들
    ) public payable returns (bool success) {
        
        // 1. 트랜잭션 해시 계산 (EIP-712)
        bytes32 txHash = getTransactionHash(
            to, value, data, operation,
            safeTxGas, baseGas, gasPrice,
            gasToken, refundReceiver, nonce
        );
        
        // 2. nonce 증가 (재사용 방지)
        nonce++;
        
        // 3. 가드 사전 검사
        if (guard != address(0)) {
            Guard(guard).checkTransaction(
                to, value, data, operation, ...
            );
        }
        
        // 4. 서명 검증
        checkSignatures(txHash, data, signatures);
        
        // 5. 트랜잭션 실행
        success = execute(to, value, data, operation, gasleft());
        
        // 6. 가드 사후 검사
        if (guard != address(0)) {
            Guard(guard).checkAfterExecution(txHash, success);
        }
        
        emit ExecutionSuccess(txHash, payment);
    }
    
    // EIP-712 서명 검증
    function checkSignatures(
        bytes32 dataHash,
        bytes memory data,
        bytes memory signatures
    ) public view {
        uint256 _threshold = threshold;
        require(_threshold > 0, "임계값 미설정");
        require(
            signatures.length >= _threshold * 65,
            "서명 부족"
        );
        
        address lastOwner = address(0);
        address currentOwner;
        
        for (uint256 i = 0; i < _threshold; i++) {
            // 각 서명 추출 및 검증
            (uint8 v, bytes32 r, bytes32 s) = signatureSplit(
                signatures, i
            );
            
            if (v == 0) {
                // 컨트랙트 서명 (EIP-1271)
                currentOwner = address(uint160(uint256(r)));
                require(
                    ISignatureValidator(currentOwner)
                        .isValidSignature(dataHash, data) == 
                        EIP1271_MAGIC_VALUE,
                    "컨트랙트 서명 무효"
                );
            } else if (v == 1) {
                // 미리 승인된 해시
                currentOwner = address(uint160(uint256(r)));
            } else {
                // ECDSA 서명
                currentOwner = ecrecover(
                    dataHash, v - 4, r, s
                );
            }
            
            require(
                currentOwner > lastOwner && 
                isOwner(currentOwner),
                "서명자 순서 오류 또는 미등록 서명자"
            );
            lastOwner = currentOwner;
        }
    }
}

멀티시그 보안 레이어 구조 자산 보호됨 m-of-n 서명 검증 ECDSA / Schnorr 암호화 키 분산 보관 전략 레이어 3: 물리적 보안 하드웨어 월렛, 에어갭 레이어 2: 암호학적 보안 타원 곡선, 해시 함수 레이어 1: 프로토콜 보안 스크립트 / 스마트 컨트랙트 ⚠️ 공격 벡터 키 도난 피싱 공격 컨트랙트 버그 소셜 엔지니어링 멀티시그는 단일 실패 지점(SPOF)을 제거하는 핵심 보안 메커니즘 여러 레이어의 보안이 함께 작동해야 진정한 보호 가능 🛡️

🚀 고급 주제: Taproot와 멀티시그의 미래

Taproot (BIP-340, 341, 342)

비트코인의 Taproot 업그레이드는 멀티시그에 혁명을 가져왔어. 핵심은 MAST(Merkelized Alternative Script Trees)와 Schnorr 서명의 결합이야.

🌳 MAST + Taproot 멀티시그의 장점

시나리오: 3-of-5 멀티시그 + 타임락 복구 조건

기존 방식:
- 모든 조건이 온체인에 노출
- 사용하지 않는 조건도 수수료 지불
- 멀티시그임이 명확히 보임

Taproot 방식:
- 정상 경로: 모든 서명자 협력 → Schnorr 집계 서명 (일반 거래처럼 보임!)
- 비상 경로: 타임락 후 복구 키 사용 (실제 사용 시에만 공개)
- 사용하지 않은 조건은 영원히 비공개
- 수수료 최소화, 프라이버시 극대화

# Taproot 멀티시그 주소 생성 (개념 코드)
# python-bitcoinlib 최신 버전 기준

from bitcoin.core.key import CPubKey
from bitcoin.core.script import (
    CScript, OP_CHECKSIG, OP_CHECKSIGADD, OP_NUMEQUAL
)
import hashlib

def create_taproot_multisig(
    pubkeys: list,
    threshold: int
) -> bytes:
    """
    Taproot 기반 멀티시그 스크립트 생성
    OP_CHECKSIGADD 사용 (Tapscript 전용 opcodes)
    """
    # Tapscript 멀티시그: OP_CHECKSIGADD 방식
    # <pubkey1> OP_CHECKSIG
    # <pubkey2> OP_CHECKSIGADD
    # ...
    # <threshold> OP_NUMEQUAL
    
    script_parts = []
    
    for i, pubkey in enumerate(pubkeys):
        script_parts.append(pubkey)
        if i == 0:
            script_parts.append(OP_CHECKSIG)
        else:
            script_parts.append(OP_CHECKSIGADD)
    
    script_parts.append(threshold)
    script_parts.append(OP_NUMEQUAL)
    
    return CScript(script_parts)

def taproot_tweak_pubkey(
    internal_pubkey: bytes,
    merkle_root: bytes
) -> bytes:
    """
    Taproot 공개키 트윅 (tweaking)
    P_output = P_internal + t*G
    t = H_taptweak(P_internal || merkle_root)
    """
    # 태그드 해시 계산
    tag = b"TapTweak"
    tag_hash = hashlib.sha256(tag).digest()
    
    tweak_input = tag_hash + tag_hash + internal_pubkey + merkle_root
    t = int.from_bytes(hashlib.sha256(tweak_input).digest(), 'big')
    
    # 실제 구현에서는 secp256k1 라이브러리 사용
    # output_pubkey = internal_pubkey + t * G
    
    return t  # 실제로는 트윅된 공개키 반환

# Taproot 주소 (bc1p로 시작)
# bech32m 인코딩 사용 (bech32와 다름!)

EIP-4337: 계정 추상화와 멀티시그

이더리움에서는 EIP-4337 (Account Abstraction)이 멀티시그의 사용성을 완전히 바꾸고 있어. 기존에는 멀티시그 월렛을 쓰려면 스마트 컨트랙트 배포 비용이 들고 UX가 복잡했는데, 계정 추상화로 이게 훨씬 쉬워졌어.

🔮 EIP-4337 + 멀티시그의 가능성

✅ 소셜 복구: 친구들이 서명자가 되어 키 분실 시 복구
✅ 세션 키: 특정 dApp에 제한된 권한 부여
✅ 가스 추상화: ETH 없이도 트랜잭션 실행 (Paymaster)
✅ 배치 트랜잭션: 여러 작업을 하나의 멀티시그로 처리
✅ 조건부 실행: 특정 조건 충족 시 자동 실행


📊 멀티시그 구현 체크리스트

실제로 멀티시그 월렛을 구현하거나 사용할 때 확인해야 할 것들을 정리했어. 재능넷에서 블록체인 보안 전문가를 찾는다면 이 항목들을 기준으로 평가해볼 수 있어!

✅ 설계 단계

☐ m-of-n 비율 결정 (보안 vs 편의성 트레이드오프)
☐ 서명자 역할 및 책임 정의
☐ 키 생성 환경 결정 (에어갭, 하드웨어 월렛 등)
☐ 키 백업 및 복구 절차 수립
☐ 타임락 및 비상 복구 메커니즘 설계
☐ 온체인 vs 오프체인 조율 방식 결정

✅ 구현 단계

☐ 검증된 암호화 라이브러리 사용
☐ CSPRNG으로 키 생성
☐ 스마트 컨트랙트 보안 감사 (외부 감사 권장)
☐ 재진입 공격 방지 (nonReentrant modifier)
☐ 정수 오버플로우 방지 (SafeMath 또는 Solidity 0.8+)
☐ 이벤트 로깅 (모든 중요 작업)
☐ 업그레이드 가능성 고려 (Proxy 패턴)

✅ 운영 단계

☐ 소액으로 테스트넷 검증
☐ 서명자 교육 (피싱, 소셜 엔지니어링 대응)
☐ 정기적인 키 상태 확인
☐ 트랜잭션 모니터링 시스템 구축
☐ 비상 연락망 및 대응 절차 수립
☐ 정기적인 보안 감사 (연 1회 이상)


🎯 마무리: 멀티시그, 이제 진짜 이해했지?

자 여기까지 왔으면 진짜 대단한 거야 ㅋㅋ 멀티시그가 단순히 "여러 명이 서명"하는 개념이 아니라, 타원 곡선 암호학, 비트코인 스크립트, 이더리움 스마트 컨트랙트, Schnorr 서명, MPC까지 엄청난 기술의 집합체라는 걸 알게 됐을 거야.

핵심을 다시 정리하면:

"멀티시그는 단일 실패 지점(Single Point of Failure)을 제거하는 가장 강력한 암호학적 보안 메커니즘이다. 개인키 하나가 노출되거나 분실되어도 자산이 안전하게 보호된다."
🔑 핵심 요약

비트코인: P2SH/P2WSH 스크립트 기반, PSBT로 오프라인 서명 조율, Taproot/Schnorr로 프라이버시 강화

이더리움: 스마트 컨트랙트 기반, Safe가 업계 표준, EIP-4337로 UX 혁신 중

암호학 기반: ECDSA/Schnorr 서명, secp256k1 타원 곡선, 해시 함수

보안 원칙: CSPRNG 사용, 키 분산 보관, 스마트 컨트랙트 감사, 서명자 교육

미래 방향: MPC, Taproot, 계정 추상화(EIP-4337)로 더 안전하고 편리하게 진화 중!

블록체인 보안이나 멀티시그 구현에 관심 있다면, 실제로 테스트넷에서 직접 구현해보는 게 최고야. 이론만으로는 절대 안 느껴지는 것들이 있거든. 비트코인 테스트넷 BTC는 무료로 받을 수 있고, 이더리움 테스트넷(Sepolia, Goerli)도 마찬가지야.

혼자 구현하기 어렵다면 재능넷에서 블록체인 개발 전문가를 찾아보는 것도 좋은 방법이야. 멀티시그 월렛 구현, 스마트 컨트랙트 감사, 보안 컨설팅 등 다양한 전문가들이 활동하고 있거든!

암호화폐 자산을 진지하게 관리한다면, 멀티시그는 선택이 아니라 필수야. 특히 큰 금액이라면 더더욱! 🔐✨

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.