Maison >développement back-end >Golang >Signatures numériques : votre cryptographique John Hancock, passez à Crypto 6
Salut, champion de crypto ! Prêt à plonger dans le monde des signatures numériques ? Considérez-les comme votre autographe numérique : un moyen de prouver que vous êtes vraiment vous-même dans le monde numérique et que votre message n'a pas été falsifié. Explorons comment Go nous aide à créer ces John Hancocks numériques infalsifiables !
Tout d’abord, nous avons les signatures RSA. C'est comme signer un document avec un stylo vraiment sophistiqué et infalsifiable.
import ( "crypto" "crypto/rand" "crypto/rsa" "crypto/sha256" "fmt" ) func main() { // Let's create our special signing pen (RSA key pair) privateKey, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { panic("Oops! Our pen ran out of ink.") } publicKey := &privateKey.PublicKey // Our important message message := []byte("I solemnly swear that I am up to no good.") // Let's create a fingerprint of our message hash := sha256.Sum256(message) // Time to sign! signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hash[:]) if err != nil { panic("Our hand cramped while signing!") } fmt.Printf("Our RSA signature: %x\n", signature) // Now, let's verify our signature err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hash[:], signature) if err != nil { fmt.Println("Uh-oh, someone forged our signature!") } else { fmt.Println("Signature checks out. Mischief managed!") } }
Ensuite, nous avons les signatures ECDSA. C'est comme le cousin plus cool et plus efficace de RSA : des signatures plus petites avec le même niveau de sécurité.
import ( "crypto/ecdsa" "crypto/elliptic" "crypto/rand" "crypto/sha256" "fmt" "math/big" ) func main() { // Let's create our curvy signing pen privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) if err != nil { panic("Our curvy pen got a bit too curvy!") } publicKey := &privateKey.PublicKey // Our important message message := []byte("Elliptic curves are mathematically delicious!") // Create a fingerprint of our message hash := sha256.Sum256(message) // Time to sign with our curvy pen! r, s, err := ecdsa.Sign(rand.Reader, privateKey, hash[:]) if err != nil { panic("Our hand slipped while signing these curves!") } signature := append(r.Bytes(), s.Bytes()...) fmt.Printf("Our curvy ECDSA signature: %x\n", signature) // Let's verify our curvy signature r = new(big.Int).SetBytes(signature[:len(signature)/2]) s = new(big.Int).SetBytes(signature[len(signature)/2:]) valid := ecdsa.Verify(publicKey, hash[:], r, s) fmt.Printf("Is our curvy signature valid? %v\n", valid) }
Enfin, nous avons les signatures Ed25519. C'est comme la voiture de sport des signatures numériques : rapides et sécurisées.
import ( "crypto/ed25519" "crypto/rand" "fmt" ) func main() { // Let's create our speedy signing pen publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) if err != nil { panic("Our speedy pen got a speeding ticket!") } // Our important message message := []byte("Speed is my middle name!") // Time to sign at lightning speed! signature := ed25519.Sign(privateKey, message) fmt.Printf("Our speedy Ed25519 signature: %x\n", signature) // Let's verify our speedy signature valid := ed25519.Verify(publicKey, message, signature) fmt.Printf("Is our speedy signature valid? %v\n", valid) }
Maintenant, vous vous demandez peut-être : « Quelle signature dois-je utiliser ? » Eh bien, cela dépend de vos besoins :
Maintenant que vous êtes un artiste signature, voici quelques règles d'or à garder à l'esprit :
Le hasard est la clé : utilisez toujours crypto/rand pour tout ce qui concerne les signatures. Le caractère aléatoire prévisible, c'est comme utiliser la même signature à chaque fois - ce n'est pas bon !
Hashez avant de signer : Sauf pour Ed25519, hachez toujours votre message avant de signer. C'est comme créer une empreinte digitale unique de votre message.
La taille compte : utilisez au moins 2048 bits pour RSA, 256 bits pour ECDSA et Ed25519 est toujours de 256 bits.
Gardez vos stylos en sécurité : Protégez vos clés privées comme vous protégeriez vos biens les plus précieux. Une clé de signature volée, c'est comme si quelqu'un volait votre identité !
Vérifiez vos vérificateurs : assurez-vous que les clés publiques que vous utilisez pour vérifier les signatures sont légitimes. Une fausse clé publique pourrait vous faire confiance à une fausse signature !
Standardisez lorsque cela est possible : pensez à utiliser des formats tels que JSON Web Signature (JWS) si vous avez besoin de bien jouer avec d'autres systèmes.
Soyez conscient des attaques sournoises : dans les scénarios de haute sécurité, faites attention aux attaques par canal secondaire. C'est comme si quelqu'un regardait par-dessus votre épaule pendant que vous signez.
Félicitations ! Vous venez d'ajouter des signatures numériques à votre boîte à outils cryptographique. Ceux-ci sont cruciaux pour prouver l’authenticité et l’intégrité dans le monde numérique.
Ensuite, nous explorerons comment Go gère les certificats TLS et X.509. C'est comme apprendre à créer et vérifier des cartes d'identité numériques : indispensable pour une communication sécurisée sur Internet !
N'oubliez pas que dans le monde de la cryptographie, comprendre ces bases est crucial. C'est comme apprendre à écrire sa signature : une compétence fondamentale à l'ère du numérique. Maîtrisez-les et vous serez sur la bonne voie pour créer des applications sécurisées et authentifiées dans Go.
Alors, que diriez-vous d'essayer de mettre en œuvre un système simple de signature de documents ? Ou peut-être créer un programme qui vérifie les mises à jour logicielles à l’aide de signatures numériques ? Le monde des autographes numériques infalsifiables est à portée de main ! Bon codage, champion de la crypto !
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!