Go语言中HashCash算法的实现：高效处理位操作与类型转换

// 原始尝试中的部分代码片段，存在问题
func partialAllZeroesOriginal(zeroCount uint8, val int64) (bool, error) {
    // ... 尝试通过字符串转换和strconv.Btoi64将位模式转换为int64 ...
    // zeroTest, e := strconv.Btoi64(setBitString, 2)
    // zeroes, e   := strconv.Btoi64(unsetBitString, 2)
    // if e != nil { return false, e }
    // result := val & zeroTest
    // return result == zeroes, nil
    return false, nil // 简化，表示存在逻辑和类型转换问题
}

// 原始哈希生成代码片段
import (
    "crypto/sha1"
    "strings" // 注意：原始代码中的strings.Join用法有误
)

// func main() { // 假设在main函数中
//     hasher := sha1.New()
//     baseCollisionString := "BASE COLLISION STRING"
//     nonce := "12345"
//     // 原始代码中strings.Join的用法是错误的，它需要一个[]string参数
//     // 正确的拼接方式应该是 baseCollisionString + nonce
//     hasher.Write([]byte(strings.Join([]string{baseCollisionString, nonce}, ""))) // 修正后的错误用法
//     testCollision := hasher.Sum(nil) // Sum() 返回 []byte
//     // 如何将 testCollision 的前 x 位转换为 int64 以便使用 partialAllZeroesOriginal？
// }

package main

import (
    "crypto/sha1"
    "fmt"
    "time"
)

// partialAllZeroes 检查字节切片 b 的前 zeroCount 位是否全部为零。
func partialAllZeroes(zeroCount uint8, b []byte) bool {
    // 1. 处理完整的字节
    // 遍历所有可以被8整除的零位，即检查整个字节是否为0
    i := 0
    for zeroCount >= 8 {
        // 如果当前字节不为0，则说明不满足条件
        if b[i] != 0 {
            return false
        }
        i++ // 移动到下一个字节
        zeroCount -= 8 // 减少已检查的零位数量
    }

    // 2. 处理剩余的零位（不足一个字节的部分）
    // 如果 zeroCount 还有剩余，说明需要检查当前字节的前 zeroCount 位
    if zeroCount > 0 {
        var mask byte
        // 根据剩余的 zeroCount 生成一个掩码。
        // 例如，如果 zeroCount = 3，mask = 0x07 (二进制 00000111)
        // 目标是检查 b[i] 的高位是否为0，所以我们需要一个掩码来“选中”这些位。
        // 实际上，我们想检查的是 b[i] 的前 `zeroCount` 位是否为零。
        // 例如，如果 zeroCount = 3，我们检查最高3位。
        // 掩码应该用于清除我们不关心的低位，然后检查结果是否为零。
        // 正确的掩码应该是 `(1 << zeroCount) - 1`，然后左移以匹配高位。
        // 然而，更直接的方法是检查 `b[i] & (^((1 << (8 - zeroCount)) - 1))` 是否为零。
        // 示例代码中的 mask 逻辑是检查低位是否为零，这与 HashCash 通常要求的高位为零略有不同。
        // HashCash通常要求哈希值的前x位（最高有效位）为零。
        // 假设 `b[i]` 是一个字节，其位表示为 `b7 b6 b5 b4 b3 b2 b1 b0`。
        // 如果 `zeroCount = 3`，我们想检查 `b7 b6 b5` 是否为零。
        // 那么，我们应该将 `b[i]` 右移 `8 - zeroCount` 位，然后检查结果是否为零。
        // 或者，更常见的是，我们创建一个掩码，只保留 `zeroCount` 位，然后检查。
        // 例如，如果 zeroCount = 3，我们想检查 `b[i]` 的 `b7 b6 b5` 是否为 0。
        // 一个掩码 `0b11100000` (0xE0) 可以用来检查。
        // (b[i] & 0xE0) == 0

        // 重新审视原始答案中的 mask 逻辑：
        // case 1: mask = 0x01 (00000001)
        // case 2: mask = 0x03 (00000011)
        // ...
        // case 7: mask = 0x7f (01111111)
        // 这个掩码实际上是检查当前字节的“低位”是否为零。
        // 如果 HashCash 要求的是“前 zeroCount 位”为零，通常指的是最高有效位。
        // 假设 HashCash 要求的是最高有效位为零，那么掩码应该反过来。
        // 例如，如果 zeroCount = 1，我们想检查最高位 b7。掩码应该是 0x80 (10000000)。
        // 如果 zeroCount = 2，我们想检查 b7 b6。掩码应该是 0xC0 (11000000)。
        // 原始答案的掩码适用于检查最低有效位。为了符合HashCash通常的“前X位”定义（通常指高位），我们需要调整。
        // 假设 HashCash 要求的是哈希值字节流的“前 zeroCount 位”（从最高有效位开始）为零。

        // 修正后的掩码逻辑（检查高位）：
        switch zeroCount {
        case 1: mask = 0x80 // 10000000
        case 2: mask = 0xC0 // 11000000
        case 3: mask = 0xE0 // 11100000
        case 4: mask = 0xF0 // 11110000
        case 5: mask = 0xF8 // 11111000
        case 6: mask = 0xFC // 11111100
        case 7: mask = 0xFE // 11111110
        case 0: mask = 0x00 // 不需要检查
        }
        // 检查当前字节 b[i] 与掩码按位与的结果是否为0。
        // 如果为0，说明被掩码选中的高位都是0。
        return (b[i] & mask) == 0
    }

    // 如果 zeroCount 已经全部处理完毕，则返回 true
    return true
}

// 完整的 HashCash 查找示例
func main() {
    baseCollisionString := "BASE COLLISION STRING"
    targetZeroCount := uint8(20) // 目标零位数量，例如20位

    fmt.Printf("开始查找 HashCash 碰撞，目标前 %d 位为零...\n", targetZeroCount)
    startTime := time.Now()

    nonce := 0 // 从0开始尝试 nonce
    for {
        hasher := sha1.New()
        // 正确的字符串拼接方式
        dataToHash := fmt.Sprintf("%s%d", baseCollisionString, nonce)
        hasher.Write([]byte(dataToHash))
        testCollision := hasher.Sum(nil) // sha1.Sum() 返回 []byte

        if partialAllZeroes(targetZeroCount, testCollision) {
            elapsedTime := time.Since(startTime)
            fmt.Printf("找到碰撞！\n")
            fmt.Printf("数据: %s\n", dataToHash)
            fmt.Printf("哈希值: %x\n", testCollision)
            fmt.Printf("耗时: %s\n", elapsedTime)
            break
        }
        nonce++
        // 为了防止无限循环和提供反馈，可以每隔一段时间打印进度
        if nonce%100000 == 0 {
            fmt.Printf("已尝试 %d 次 nonce...\n", nonce)
        }
    }
}