Comment puis-je dériver la clé publique et la signature correctes à partir d'une clé privée préhachée à l'aide du package Go golang.org/x/crypto/ed25519 ?

Différence de clé publique Ed25519

Description du problème :

Utilisation du package Go golang.org/x/crypto/ed25519 , les tentatives visant à dériver la clé publique à partir d'une clé privée donnée produisent un résultat différent par rapport à la clé publique attendue telle que définie dans un scénario de test donné.

Cause fondamentale :

L'écart résulte de l'utilisation de différents formats de clé privée ed25519.

Différence de format de clé privée :

• Le package Go attend un format de clé privée qui consiste de la graine de 32 octets concaténée avec la clé publique de 32 octets.
• Le scénario de test utilise un format de clé privée qui est le résultat de 64 octets d'un hachage appliqué à la graine (ou éventuellement 64 octets aléatoires utilisés comme substitut).

Solution :

Étant donné que l'inversion du hachage utilisé pour générer les clés privées du scénario de test n'est pas réalisable, la conversion vers un format compatible avec le package Go n'est pas possible.

Solution proposée :

Pour obtenir la clé publique correcte pour le scénario de test, une version modifiée du package Go peut être créée qui utilise les fonctions personnalisées suivantes :

getPublicKey :

<code class="go">// GetPublicKey generates the public key from the prehashed private key.
func getPublicKey(privateKey []byte) []byte {
    var A edwards25519.ExtendedGroupElement
    var hBytes [32]byte
    copy(hBytes[:], privateKey)
    edwards25519.GeScalarMultBase(&A, &hBytes)
    var publicKeyBytes [32]byte
    A.ToBytes(&publicKeyBytes)
    return publicKeyBytes[:]
}</code>

sign :

<code class="go">// Sign generates a signature from the prehashed private key, public key, and message.
func sign(privateKey, publicKey, message []byte) []byte {
    var privateKeyA [32]byte
    copy(privateKeyA[:], privateKey)
    var messageDigest, hramDigest [64]byte
    h := sha512.New()
    h.Write(privateKey[32:])
    h.Write(message)
    h.Sum(messageDigest[:0])
    var messageDigestReduced [32]byte
    edwards25519.ScReduce(&messageDigestReduced, &messageDigest)
    var R edwards25519.ExtendedGroupElement
    edwards25519.GeScalarMultBase(&R, &messageDigestReduced)
    var encodedR [32]byte
    R.ToBytes(&encodedR)
    h.Reset()
    h.Write(encodedR[:])
    h.Write(publicKey)
    h.Write(message)
    h.Sum(hramDigest[:0])
    var hramDigestReduced [32]byte
    edwards25519.ScReduce(&hramDigestReduced, &hramDigest)
    var s [32]byte
    edwards25519.ScMulAdd(&s, &hramDigestReduced, &privateKeyA, &messageDigestReduced)
    signature := make([]byte, 64)
    copy(signature[:], encodedR[:])
    copy(signature[32:], s[:])
    return signature
}</code>

Utilisation Exemple :

<code class="go">privateKeyHex := "e06d3183d14159228433ed599221b80bd0a5ce8352e4bdf0262f76786ef1c74db7e7a9fea2c0eb269d61e3b38e450a22e754941ac78479d6c54e1faf6037881d"
privateKey, _ := hex.DecodeString(privateKeyHex)
expectedPublicKey := "77ff84905a91936367c01360803104f92432fcd904a43511876df5cdf3e7e548"
expectedSig := "6834284b6b24c3204eb2fea824d82f88883a3d95e8b4a21b8c0ded553d17d17ddf9a8a7104b1258f30bed3787e6cb896fca78c58f8e03b5f18f14951a87d9a08"
publicKey := getPublicKey(privateKey)
fmt.Printf("Calculated Public Key: %x\n", publicKey)
fmt.Printf("Expected Public Key:   %s\n", expectedPublicKey)
calculatedSig := sign(privateKey, publicKey, []byte("Hello, World!"))
fmt.Printf("Calculated Signature: %x\n", calculatedSig)
fmt.Printf("Expected Signature:   %s\n", expectedSig)</code>

Cette approche permet de calculer la clé publique et la signature correctes à l'aide du package Go modifié, comme spécifié dans le scénario de test.

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!