PC & Mobile

Quand Bob rencontra Alice – Medium

Quand Bob rencontra Alice - Medium


Une démonstration de la méthode est ici.

Nous vivons dans un monde d'infrastructure à clé publique, où nous distribuons les clés publiques au moyen de certificats numériques. C'est un monde horriblement brouillé, que peu de gens comprennent. Si nous devions recommencer, nous ne mettrions pas en œuvre l'ICP. Le monde de Bitcoin et de blockchain le fait beaucoup mieux, et là où je peux signer quelque chose avec ma clé privée, la signature peut ensuite être utilisée pour dériver ma clé publique. De cette façon, je n’ai pas à distribuer ma clé publique, vous pouvez le trouver à partir de ma signature. Nous pouvons également vérifier que je suis le signataire de mon message, sans avoir à placer ma clé publique dans un certificat approuvé. Nous nous tournons donc vers les signatures Schnorr et leur implémentation dans le langage de programmation Go.

Signatures Schnorr

Avec la signature Schnorr, nous créons une signature (R, s) pour un hachage du message (MM). Nous générons d’abord une clé privée (x) puis nous dérivons la clé publique d’un point de la courbe elliptique (G) pour obtenir:

P = x⋅G

Ensuite, nous sélectionnons une valeur aléatoire (k) pour obtenir une valeur de signature de R:

R = k⋅G

La valeur de s est alors:

s = k − hachage (M, R) ⋅x

Notre signature de M est (s, R) et la clé publique est P.

Pour vérifier la signature, nous calculons

P⋅Hash (M, R) + s⋅G

Cela devient x⋅G⋅Hash (M, R) + (k − Hash (M, R) x) ⋅G

lequel est:

x⋅G⋅Hash (M, R) + k⋅G - Hash (M, R) x⋅G = k⋅G

La valeur de k⋅G est égale à R; ainsi, si le résultat est identique à R, la signature est extraite.

Un exemple d’exécution contenant le message «Hello» est (et où «BN» est «Big Number») [here]:

Message: Bonjour
Clé privée: dce71358bf6d57dffaf8ac422ea972dca65badd2ce21b585803ea3075b7de388
Clé publique: Tampon 03 9d e0 bd 0a e1 b2 1c 64 c7 35 12 31 1c d5 fd 35 42 f1 0a f5 02 9c c7 eb 81 e5 fb cc c8 51 18 27
Signature [s]: BN: 18573f5212373b51022b00cbe12276b8099a351526b3384ccd1f02ad71761ff1
Signature [r]: BN: 3d96504afbe3beec97a753c38d614ec5fa68cf8219df36d7cce891319058d5db
Récupération de la clé publique: Tampon 03 9d e0 bd 0a e1 b2 1c 64 c7 35 12 31 1c d5 fd 35 42 f1 0a f5 02 9c c7 eb 81 e5 fb cc c8 51 18 27
Signature vérifiée: true

Dans ce cas, nous avons une clé privée de 256 bits (dce7… 388) et produisons une clé publique de 512 bits (03 96e… 827) - la partie «03» indique que nous utilisons une clé publique Bitcoin. Ainsi, si nous connaissons le message - et celui qui sera stocké dans la blockchain dans le cas de Bitcoin - et la clé, nous verrons que nous pouvons récupérer la clé publique à partir de la signature.

L'un des grands avantages de la signature Schnorr est que nous pouvons signer plus d'un message.

Coder avec Go

Le langage de programmation Go nous donne la puissance du C ++, sans la complexité. Un aperçu du code Go pour implémenter la signature Schnorr est [code]:

paquet principal
importer (
"fmt"
"drapeau"
"gopkg.in/dedis/kyber.v2"
"gopkg.in/dedis/kyber.v2/group/edwards25519"
)
var curve = edwards25519.NewBlakeSHA256Ed25519 ()
var sha256 = curve.Hash ()
type Signature struct {
r kyber.Point
s kyber.Scalar
}
func Hash (chaîne de caractères) kyber.Scalar {
sha256.Reset ()
sha256.Write ([]octet (s)
        return curve.Scalar (). SetBytes (sha256.Sum (nil))
}
// m: Message
// x: clé privée
func Sign (chaîne de caractères, x kyber.Scalar) Signature {
// Récupère la base de la courbe.
g: = curve.Point (). Base ()
        // Choisit un k aléatoire dans l'ensemble autorisé.
k: = curve.Scalar (). Choisissez (curve.RandomStream ())
        // r = k * G (a.k.a la même opération que r = g ^ k)
r: = curve.Point (). Mul (k, g)
        // hachage (m || r)
e: = hachage (m + r.Chaîne ())
        // s = k - e * x
s: = curve.Scalar (). Sub (k, curve.Scalar (). Mul (e, x))
        return Signature {r: r, s: s}
}
// m: Message
// S: Signature
func PublicKey (chaîne de caractères, S Signature) kyber.Point {
// Crée un générateur.
g: = curve.Point (). Base ()
        // e = hachage (m || r)
e: = hachage (m + S.r.String ())
        // y = (r - s * G) * (1 / e)
y: = Curve.Point (). Sub (S.r, Curve.Point (). Mul (S.s, g))
y = courbe.Point (). Mul (courbe.Scalar (). Div (courbe.Scalar (). Un (), e), y)
        retourne y
}
// m: Message
// s: Signature
// y: clé publique
func Verify (chaîne de caractères, S Signature, y kyber.Point) bool {
// Crée un générateur.
g: = curve.Point (). Base ()
        // e = hachage (m || r)
e: = hachage (m + S.r.String ())
        // Tentative de reconstruire le * G 'avec une signature fournie; s * G = r - e * y
sGv: = curve.Point (). Sub (S.r, curve.Point (). Mul (e, y))
        // Construit le réel 's' G '
sG: = curve.Point (). Mul (S.s, g)
        // contrôle d'égalité; assurer la signature et les sorties de clé publique à s * G.
retour sG.Equal (sGv)
}
func (S Signature) String () string {
retourne fmt.Sprintf ("(r =% s, s =% s)", S.r, S.s)
}
func main () {
        message: = "abc"
flag.Parse ()
args: = flag.Args ()
message = args[0]
        privateKey: = curve.Scalar (). Choisissez (curve.RandomStream ())
publicKey: = curve.Point (). Mul (privateKey, curve.Point (). Base ())
fmt.Printf ("Message à signer:% s  n  n", message)
fmt.Printf ("Clé privée:% s n", clé privée)
fmt.Printf ("Clé publique:% s n n", clé publique)
        signature: = Sign (message, privateKey)
                fmt.Printf ("Signature (r =% s, s =% s)  n  n", signature.r, signature.s)
        DerivePublicKey: = PublicKey (message, signature)
        fmt.Printf ("Clé publique dérivée:% s  n  n", dérivéPublicKey)
        fmt.Printf ("Vérification des clés% t  n", publicKey.Equal (dérivéPublicKey))
fmt.Printf ("Vérification de la signature% t n n", Verify (message, signature, publicKey))
}

Dans ce cas, nous intégrons des bibliothèques de cryptographie à l'aide de l'instruction Import (). Ceux-ci sont importés dans le dossier src en utilisant Git avec:

allez chercher gopkg.in  dedis  kyber.v2
allez chercher github.com dedis fixbuf

Le grand avantage de Go est qu’il peut être installé dans la plupart des systèmes d’exploitation, puis compilé en une version exécutable. [install]. Nous créons d’abord ce code sous forme de fichier appelé “schnorr.go” puis nous compilons avec:

allez construire schnorr.go

Dans Microsoft Windows, cela crée ensuite un fichier exécutable nommé «schnorr.exe», qui peut être exécuté en tant que programme autonome et passer en argument. Un exemple de parcours est:

Message à signer: abc
Clé privée: db9f72a4b7c6d76e480640dc9b40789f2ce1860700415c90178df4599c0a9006
Clé publique: 96f17aa85c9dc5a57ca3103d723990f775eb38a668afb2e43679efec7eca2080
Signature (r = 2ae621dabf1c6dc83302c67e951e5da62ff073970f0ce37b531f55e319c56be5, s = 6917994e914ff7f6f29fa29861749203f242eae832d1e24e2f13a3e16f3a3
Clé publique dérivée: 96f17aa85c9dc5a57ca3103d723990f775eb38a668afb2e43679efec7eca2080
Vérification des clés true
Vérification de la signature true

Dans ce cas, nous générons une clé privée, puis la clé publique associée. Ensuite, nous calculons la signature (r, s) du message. Ensuite, nous pouvons déduire la clé publique de la signature. En fin de compte, nous pouvons vérifier que les clés sont les mêmes et que la signature est vérifiée.

La démo est ici:

Conclusions

Dans la sécurité informatique, peu de choses sont aussi parfaites que la signature Schnorr. Le monde numérique actuel est imparfait et nous devons en créer un nouveau. La signature Schnorr nous fournit un moyen de placer le citoyen au cœur d'Internet.

Oh, comme j'aime la beauté de la cryptographie à courbe elliptique!

Show More

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Related Articles

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Close
Close