Go语言HashCash算法实现：哈希输出与位检查优化

package main

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

// partialAllZeroes 检查字节数组b的前zeroCount位是否全为0。
// 直接操作字节数组，避免了不必要的类型转换。
func partialAllZeroes(zeroCount uint8, b []byte) bool {
    // 遍历完整的字节，检查是否全为0
    i := 0
    for zeroCount >= 8 { // 当剩余的zeroCount大于等于8位时，检查一个完整的字节
        if b[i] != 0 {
            return false // 如果当前字节不为0，则不满足条件
        }
        i++         // 移动到下一个字节
        zeroCount -= 8 // 减少已检查的位数
    }

    // 处理剩余不足8位的零位检查
    // 根据剩余的zeroCount生成一个对应的掩码
    var mask byte
    switch zeroCount {
    case 0:
        mask = 0x00 // 不需要检查任何位
    case 1:
        mask = 0x01 // 检查最低1位
    case 2:
        mask = 0x03 // 检查最低2位
    case 3:
        mask = 0x07 // 检查最低3位
    case 4:
        mask = 0x0F // 检查最低4位
    case 5:
        mask = 0x1F // 检查最低5位
    case 6:
        mask = 0x3F // 检查最低6位
    case 7:
        mask = 0x7F // 检查最低7位
    }

    // 注意：HashCash通常要求前导零，这意味着需要检查的是字节的最高位。
    // 这里的mask是针对最低位。为了检查前导零，我们需要将字节右移或使用反向掩码。
    // 假设我们检查的是b[i]的最高zeroCount位。
    // 例如，如果zeroCount是1，需要检查b[i]的最高位（10000000）。
    // 正确的掩码应该是从最高位开始的。
    // 让我们重新思考掩码逻辑以匹配“前导零”的概念。

    // 修正后的掩码逻辑：
    // 如果需要检查b[i]的最高zeroCount位，那么我们需要的掩码应该是：
    // 例如，zeroCount = 1, mask = 10000000 (0x80)
    // 例如, zeroCount = 2, mask = 11000000 (0xC0)
    // 例如, zeroCount = 7, mask = 11111110 (0xFE)
    // 例如, zeroCount = 8, mask = 11111111 (0xFF) - 但这种情况已经被上面的循环处理了

    // 更通用的生成前导零掩码的方法：
    // 从全1字节开始，然后右移 (8 - zeroCount) 位
    // 例如，zeroCount = 3， (11111111) >> (8-3) = (11111111) >> 5 = 00000111
    // 得到的是低位掩码。我们需要的是高位掩码。
    // 可以通过 (0xFF << (8 - zeroCount)) & 0xFF 得到高位掩码
    // 例如，zeroCount = 3, (0xFF << 5) & 0xFF = (11100000) & 0xFF = 0xE0
    // 这样，`b[i] & mask` 就能检查出高位是否全为零。

    if zeroCount == 0 {
        return true // 如果zeroCount为0，表示不需要检查，直接返回true
    }

    // 生成高位掩码
    // 例如 zeroCount = 1, mask = 0x80 (10000000)
    // 例如 zeroCount = 2, mask = 0xC0 (11000000)
    // 例如 zeroCount = 7, mask = 0xFE (11111110)
    mask = 0xFF << (8 - zeroCount)

    // 检查当前字节的最高zeroCount位是否为0
    // 如果 (b[i] & mask) == 0，说明这些高位都是0
    return (b[i] & mask) == 0
}

package main

import (
    "crypto/sha1"
    "fmt"
    "strconv" // 用于将nonce转换为字符串
    "time"    // 用于时间戳
)

// partialAllZeroes 检查字节数组b的前zeroCount位是否全为0。
// 直接操作字节数组，避免了不必要的类型转换。
func partialAllZeroes(zeroCount uint8, b []byte) bool {
    // 遍历完整的字节，检查是否全为0
    i := 0
    for zeroCount >= 8 { // 当剩余的zeroCount大于等于8位时，检查一个完整的字节
        if i >= len(b) { // 防止越界，如果zeroCount要求检查的位数超出了哈希长度
            return false // 或者根据需求返回true/false，这里假设超出会失败
        }
        if b[i] != 0 {
            return false // 如果当前字节不为0，则不满足条件
        }
        i++         // 移动到下一个字节
        zeroCount -= 8 // 减少已检查的位数
    }

    // 处理剩余不足8位的零位检查
    if zeroCount == 0 {
        return true // 如果zeroCount为0，表示不需要检查，直接返回true
    }

    if i >= len(b) { // 再次防止越界，如果零位检查要求超出了哈希长度
        return false // 例如，SHA-1只有160位，如果zeroCount是200，则会越界
    }

    // 生成高位掩码
    // 例如 zeroCount = 1, mask = 0x80 (10000000)
    // 例如 zeroCount = 2, mask = 0xC0 (11000000)
    // 例如 zeroCount = 7, mask = 0xFE (11111110)
    mask := byte(0xFF << (8 - zeroCount))

    // 检查当前字节的最高zeroCount位是否为0
    // 如果 (b[i] & mask) == 0，说明这些高位都是0
    return (b[i] & mask) == 0
}

func main() {
    // HashCash头部信息示例
    // 通常包含版本、难度、时间戳、资源（如邮件地址）、随机数等
    // 这里简化为 baseCollisionString + nonce
    baseCollisionString := "1:20:1303030600:test@example.com::" // 示例HashCash头部，不含nonce

    // 设定需要找到的前导零位数
    // 20位是一个常见的难度值，对应大约1秒钟的计算时间
    // 对于SHA-1 (160位)，20位前导零意味着平均需要2^20次尝试
    targetZeroBits := uint8(20)

    fmt.Printf("开始寻找前 %d 位为零的哈希值...\n", targetZeroBits)
    startTime := time.Now()

    var nonce int64 = 0
    for {
        // 构造待哈希的字符串：baseCollisionString + nonce
        // 在实际HashCash中，nonce通常是base64编码的随机字符串
        // 这里简化为数字递增
        currentString := baseCollisionString + strconv.FormatInt(nonce, 10)

        // 计算SHA-1哈希
        hasher := sha1.New()
        hasher.Write([]byte(currentString))
        hashResult := hasher.Sum(nil) // Sum(nil) 返回一个新的字节切片

        // 检查哈希值是否满足前导零条件
        if partialAllZeroes(targetZeroBits, hashResult) {
            elapsedTime := time.Since(startTime)
            fmt.Printf("找到满足条件哈希值！\n")
            fmt.Printf("尝试次数: %d\n", nonce+1)
            fmt.Printf("耗时: %s\n", elapsedTime)
            fmt.Printf("原始字符串: %s\n", currentString)
            fmt.Printf("哈希值 (Hex): %x\n", hashResult)
            fmt.Printf("哈希值 (Binary): %08b...\n", hashResult[0]) // 打印第一个字节的二进制
            break
        }

        nonce++
        if nonce%1000000 == 0 { // 每100万次尝试打印一次进度
            fmt.Printf("已尝试 %d 次，耗时 %s...\n", nonce, time.Since(startTime))
        }
    }
}