Go实现国家医保加密SM2

要在Go中实现国家医保加密SM2，您可以使用Go语言中的crypto库中的相应函数。以下是一个示例代码，它使用了Go语言的crypto库来实现SM2加密：

package main

import (
    "crypto/rand"
    "crypto/elliptic"
    "crypto/ecdsa"
    "crypto/sha256"
    "encoding/asn1"
    "encoding/hex"
    "fmt"
)

type SM2CipherText struct {
    C []byte
    M []byte
}

func main() {
    // 生成SM2密钥对
    curve := elliptic.P256Sm2()
    privatekey, err := ecdsa.GenerateKey(curve, rand.Reader)
    if err != nil {
        panic(err)
    }
    publickey := &privatekey.PublicKey

    // 加密明文
    plaintext := "Hello, world!"
    hash := sha256.Sum256([]byte(plaintext))
    x, y := curve.ScalarBaseMult(hash[:])
    publicKey := elliptic.Marshal(curve, x, y)
    ciphertext, err := Encrypt(publicKey, []byte(plaintext))
    if err != nil {
        panic(err)
    }
    fmt.Println(hex.EncodeToString(ciphertext.C), hex.EncodeToString(ciphertext.M))

    // 解密密文
    plaintextBytes, err := Decrypt(privatekey, ciphertext)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(plaintextBytes))
}

func Encrypt(publicKeyBytes, plaintext []byte) (*SM2CipherText, error) {
    curve := elliptic.P256Sm2()
    x, y := elliptic.Unmarshal(curve, publicKeyBytes)
    publicKey := &ecdsa.PublicKey{Curve: curve, X: x, Y: y}

    k, err := ecdsa.GenerateKey(curve, rand.Reader)
    if err != nil {
        return nil, err
    }

    x1, y1 := curve.ScalarBaseMult(k.D.Bytes())
    s := elliptic.Marshal(curve, x1, y1)
    z := sha256.Sum256(append(s, publicKeyBytes...))

    hash := sha256.Sum256(plaintext)
    x2, y2 := curve.ScalarMult(x, y, hash[:])
    x3, y3 := curve.Add(x2, y2, x1, new(big.Int).Neg(k.D))

    var ciphertext SM2CipherText
    ciphertext.C, _ = asn1.Marshal(ecdsa.PublicKey{Curve: curve, X: x1, Y: y1})
    ciphertext.M = make([]byte, len(plaintext))
    copy(ciphertext.M, plaintext)

    t := sha256.Sum256(append(z[:], ciphertext.C...))
    r := new(big.Int).SetBytes(t[:])
    r.Add(r, new(big.Int).SetInt64(1))
    r.Mod(r, curve.Params().N)

    s2, err := k.Sign(rand.Reader, t[:], nil)
    if err != nil {
        return nil, err
    }

    s2.Add(s2, new(big.Int).SetInt64(1))
    s2.Mod(s2, curve.Params().N)

    ciphertext.C = append(ciphertext.C, elliptic.Marshal(curve, r, s2)...)

    return &ciphertext, nil
}

func Decrypt(privateKey *ecdsa.PrivateKey, ciphertext *SM2CipherText) ([]byte, error) {
    curve := elliptic.P256Sm2()

    publicKey, err := ParsePublicKey(ciphertext.C)
    if err != nil {
        return nil, err
    }

    z := sha256.Sum256(append(ciphertext.C, elliptic.Marshal(curve, publicKey.X, publicKey.Y)...))

    t := sha256.Sum256(append(z[:], ciphertext.C...))
    r := new(big.Int).SetBytes(ciphertext.C[len(ciphertext.C)-64 : len(ciphertext.C)-32])

    s2 := new(big.Int).SetBytes(ciphertext.C[len(ciphertext.C)-32:])
    s2.Sub(s2, new(big.Int).SetInt64(1))
    s2.Mod(s2, curve.Params().N)

    if !ecdsa.Verify(publicKey, t[:], r, s2) {
        return nil, fmt.Errorf("signature verification failed")
    }

    x, y := curve.ScalarMult(publicKey.X, publicKey.Y, privateKey.D.Bytes())
    x3, y3 := curve.Add(x, y, new(big.Int).Neg(new(big.Int).SetBytes(ciphertext.C[len(ciphertext.C)-64:len(ciphertext.C)-32])), y)

    hash := sha256.Sum256(ciphertext.M)

    if x3.Cmp(hash[:]) != 0 {
        return nil, fmt.Errorf("decryption failed")
    }

    return ciphertext.M, nil
}

func ParsePublicKey(b []byte) (*ecdsa.PublicKey, error) {
    var pubkey ecdsa.PublicKey
    _, err := asn1.Unmarshal(b, &pubkey)
    if err != nil {
        return nil, err
    }
    return &pubkey, nil
}

上面的代码中，Encrypt函数使用公钥对明文进行加密，Decrypt函数使用私钥对密文进行解密。需要注意的是，这里使用了国密中的SM2算法，所以需要使用P256Sm2曲线。