standard/crypto_test/pkg/service/service.go

package service

import (
	"bytes"
	"crypto/md5"
	"crypto/rand"
	"crypto_test/pkg/handle"
	"encoding/hex"
	"fmt"
	"log"

	"golang.org/x/crypto/sha3"

	"github.com/tjfoc/gmsm/sm2"
	"github.com/tjfoc/gmsm/sm3"
	"github.com/tjfoc/gmsm/x509"
)

func RSA() {
	content := "hello world"
	base64Sig, err := handle.RSASign([]byte(content), "./rsa_private_key.pem")
	if err != nil {
		fmt.Println("私钥签名失败：", err)
		return
	}
	fmt.Println("私钥签名结果：", base64Sig)
	err = handle.RSAVerify([]byte(content), base64Sig, "./rsa_public_key.pem")
	if err != nil {
		fmt.Println("验证签名失败：", err)
	} else {
		fmt.Println("签名验证成功")
	}
}

func SM2() {
	content := []byte("hello world")
	priv, err := sm2.GenerateKey(rand.Reader) // 生成密钥对
	if err != nil {
		log.Fatal(err)
	}
	pub := &priv.PublicKey
	ciphertxt, err := pub.EncryptAsn1(content, rand.Reader) //sm2加密
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("加密结果: ", ciphertxt)

	plaintxt, err := priv.DecryptAsn1(ciphertxt) //sm2解密
	if err != nil {
		log.Fatal(err)
	}
	if !bytes.Equal(content, plaintxt) {
		log.Fatal("原文不匹配")
	}

	sign, err := priv.Sign(rand.Reader, content, nil) //sm2签名
	if err != nil {
		log.Fatal(err)
	}
	isok := pub.Verify(content, sign) //sm2验签
	fmt.Printf("Verified: %v\n", isok)

}

//	func GetKey2(){
//		priv, err := sm2.GenerateKey(rand.Reader) // 生成密钥对
//		if err != nil {
//			log.Fatal(err)
//		}
//	}
func SM3() {
	content := []byte("hello world")
	h := sm3.New()
	h.Write([]byte(content))
	sum := h.Sum(nil)
	fmt.Printf("sm3 value is: %x\n", sum)
}

func MD5() {
	content := []byte("hello world")
	h := md5.New()
	h.Write(content)
	sum2 := hex.EncodeToString(h.Sum(nil))
	fmt.Printf("md5 value is: %x\n", sum2)
}

func GetKey() {
	// 生成 SM2 密钥对
	priv, err := sm2.GenerateKey(nil) // 使用 sm2 包生成密钥对
	if err != nil {
		return // 如果生成密钥对失败，直接返回
	}

	// 将私钥转换为 PEM 格式
	privPem, err := x509.WritePrivateKeyToPem(priv, nil) // 使用 x509 包将私钥转换为 PEM 格式
	if err != nil {
		log.Fatal(err) // 如果转换失败，记录错误并终止程序
	}

	// 将公钥转换为 PEM 格式
	publicPem, err := x509.WritePublicKeyToPem(&priv.PublicKey) // 使用 x509 包将公钥转换为 PEM 格式
	if err != nil {
		log.Fatal(err) // 如果转换失败，记录错误并终止程序
	}

	// 从 PEM 格式中恢复公钥
	publicKeyFromPem, err := x509.ReadPublicKeyFromPem([]byte(publicPem)) // 使用 x509 包从 PEM 格式恢复公钥
	if err != nil {
		log.Fatal(err) // 如果恢复失败，记录错误并终止程序
	}

	// 打印压缩后的公钥的十六进制表示
	fmt.Println("pubkey", hex.EncodeToString(sm2.Compress(publicKeyFromPem))) // 使用 sm2 包对公钥进行压缩，并打印其十六进制表示

	// 从 PEM 格式中恢复私钥
	privateKeyFromPem, err := x509.ReadPrivateKeyFromPem([]byte(privPem), nil) // 使用 x509 包从 PEM 格式恢复私钥
	if err != nil {
		log.Fatal(err) // 如果恢复失败，记录错误并终止程序
	}

	// 打印私钥的 D 参数的十六进制表示
	fmt.Println("privkey", hex.EncodeToString(privateKeyFromPem.D.Bytes())) // 打印私钥的 D 参数（私钥的核心部分）的十六进制表示
}

func SHA3(ctx string) {
	h := sha3.New256() // 可以选择SHA3-224、SHA3-256、SHA3-384或SHA3-512

	// 写入数据 可以多次调用Write()方法，逐步写入数据
	h.Write([]byte(ctx))

	// 计算哈希值
	hash := h.Sum(nil)

	// 打印哈希值（以十六进制格式）
	fmt.Printf("SHA-3-256: %x\n", hash)

	// 也可以直接使用Sum256函数
	data := []byte(ctx)
	hash2 := sha3.Sum256(data)
	fmt.Printf("SHA-3-256: %x\n", hash2)
}