Golang实现常用的Hash摘要

常用Hash算法

哈希（Hash）算法是一种将任意长度的数据映射为固定长度的数据的算法。常用的哈希算法有以下几种：

MD5：MD5 是一种常用的哈希算法，可以将任意长度的数据转换为 128 位的哈希值。但是，MD5 已经被证明不是完全安全的，因此在实际应用中，建议使用更加安全的哈希算法。
SHA-1：SHA-1 是一种常用的哈希算法，可以将任意长度的数据转换为 160 位的哈希值。但是，SHA-1 已经被证明不是完全安全的，因此在实际应用中，建议使用更加安全的哈希算法。
SHA-256：SHA-256 是一种常用的哈希算法，可以将任意长度的数据转换为 256 位的哈希值。SHA-256 相对于 SHA-1 更加安全，因此在实际应用中，建议使用 SHA-256。
SHA-512：SHA-512 是一种更加安全的哈希算法，可以将任意长度的数据转换为 512 位的哈希值。SHA-512 相对于 SHA-256 更加安全，但是计算速度更慢。

// Md5 -
func Md5(s string) string {
    h := md5.New()
    h.Write([]byte(s))
    return hex.EncodeToString(h.Sum(nil))
}

// Sha1 -
func Sha1(s string) string {
    h := sha1.New()
    h.Write([]byte(s))
    return hex.EncodeToString(h.Sum(nil))
}

// Sha256 -
func Sha256(s string) string {
    h := sha256.New()
    h.Write([]byte(s))
    return hex.EncodeToString(h.Sum(nil))
}

// Sha512 -
func Sha512(s string) string {
    h := sha512.New()
    h.Write([]byte(s))
    return hex.EncodeToString(h.Sum(nil))
}

在区块链中常用的Hash算法

在区块链中，常用的哈希算法有以下几种：

SHA-256：比特币和许多其他区块链使用 SHA-256 作为其哈希算法。。
Scrypt：Scrypt 是一种基于密码学的哈希算法，比特币中的挖矿算法也使用了 Scrypt。Scrypt 可以将任意长度的数据转换为固定长度的哈希值，但是计算速度较慢，需要更多的计算资源。
Ethash：以太坊使用 Ethash 作为其哈希算法。Ethash 是一种基于内存的哈希算法，可以抵抗 ASIC 矿机的攻击，使得以太坊挖矿更加公平。
Blake2：Monero 使用 Blake2 作为其哈希算法。Blake2 是一种高速、安全的哈希算法，可以将任意长度的数据转换为固定长度的哈希值。
ECC（Elliptic Curve Cryptography）是一种基于椭圆曲线的加密算法，常用于数字签名、密钥交换等场景。

1. Scrypt

// Scrypt - 
func Scrypt(s string) string {
    salt := []byte("salt")
    key, _ := scrypt.Key([]byte(s), salt, 16384, 8, 1, 32)
    return hex.EncodeToString(key)
}

2. Blake2

// Blake2 -
func Blake2(s string) string {
    h, _ := blake2b.New256(nil)
    h.Write([]byte(s))
    return hex.EncodeToString(h.Sum(nil))
}

3. ECC

func main() {
    // 生成密钥对
    curve := elliptic.P256()
    privateKey, _ := ecdsa.GenerateKey(curve, rand.Reader)
    publicKey := privateKey.PublicKey

    // 将公钥转换为字符串
    publicKeyBytes := elliptic.Marshal(curve, publicKey.X, publicKey.Y)
    publicKeyString := hex.EncodeToString(publicKeyBytes)

    // 将私钥转换为字符串
    privateKeyBytes := privateKey.D.Bytes()
    privateKeyString := hex.EncodeToString(privateKeyBytes)

    // 打印公钥和私钥
    fmt.Printf("公钥：%s\n", publicKeyString)
    fmt.Printf("私钥：%s\n", privateKeyString)

    // 使用私钥对数据进行签名
    data := []byte("Hello, world!")
    r, s, _ := ecdsa.Sign(rand.Reader, privateKey, data)

    // 将签名转换为字符串
    rBytes := r.Bytes()
    sBytes := s.Bytes()
    signatureBytes := make([]byte, 64)
    copy(signatureBytes[32-len(rBytes):32], rBytes)
    copy(signatureBytes[64-len(sBytes):64], sBytes)
    signatureString := hex.EncodeToString(signatureBytes)

    // 打印签名
    fmt.Printf("签名：%s\n", signatureString)
}

其他Hash算法

1. FNV（Fowler-Noll-Vo）哈希算法

FNV（Fowler-Noll-Vo）哈希算法是一种快速、简单的哈希算法，常用于哈希表、数据校验等场景。在 Golang 中，可以使用 hash/fnv 包来实现 FNV 哈希算法。

// Fnv - 
func Fnv(s string) uint64 {
    h := fnv.New64a()
    h.Write([]byte(s))
    return h.Sum64()
}

2. Adler-32

Adler-32 是一种快速的校验和算法，常用于数据传输和数据校验等场景。在 Golang 中，可以使用 hash/adler32 包来实现 Adler-32 算法。

// Adler -
func Adler(s string) uint32 {
    return adler32.Checksum([]byte(s))
}

3. CRC-32

CRC-32 是一种常用的校验和算法，常用于数据传输和数据校验等场景。在 Golang 中，可以使用 hash/crc32 包来实现 CRC-32 算法。

// Crc32 -
func Crc32(s string) uint32 {
    return crc32.ChecksumIEEE([]byte(s))
}

目录CONTENT