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

암호학: 다중 서명(Multisignature) 월렛 완전 정복 — 설계부터 구현까지
혼자 지키기엔 너무 소중한 자산, 여러 키로 함께 잠그는 멀티시그의 모든 것 🗝️✨
🤔 멀티시그가 뭔데? 진짜 쉽게 설명해줄게
야 솔직히 말해서, 비트코인이나 이더리움 같은 암호화폐 들어봤지? 근데 그걸 보관하는 월렛(지갑)이 해킹당하거나 개인키 하나 잃어버리면 그냥 끝이잖아 ㅠㅠ
그래서 나온 게 바로 다중 서명(Multisignature, 줄여서 멀티시그) 월렛이야!
개념 자체는 엄청 직관적이야. 예를 들어 회사 금고 열려면 사장님 혼자 열 수 있으면 위험하잖아? 그래서 사장님 + 재무팀장 + 감사 이렇게 3명 중 2명이 동시에 열쇠를 꽂아야 열리게 만드는 거야. 이게 바로 2-of-3 멀티시그의 개념임 ㅋㅋ
암호학적으로 표현하면: m-of-n 서명 구조라고 해. n개의 키 중에서 최소 m개의 서명이 있어야 트랜잭션이 유효하다는 뜻이지.
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).
비트코인과 이더리움은 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)라고 해.
서명 검증 과정:
1. 서명값 (r, s)와 공개키 Q를 가지고
2. 원본 메시지 해시 e를 계산
3. 수학적 연산으로 서명이 해당 공개키의 개인키로 만들어진 게 맞는지 확인
멀티시그에서는 이 과정을 여러 키에 대해 반복하고, 충분한 수의 유효한 서명이 모였을 때만 트랜잭션을 실행하는 거야!
⛓️ 비트코인에서의 멀티시그 구현
P2SH (Pay-to-Script-Hash) 방식
비트코인에서 멀티시그를 구현하는 가장 대표적인 방법이 P2SH야. 2012년 BIP-16으로 표준화됐어.
핵심 아이디어: 복잡한 잠금 조건(스크립트)을 직접 노출하지 않고, 그 스크립트의 해시값만 주소에 담는 거야. 그래서 주소가 짧고 깔끔해지고, 실제 조건은 자금을 쓸 때만 공개돼.
2-of-3 멀티시그의 리딤 스크립트:
OP_2 <공개키1> <공개키2> <공개키3> OP_3 OP_CHECKMULTISIG
OP_2: 최소 2개의 서명 필요
공개키들: 서명자들의 공개키 (33바이트 압축 형식)
OP_3: 총 3개의 공개키
OP_CHECKMULTISIG: 멀티시그 검증 실행
P2SH 주소 생성 과정
# 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), 가스 최적화 등이 추가돼. 재능넷 같은 플랫폼에서 블록체인 개발자를 찾는다면 이런 스마트 컨트랙트 구현 능력이 핵심 스킬 중 하나야!
🔬 고급 멀티시그 기술: Schnorr 서명과 MPC
Schnorr 서명 — 멀티시그의 게임 체인저
비트코인 Taproot 업그레이드(2021년 11월)와 함께 Schnorr 서명이 도입됐어. 이게 왜 혁명적이냐면... 기존 ECDSA 멀티시그는 서명자 수만큼 서명 데이터가 커지는데, Schnorr은 서명을 하나로 합칠 수 있거든!
이걸 MuSig(Multi-Signature Scheme)이라고 해.
| 항목 | ECDSA 멀티시그 | Schnorr/MuSig |
|---|---|---|
| 서명 크기 | 서명자 수 × ~72바이트 | 단일 서명 ~64바이트 |
| 프라이버시 | 멀티시그임이 온체인에 노출 | 일반 단일 서명과 구분 불가 |
| 수수료 | 높음 | 낮음 (최대 50% 절감) |
| 선형성 | 없음 | 있음 (키 집계 가능) |
Schnorr 서명의 수학적 원리
Schnorr 서명이 왜 집계(Aggregation)가 가능한지 수학적으로 살펴보자. 겁먹지 마, 생각보다 직관적이야 ㅋㅋ
단일 서명자의 경우:
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명이 협력해서 연산하면 서명이 생성됨
- 하지만 실제 개인키는 어디에도 존재하지 않음!
이 방식의 장점은 온체인에서 보면 그냥 일반 단일 서명처럼 보인다는 거야. 프라이버시 극강!
전통 멀티시그 선택 시:
✅ 온체인 투명성이 필요한 경우 (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)를 많이 써. 여러 서명자가 오프라인에서 순차적으로 서명을 추가할 수 있는 표준 포맷이야.
# 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;
}
}
}
🚀 고급 주제: Taproot와 멀티시그의 미래
Taproot (BIP-340, 341, 342)
비트코인의 Taproot 업그레이드는 멀티시그에 혁명을 가져왔어. 핵심은 MAST(Merkelized Alternative Script Trees)와 Schnorr 서명의 결합이야.
시나리오: 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가 복잡했는데, 계정 추상화로 이게 훨씬 쉬워졌어.
✅ 소셜 복구: 친구들이 서명자가 되어 키 분실 시 복구
✅ 세션 키: 특정 dApp에 제한된 권한 부여
✅ 가스 추상화: ETH 없이도 트랜잭션 실행 (Paymaster)
✅ 배치 트랜잭션: 여러 작업을 하나의 멀티시그로 처리
✅ 조건부 실행: 특정 조건 충족 시 자동 실행
📊 멀티시그 구현 체크리스트
실제로 멀티시그 월렛을 구현하거나 사용할 때 확인해야 할 것들을 정리했어. 재능넷에서 블록체인 보안 전문가를 찾는다면 이 항목들을 기준으로 평가해볼 수 있어!
☐ m-of-n 비율 결정 (보안 vs 편의성 트레이드오프)
☐ 서명자 역할 및 책임 정의
☐ 키 생성 환경 결정 (에어갭, 하드웨어 월렛 등)
☐ 키 백업 및 복구 절차 수립
☐ 타임락 및 비상 복구 메커니즘 설계
☐ 온체인 vs 오프체인 조율 방식 결정
☐ 검증된 암호화 라이브러리 사용
☐ CSPRNG으로 키 생성
☐ 스마트 컨트랙트 보안 감사 (외부 감사 권장)
☐ 재진입 공격 방지 (nonReentrant modifier)
☐ 정수 오버플로우 방지 (SafeMath 또는 Solidity 0.8+)
☐ 이벤트 로깅 (모든 중요 작업)
☐ 업그레이드 가능성 고려 (Proxy 패턴)
☐ 소액으로 테스트넷 검증
☐ 서명자 교육 (피싱, 소셜 엔지니어링 대응)
☐ 정기적인 키 상태 확인
☐ 트랜잭션 모니터링 시스템 구축
☐ 비상 연락망 및 대응 절차 수립
☐ 정기적인 보안 감사 (연 1회 이상)
🎯 마무리: 멀티시그, 이제 진짜 이해했지?
자 여기까지 왔으면 진짜 대단한 거야 ㅋㅋ 멀티시그가 단순히 "여러 명이 서명"하는 개념이 아니라, 타원 곡선 암호학, 비트코인 스크립트, 이더리움 스마트 컨트랙트, Schnorr 서명, MPC까지 엄청난 기술의 집합체라는 걸 알게 됐을 거야.
핵심을 다시 정리하면:
비트코인: P2SH/P2WSH 스크립트 기반, PSBT로 오프라인 서명 조율, Taproot/Schnorr로 프라이버시 강화
이더리움: 스마트 컨트랙트 기반, Safe가 업계 표준, EIP-4337로 UX 혁신 중
암호학 기반: ECDSA/Schnorr 서명, secp256k1 타원 곡선, 해시 함수
보안 원칙: CSPRNG 사용, 키 분산 보관, 스마트 컨트랙트 감사, 서명자 교육
미래 방향: MPC, Taproot, 계정 추상화(EIP-4337)로 더 안전하고 편리하게 진화 중!
블록체인 보안이나 멀티시그 구현에 관심 있다면, 실제로 테스트넷에서 직접 구현해보는 게 최고야. 이론만으로는 절대 안 느껴지는 것들이 있거든. 비트코인 테스트넷 BTC는 무료로 받을 수 있고, 이더리움 테스트넷(Sepolia, Goerli)도 마찬가지야.
혼자 구현하기 어렵다면 재능넷에서 블록체인 개발 전문가를 찾아보는 것도 좋은 방법이야. 멀티시그 월렛 구현, 스마트 컨트랙트 감사, 보안 컨설팅 등 다양한 전문가들이 활동하고 있거든!
암호화폐 자산을 진지하게 관리한다면, 멀티시그는 선택이 아니라 필수야. 특히 큰 금액이라면 더더욱! 🔐✨
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.