Comment se connecter à Golang

Avec le développement continu de la technologie Internet, le langage Go, en tant que nouveau langage de programmation, a été accueilli par de plus en plus de développeurs. En tant que langage fortement typé, le langage Go peut fournir un support de développement plus efficace, plus sûr et plus stable et a été largement utilisé. Dans le langage Go, le mécanisme de signature fait également partie des fonctions très importantes. Voyons ensuite comment implémenter les signatures dans le langage Go.

Tout d’abord, nous devons comprendre certains concepts de signature.

La soi-disant signature consiste à crypter les données et à ajouter des marques spéciales aux données afin que des tiers ne puissent pas falsifier les données et les falsifier. La signature numérique est l'une des formes de méthodes de signature. Son principe de base est d'utiliser une technologie de cryptage asymétrique, c'est-à-dire une paire de clés composée d'une clé privée et d'une clé publique pour la signature et la vérification.

En langage Go, nous pouvons utiliser les fonctions fournies dans le package crypto pour implémenter la fonction de signature numérique. Les étapes spécifiques de mise en œuvre sont les suivantes :

1. Générer une paire de clés

Nous pouvons utiliser RSA pour générer une paire de clés. Le code est le suivant :

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/pem"
    "os"
)

func GenerateRsaKey() error {
    // 生成私钥
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        return err
    }
    derPrivateKey := x509.MarshalPKCS1PrivateKey(privateKey)
    privateKeyBlock := &pem.Block{
        Type:  "RSA PRIVATE KEY",
        Bytes: derPrivateKey,
    }
    // 将私钥写入文件中
    privateKeyFile, err := os.Create("private.pem")
    if err != nil {
        return err
    }
    defer privateKeyFile.Close()
    pem.Encode(privateKeyFile, privateKeyBlock)

    // 生成公钥
    publicKey := privateKey.PublicKey
    derPublicKey, err := x509.MarshalPKIXPublicKey(&publicKey)
    if err != nil {
        return err
    }
    publicKeyBlock := &pem.Block{
        Type:  "PUBLIC KEY",
        Bytes: derPublicKey,
    }
    // 将公钥写入文件中
    publicKeyFile, err := os.Create("public.pem")
    if err != nil {
        return err
    }
    defer publicKeyFile.Close()
    pem.Encode(publicKeyFile, publicKeyBlock)

    return nil
}

Cette fonction générera une paire de clés de 2048 bits et écrira respectivement la clé privée et la clé publique dans les fichiers private.pem et public.pem.

2. Signer les données

Nous pouvons signer des données à l'aide de la clé privée RSA. Le code de la fonction de signature est le suivant :

package main

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "encoding/hex"
)

func Sign(data []byte, privateKey *rsa.PrivateKey) (string, error) {
    h := sha256.New()
    h.Write(data)
    hash := h.Sum(nil)

    signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hash)
    if err != nil {
        return "", err
    }

    return hex.EncodeToString(signature), nil
}

Cette fonction reçoit un tableau d'octets et une clé privée en paramètres et renvoie la chaîne signée.

3. Vérifier la signature

Nous pouvons vérifier la signature à l'aide de la clé publique RSA. Le code de la fonction de vérification est le suivant :

package main

import (
    "crypto"
    "crypto/rsa"
    "crypto/sha256"
    "encoding/hex"
)

func Verify(signature string, data []byte, publicKey *rsa.PublicKey) bool {
    h := sha256.New()
    h.Write(data)
    hash := h.Sum(nil)

    decodedSignature, err := hex.DecodeString(signature)
    if err != nil {
        return false
    }

    err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hash, decodedSignature)
    if err != nil {
        return false
    }

    return true
}

Cette fonction reçoit la chaîne de signature, le tableau d'octets de données d'origine et la clé publique en tant que paramètres, et renvoie le résultat de la vérification de la signature.

Ce qui précède contient quelques connaissances de base et un code opérationnel sur la façon de mettre en œuvre des signatures numériques en langage Go. Dans les applications pratiques, le mécanisme de signature numérique peut protéger efficacement la sécurité et la fiabilité des données, améliorer la stabilité et la crédibilité des systèmes d'application et jouer un rôle très important dans la protection de la vie privée des utilisateurs et la garantie de l'intégrité des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!