Go语言批量生成以太坊地址,原理/实现与安全实践

>crypto/ecdsa 和 crypto/rand 包提供了椭圆曲线加密和随机数生成的支持，crypto/sha3 包实现了Keccak-256哈希算法，下面分步骤实现批量生成功能。

1 环境准备

确保已安装Go环境（建议1.16+），并创建项目目录：

mkdir eth-address-generator
cd eth-address-generator
go mod init eth-address-generator

2 核心代码实现

创建 main.go 文件，完整代码如下：

package main
import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "log"
    "math/big"
)
// 生成单个以太坊地址
func GenerateEthAddress() (privateKey string, publicKey string, address string, err error) {
    // 1. 生成私钥（32字节随机数）
    privateKeyECDSA, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        return "", "", "", fmt.Errorf("生成私钥失败: %v", err)
    }
    // 2. 格式化私钥（64字节十六进制字符串）
    privateKeyBytes := privateKeyECDSA.D.Bytes()
    privateKey = fmt.Sprintf("%064x", privateKeyBytes)
    // 3. 生成公钥（压缩格式：0x02或0x03 + x坐标）
    publicKeyECDSA := &privateKeyECDSA.PublicKey
    publicKeyBytes := elliptic.MarshalCompressed(publicKeyECDSA, publicKeyECDSA.X, publicKeyECDSA.Y)
    publicKey = fmt.Sprintf("%x", publicKeyBytes)
    // 4. 从公钥生成地址（Keccak-256哈希后取后20字节）
    // 去掉公钥的前缀（0x04或0x02/0x03），仅保留x和y坐标（64字节）
    pubKeyBytes := publicKeyBytes[1:]
    // Keccak-256哈希
    hash := sha3.NewLegacyKeccak256()
    hash.Write(pubKeyBytes)
    hashBytes := hash.Sum(nil)
    // 取后20字节作为地址
    addressBytes := hashBytes[len(hashBytes)-20:]
    address = fmt.Sprintf("0x%x", addressBytes)
    return privateKey, publicKey, address, nil
}
// 批量生成以太坊地址
func BatchGenerateEthAddresses(count int) ([]map[string]string, error) {
    if count <= 0 {
        return nil, fmt.Errorf("生成数量必须大于0")
    }
    addresses := make([]map[string]string, 0, count)
    for i := 0; i < count; i++ {
        privateKey, publicKey, address, err := GenerateEthAddress()
        if err != nil {
            return nil, fmt.Errorf("生成第%d个地址失败: %v", i+1, err)
        }
        addrInfo := map[string]string{
            "private_key": privateKey,
            "public_key":  publicKey,
            "address":     address,
        }
        addresses = append(addresses, addrInfo)
    }
    return addresses, nil
}
func main() {
    // 设置批量生成数量
    count := 10
    addresses, err := BatchGenerateEthAddresses(count)
    if err != nil {
        log.Fatalf("批量生成地址失败: %v", err)
    }
    // 打印结果
    fmt.Printf("成功生成 %d 个以太坊地址:\n", count)
    for i, addr := range addresses {
        fmt.Printf("\n=== 地址 %d ===\n", i+1)
        fmt.Printf("私钥: %s\n", addr["private_key"])
        fmt.Printf("公钥: %s\n", addr["public_key"])
        fmt.Printf("地址: %s\n", addr["address"])
    }
}

3 代码解析

3.1 私钥生成

ecdsa.GenerateKey(elliptic.P256(), rand.Reader) 是核心函数，

• elliptic.P256()：指定椭圆曲线算法（以太坊使用secp256k1，但Go标准库的 P256 是NIST P-256曲线，需注意！实际开发中需替换为secp256k1，见下文修正）；
• rand.Reader：密码学安全的随机数源，避免使用不安全的随机数生成器（如 math/rand）。

3.2 公钥生成

elliptic.MarshalCompressed 将公钥压缩为33字节（前1字节表示压缩类型，后32字节为x坐标），节省存储空间。

3.3 地址生成

• 对公钥（去压缩前缀后的64字节）计算Keccak-256哈希；
• 取哈希值后20字节，并添加 0x 前缀，符合以太坊地址格式。

4 关键修正：使用secp256k1曲线

Go标准库的 crypto/elliptic 默认未包含secp256k1曲线，需使用第三方库，推荐使用 ethereum/go-ethereum 中的 crypto/secp256k1 包：

1. 安装依赖：

   go get github.com/ethereum/go-ethereum/crypto/secp256k1

2. 修正私钥生成代码：

   import "github.com/ethereum/go-ethereum/crypto/secp256k1"
   // 生成私钥（使用secp256k1曲线）
   privateKeyECDSA, err := secp256k1.GenerateKey()

   其他逻辑保持不变，确保生成的地址符合以太坊标准。

批量生成的优化与安全实践

1 并发优化

批量生成地址时，可通过并发（goroutine）提升效率，修改 BatchGenerateEthAddresses 函数：

import "sync"
func BatchGenerateEthAddressesConcurrent(count int) ([]map[string]string, error) {
    if count <= 0 {
        return nil, fmt.Errorf("生成数量必须大于0")
    }
    var wg sync.WaitGroup
    addresses := make([]map[string]string, 0, count)
    addrChan := make(chan map[string]string, count)
    // 启动多个goroutine并行生成
    for i := 0; i < 10; i++ { // 设置10个并发worker
        wg.Add(1)
        go func() {
            defer wg.Done()
            for {
                select {
                case addr, ok := <-addrChan:
                    if !ok {
                        return
                    }
                    addresses = append(addresses, addr)
                default:
                    // 从通道获取任务，若通道为空则退出
                    if len(addrChan) == 0 {
                        return
                    }
                }
            }
        }()
    }
    // 向通道发送生成任务
    for i := 0; i < count; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            privateKey, publicKey, address, err := GenerateEthAddress()
            if err != nil {
                log.Printf("生成地址失败: %v", err)
                return
            }
            addrChan <- map[string]string{
                "private_key": privateKey,
                "public_key":  publicKey,
                "address":     address,
            }
        }()
    }
    wg.Wait()
    close(addrChan)