Skip to main content

crypto HMAC

crypto/hmac 是 Go 语言标准库中的一个包，用于实现基于哈希函数的消息认证码（HMAC）。HMAC 是一种通过结合一个密钥和一个哈希函数来同时验证数据的完整性和真实性的方法。

HMAC 的工作原理​

HMAC 通过将密钥与消息混合，然后应用哈希函数来生成一个消息认证码。这个过程包括以下步骤：

  1. 将密钥和消息进行特定的填充和拼接。
  2. 对拼接后的结果进行哈希运算。
  3. 将上述结果再次与密钥混合，并进行第二次哈希运算。

使用 crypto/hmac 包​

下面是一个示例，展示了如何使用 crypto/hmac 包来生成和验证 HMAC：

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"crypto/sha1"
	"crypto/sha512"
	"encoding/hex"
	"fmt"
)

// 生成 HMAC
func generateHMAC(message, key []byte, hashType string) string {
	var h hash.Hash
	switch hashType {
	case "sha1":
		h = hmac.New(sha1.New, key)
	case "sha256":
		h = hmac.New(sha256.New, key)
	case "sha512":
		h = hmac.New(sha512.New, key)
	default:
		panic("Unsupported hash type")
	}
	h.Write(message)
	return hex.EncodeToString(h.Sum(nil))
}

// 验证 HMAC
func verifyHMAC(message, key []byte, hashType, receivedHMAC string) bool {
	calculatedHMAC := generateHMAC(message, key, hashType)
	return hmac.Equal([]byte(receivedHMAC), []byte(calculatedHMAC))
}

func main() {
	message := []byte("Hello, World!")
	key := []byte("my secret key")

	hashTypes := []string{"sha1", "sha256", "sha512"}

	for _, hashType := range hashTypes {
		hmac := generateHMAC(message, key, hashType)
		fmt.Printf("HMAC (%s): %s\n", hashType, hmac)

		isValid := verifyHMAC(message, key, hashType, hmac)
		fmt.Printf("Is valid: %v\n", isValid)
	}
}

代码说明​

  1. 生成 HMAC：

    • generateHMAC 函数根据指定的哈希类型（例如 sha1, sha256, sha512）生成 HMAC。
    • 使用 hmac.New 创建一个 HMAC 对象，并写入消息数据。
    • 使用 hex.EncodeToString 将生成的 HMAC 转换为十六进制字符串。

  2. 验证 HMAC：

    • verifyHMAC 函数根据指定的哈希类型生成消息的 HMAC，并将其与接收到的 HMAC 进行比较。
    • 使用 hmac.Equal 函数安全地比较两个 HMAC 值。

  3. 主函数：

    • main 函数演示了如何使用 generateHMAC 和 verifyHMAC 函数生成和验证 HMAC。

运行代码​

将上述代码保存为一个 .go 文件（例如 hmac_example.go），然后在终端运行以下命令：

go run hmac_example.go

你将看到不同哈希类型（sha1, sha256, sha512）生成的 HMAC 以及验证结果。

SHA-1, SHA-256 和 SHA-512 的区别​

  • SHA-1：

    • 输出长度：160 位（20 字节）
    • 安全性：已被认为不安全，存在碰撞攻击。

  • SHA-256：

    • 输出长度：256 位（32 字节）
    • 安全性：目前被认为安全，广泛应用于各种安全协议和应用。

  • SHA-512：

    • 输出长度：512 位（64 字节）
    • 安全性：比 SHA-256 更安全，但输出长度更长，适用于需要更高安全性的场景。

在实际应用中，建议使用 SHA-256 或 SHA-512 来代替 SHA-1，以确保更高的安全性。

使用场景​

HMAC（基于哈希的消息认证码）在许多场景中被广泛使用，主要用于确保数据的完整性和真实性。以下是一些常见的使用场景：

常见使用场景​

  1. API 请求签名：

    • HMAC 常用于对 API 请求进行签名，以确保请求未被篡改，并验证请求的来源。例如，AWS 和其他云服务提供商通常要求在请求头中包含 HMAC 签名。

  2. 数据完整性验证：

    • 在数据传输过程中，HMAC 可以用于验证数据的完整性，防止数据在传输过程中被篡改。例如，在文件传输或数据备份过程中，可以使用 HMAC 来验证文件的完整性。

  3. 身份验证：

    • HMAC 可以用于用户身份验证系统中，确保用户提供的凭据未被篡改。例如，JWT（JSON Web Token）可以使用 HMAC 进行签名，以确保令牌的真实性和完整性。

  4. 消息认证：

    • 在通信协议中，HMAC 可以用于消息认证，确保消息未被篡改并且来自可信的发送方。例如，在 TLS 协议中，HMAC 用于验证数据包的完整性。

承诺揭示（Commitment Scheme）​

承诺揭示（Commitment Scheme）是一种密码学协议，允许一方（承诺者）对某个值进行承诺，并在稍后揭示该值。HMAC 可以用于实现这种协议，过程如下：

  1. 承诺阶段：

    • 承诺者选择一个秘密值和一个随机数（nonce），并使用 HMAC 生成一个承诺值。
    • 承诺值可以公开，但秘密值和随机数保持私密。

  2. 揭示阶段：

    • 承诺者公开秘密值和随机数。
    • 验证者使用公开的秘密值和随机数，生成 HMAC 并与承诺值进行比较。如果匹配，则验证通过。

示例代码​

以下是一个使用 HMAC 实现承诺揭示的示例代码：

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
)

// 生成承诺值
func generateCommitment(secret, nonce, key []byte) string {
	h := hmac.New(sha256.New, key)
	h.Write(secret)
	h.Write(nonce)
	return hex.EncodeToString(h.Sum(nil))
}

// 验证承诺值
func verifyCommitment(commitment string, secret, nonce, key []byte) bool {
	calculatedCommitment := generateCommitment(secret, nonce, key)
	return hmac.Equal([]byte(commitment), []byte(calculatedCommitment))
}

func main() {
	secret := []byte("my secret value")
	nonce := []byte("random nonce")
	key := []byte("my secret key")

	// 承诺阶段
	commitment := generateCommitment(secret, nonce, key)
	fmt.Printf("Commitment: %s\n", commitment)

	// 揭示阶段
	isValid := verifyCommitment(commitment, secret, nonce, key)
	fmt.Printf("Is commitment valid: %v\n", isValid)
}

代码说明​

  1. 生成承诺值：

    • generateCommitment 函数将秘密值和随机数与密钥混合，并生成 HMAC 作为承诺值。

  2. 验证承诺值：

    • verifyCommitment 函数根据公开的秘密值和随机数生成 HMAC，并与承诺值进行比较。

  3. 主函数：

    • main 函数演示了生成和验证承诺值的过程。

运行代码​

将上述代码保存为一个 .go 文件（例如 commitment_example.go），然后在终端运行以下命令：

go run commitment_example.go

你将看到生成的承诺值以及验证结果。

总结​

HMAC 在确保数据完整性和真实性方面有着广泛的应用，包括 API 请求签名、数据完整性验证、身份验证和消息认证。此外，HMAC 也可以用于实现承诺揭示协议，确保信息的私密性和可信性。

我看承诺解密源码实现不是用的 hmac，而是 crypto.SHA512Int​

承诺揭示协议（Commitment Scheme）可以使用多种加密和哈希技术来实现，不一定需要使用 HMAC。具体实现方式可以根据需求和安全要求选择不同的哈希函数或加密算法。

如果你提到的承诺揭示实现使用的是 crypto.SHA512Int，那么我们可以假设这是使用 SHA-512 哈希函数的一种实现方式。虽然 Go 标准库中没有直接提供 crypto.SHA512Int，但我们可以使用 crypto/sha512 包来实现类似的功能。

使用 SHA-512 实现承诺揭示协议​

以下是一个使用 SHA-512 哈希函数实现承诺揭示协议的示例代码：

package main

import (
	"crypto/sha512"
	"encoding/hex"
	"fmt"
)

// 生成承诺值
func generateCommitment(secret, nonce []byte) string {
	h := sha512.New()
	h.Write(secret)
	h.Write(nonce)
	return hex.EncodeToString(h.Sum(nil))
}

// 验证承诺值
func verifyCommitment(commitment string, secret, nonce []byte) bool {
	calculatedCommitment := generateCommitment(secret, nonce)
	return commitment == calculatedCommitment
}

func main() {
	secret := []byte("my secret value")
	nonce := []byte("random nonce")

	// 承诺阶段
	commitment := generateCommitment(secret, nonce)
	fmt.Printf("Commitment: %s\n", commitment)

	// 揭示阶段
	isValid := verifyCommitment(commitment, secret, nonce)
	fmt.Printf("Is commitment valid: %v\n", isValid)
}

代码说明​

  1. 生成承诺值：

    • generateCommitment 函数将秘密值和随机数（nonce）拼接在一起，并使用 SHA-512 哈希函数生成承诺值。

  2. 验证承诺值：

    • verifyCommitment 函数根据公开的秘密值和随机数生成承诺值，并与原始承诺值进行比较。

  3. 主函数：

    • main 函数演示了生成和验证承诺值的过程。

运行代码​

将上述代码保存为一个 .go 文件（例如 commitment_sha512_example.go），然后在终端运行以下命令：

go run commitment_sha512_example.go

你将看到生成的承诺值以及验证结果。

总结​

承诺揭示协议可以使用多种哈希函数或加密算法来实现，具体选择取决于应用场景和安全需求。使用 SHA-512 哈希函数是一种常见的实现方式，能够提供较高的安全性。在实现过程中，关键在于确保秘密值和随机数的私密性，以及哈希函数的选择和使用是否符合安全要求。

属于对称加密​

HMAC（Hash-based Message Authentication Code，基于哈希的消息认证码）是一种基于哈希函数的消息认证码，属于对称加密范畴。具体来说，HMAC 使用一个共享的秘密密钥和一个哈希函数（如 SHA-256）来生成消息的认证码，以确保消息的完整性和真实性。

对称加密与非对称加密的区别​

  • 对称加密：加密和解密使用相同的密钥。常见的对称加密算法包括 AES、DES 和 HMAC。
  • 非对称加密：加密和解密使用不同的密钥，即公钥和私钥。常见的非对称加密算法包括 RSA 和 ECC。

HMAC 工作原理​

HMAC 的工作原理如下：

  1. 准备密钥：如果密钥长度超过哈希函数的块大小，则对密钥进行哈希处理以缩短其长度。如果密钥长度不足，则用零填充到哈希函数的块大小。
  2. 内层哈希：将密钥与一个内层填充值（ipad）进行 XOR 运算，然后将结果与消息拼接并进行哈希运算。
  3. 外层哈希：将密钥与一个外层填充值（opad）进行 XOR 运算，然后将结果与内层哈希结果拼接并进行最终的哈希运算。

HMAC 生成的认证码可以用于验证消息的完整性和真实性。由于 HMAC 使用了共享的秘密密钥，因此它属于对称加密。

HMAC 示例​

假设我们使用 HMAC-SHA256 算法，以下是一个简单的 HMAC 生成示例：

import hmac
import hashlib

# 密钥和消息
secret_key = b'secret'
message = b'This is a message.'

# 生成 HMAC
hmac_obj = hmac.new(secret_key, message, hashlib.sha256)
hmac_digest = hmac_obj.hexdigest()

print(hmac_digest)

在这个示例中，我们使用 secret_key 和 message 生成了一个 HMAC-SHA256 认证码。

总结​

HMAC 是一种基于哈希函数的消息认证码，属于对称加密。它使用共享的秘密密钥和哈希函数来生成消息的认证码，以确保消息的完整性和真实性。在 Token 加密（如 JWT）中，HMAC 通常用于生成和验证令牌的签名。