1
2
3
4
5
6

{
  "Action": [
    "kms:Sign",
    "kms:GetPublicKey"
  ]
}

1
2
3
4

SubjectPublicKeyInfo ::= SEQUENCE {
    algorithm         AlgorithmIdentifier    -- "EC 알고리즘, secp256k1 커브"
    subjectPublicKey  BIT STRING             -- 실제 공개키 바이트
}

1
2
3
4
5
6
7
8
9

type asn1EcPublicKey struct {
    EcPublicKeyInfo asn1EcPublicKeyInfo
    PublicKey       asn1.BitString          // ← 이것이 실제 공개키
}

type asn1EcPublicKeyInfo struct {
    Algorithm  asn1.ObjectIdentifier       // OID 1.2.840.10045.2.1 (EC)
    Parameters asn1.ObjectIdentifier       // OID 1.3.132.0.10 (secp256k1)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func getPublicKeyDerBytesFromKMS(ctx context.Context, svc *kms.Client, keyId string) ([]byte, error) {
    getPubKeyOutput, err := svc.GetPublicKey(ctx, &kms.GetPublicKeyInput{
        KeyId: aws.String(keyId),
    })
    if err != nil {
        return nil, errors.Wrapf(err, "can not get public key from KMS for KeyId=%s", keyId)
    }

    // ASN.1 DER 파싱: SubjectPublicKeyInfo에서 공개키 바이트만 추출
    var asn1pubk asn1EcPublicKey
    _, err = asn1.Unmarshal(getPubKeyOutput.PublicKey, &asn1pubk)
    if err != nil {
        return nil, errors.Wrapf(err, "can not parse asn1 public key for KeyId=%s", keyId)
    }

    return asn1pubk.PublicKey.Bytes, nil
}

1

[0x04] [---- X 좌표 32 bytes ----] [---- Y 좌표 32 bytes ----]

1
2

순방향: k → (X, Y)     계산 가능 (point multiplication)
역방향: (X, Y) → k     계산 불가능 (이산 로그 문제, ECDLP)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 1. 0x04 prefix 제거
rawPubKey := pubKeyBytes[1:]  // 64 bytes (X || Y)

// 2. keccak256 해시 (Ethereum은 NIST SHA-3가 아닌 원본 Keccak-256 사용)
hash := sha3.NewLegacyKeccak256()
hash.Write(rawPubKey)
fullHash := hash.Sum(nil)     // 32 bytes

// 3. 마지막 20 bytes = Ethereum 주소
address := fullHash[12:]      // 20 bytes

1
2
3
4
5
6
7
8

txHashBytes := signer.Hash(tx).Bytes()  // keccak256(RLP(tx))

signInput := &kms.SignInput{
    KeyId:            aws.String(keyId),
    Message:          txHashBytes,
    SigningAlgorithm: "ECDSA_SHA_256",
    MessageType:      "DIGEST",          // ← 반드시 지정!
}

1
2
3
4

ECDSA-Sig-Value ::= SEQUENCE {
    r  INTEGER,    -- 점 R의 x좌표
    s  INTEGER     -- k_sig⁻¹ × (txHash + r × privateKey) mod n
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func getSignatureFromKms(
    ctx context.Context, svc *kms.Client, keyId string, txHashBytes []byte,
) ([]byte, []byte, error) {
    signInput := &kms.SignInput{
        KeyId:            aws.String(keyId),
        SigningAlgorithm: awsKmsSignOperationSigningAlgorithm,
        MessageType:      awsKmsSignOperationMessageType,
        Message:          txHashBytes,
    }

    signOutput, err := svc.Sign(ctx, signInput)
    if err != nil {
        return nil, nil, err
    }

    // DER-encoded 서명을 ASN.1 파싱하여 r, s 정수값 추출
    var sigAsn1 asn1EcSig
    _, err = asn1.Unmarshal(signOutput.Signature, &sigAsn1)
    if err != nil {
        return nil, nil, err
    }

    return sigAsn1.R.Bytes, sigAsn1.S.Bytes, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// secp256k1 커브의 order (n)
var secp256k1N = crypto.S256().Params().N

// EIP-2 기준값: n / 2
var secp256k1HalfN = new(big.Int).Div(secp256k1N, big.NewInt(2))

// s > n/2 이면 "dark side"에 있는 s를 "bright side"로 뒤집기
sBigInt := new(big.Int).SetBytes(sBytes)
if sBigInt.Cmp(secp256k1HalfN) > 0 {
    sBytes = new(big.Int).Sub(secp256k1N, sBigInt).Bytes()
}

1
2
3
4
5
6
7
8

// github.com/ethereum/go-ethereum/crypto/crypto.go
func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool {
    // ...
    if homestead && s.Cmp(secp256k1halfN) > 0 {
        return false  // ← s > N/2 이면 거부!
    }
    // ...
}

1
2

v=0 → R = (x, y₁) 사용 → 공개키 A 복구
v=1 → R = (x, y₂) 사용 → 공개키 B 복구

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

func getEthereumSignature(expectedPublicKeyBytes []byte, txHash []byte, r []byte, s []byte) ([]byte, error) {
    rsSignature := append(adjustSignatureLength(r), adjustSignatureLength(s)...)

    // v=0 시도: R = (x, y₁) 가정
    signature := append(rsSignature, []byte{0}...)
    recoveredPublicKeyBytes, err := crypto.Ecrecover(txHash, signature)
    if err != nil {
        return nil, err
    }

    // 복구된 공개키와 원본 공개키 비교
    if hex.EncodeToString(recoveredPublicKeyBytes) != hex.EncodeToString(expectedPublicKeyBytes) {
        // v=1 시도: R = (x, y₂) 가정
        signature = append(rsSignature, []byte{1}...)
        recoveredPublicKeyBytes, err = crypto.Ecrecover(txHash, signature)
        if err != nil {
            return nil, err
        }

        if hex.EncodeToString(recoveredPublicKeyBytes) != hex.EncodeToString(expectedPublicKeyBytes) {
            return nil, errors.New("can not reconstruct public key from sig")
        }
    }

    return signature, nil  // 65 bytes: [r:32][s:32][v:1]
}

1
2
3
4
5
6
7
8
9

type Transaction struct {
    inner TxData    // ← 합의(consensus) 데이터 (RLP로 인코딩되는 부분)
    time  time.Time

    // caches (메모리에만 존재, 저장/전파 안 됨)
    hash atomic.Pointer[common.Hash]
    size atomic.Uint64
    from atomic.Pointer[sigCache]   // ← 캐시! 블록에 저장되지 않음
}

1
2
3
4
5

사용자 → eth_getTransactionByHash 요청
  → 노드가 DB에서 tx 조회 (from 없음)
  → 노드가 tx의 (v, r, s)에서 Sender() 호출 → from 계산
  → JSON 응답에 from 필드 추가
  → 사용자에게 반환

1
2
3
4
5
6
7

트랜잭션 수신
  → types.Sender(signer, tx) 호출
    → recoverPlain(sighash, R, S, V)
      → crypto.Ecrecover(hash, sig)          // sig = r || s || v, 65 bytes
        → secp256k1.RecoverPubkey(hash, sig)  // v로 두 후보 중 하나 선택
          → 공개키 (65 bytes, 0x04 || X || Y)
            → keccak256(공개키[1:])[12:] = from 주소

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

func NewAwsKmsTransactorWithChainIDCtx(
    ctx context.Context, svc *kms.Client, keyId string, chainID *big.Int,
) (*bind.TransactOpts, error) {
    // [Step 1] KMS에서 공개키 가져오기 (kms:GetPublicKey 권한 필요)
    pubkey, err := GetPubKeyCtx(ctx, svc, keyId)
    if err != nil {
        return nil, err
    }

    // [Step 2] 공개키 → uncompressed 포맷 (65 bytes)
    pubKeyBytes := secp256k1.S256().Marshal(pubkey.X, pubkey.Y)

    // [Step 3] 공개키 → Ethereum 주소 도출
    keyAddr := crypto.PubkeyToAddress(*pubkey)
    if chainID == nil {
        return nil, bind.ErrNoChainID
    }

    signer := types.LatestSignerForChainID(chainID)

    // [Step 4] 트랜잭션 서명 함수 (signerFn)
    signerFn := func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
        if address != keyAddr {
            return nil, bind.ErrNotAuthorized
        }

        // (a) 트랜잭션 해시
        txHashBytes := signer.Hash(tx).Bytes()

        // (b) KMS 서명 → (r, s) 추출
        rBytes, sBytes, err := getSignatureFromKms(ctx, svc, keyId, txHashBytes)
        if err != nil {
            return nil, err
        }

        // (c) EIP-2: s > n/2 이면 뒤집기
        sBigInt := new(big.Int).SetBytes(sBytes)
        if sBigInt.Cmp(secp256k1HalfN) > 0 {
            sBytes = new(big.Int).Sub(secp256k1N, sBigInt).Bytes()
        }

        // (d) v 값 결정 + 최종 서명 조립
        signature, err := getEthereumSignature(pubKeyBytes, txHashBytes, rBytes, sBytes)
        if err != nil {
            return nil, err
        }

        // (e) 서명을 트랜잭션에 부착
        return tx.WithSignature(signer, signature)
    }

    return &bind.TransactOpts{
        From:   keyAddr,
        Signer: signerFn,
    }, nil
}

1
2
3
4

type pubKeyCache struct {
    pubKeys map[string]*ecdsa.PublicKey
    mutex   sync.RWMutex
}

1
2
3
4
5
6

KMS 사용 흐름:
  GetPubKey → 공개키 → Ethereum 주소 (from)
  Sign(txHash) → (r, s)  ← v가 없음!
  v 결정: ecrecover(txHash, r, s, v=0) == 공개키? → v=0, 아니면 v=1
  (v, r, s) 완성 → 트랜잭션 전송
  노드: ecrecover(txHash, v, r, s) → from 복구 → 잔액 확인 → 실행