Warum generiert die Go-Implementierung von ed25519 in bestimmten Fällen einen anderen öffentlichen Schlüssel als erwartet?

ed25519 Public Key Generation Disparity

Das kryptografische Paket ed25519 bietet eine Möglichkeit, öffentliche Schlüssel aus privaten Schlüsseln zu generieren. Benutzer haben jedoch festgestellt, dass der von der Go-Implementierung generierte öffentliche Schlüssel in bestimmten Anwendungsfällen nicht mit dem erwarteten Wert übereinstimmt.

Ursache:

Diese Ungleichheit ergibt sich aus den verschiedenen Formaten, die zur Darstellung privater Schlüssel von ed25519 verwendet werden. Das Go-Paket verwendet ein Format, bei dem der private Schlüssel als Verkettung des 32-Byte-Seeds und des 32-Byte-öffentlichen Schlüssels dargestellt wird. Umgekehrt stellen die Testvektoren, die die erwarteten Ergebnisse definieren, den privaten Schlüssel als 64-Byte-Ausgabe des Hashings des Seeds dar.

Lösung:

Angesichts der Tatsache, dass dies nicht möglich ist Wenn Sie den Hashing-Prozess umkehren, ist es unmöglich, die privaten Schlüssel des Testvektors in ein Format zu konvertieren, das mit der Go-Implementierung kompatibel ist. Alternativ können Sie eine modifizierte Version der Go-Bibliothek erstellen, die das alternative private Schlüsselformat unterstützt.

Geänderter Bibliothekscode:

Die folgenden Codeausschnitte stellen eine benutzerdefinierte Version bereit der Go-Implementierung zur Unterstützung des alternativen privaten Schlüsselformats:

Generieren des öffentlichen Schlüssels:

<code class="go">// Generate the public key corresponding to the already hashed private
// key.
//
// This code is mostly copied from GenerateKey in the
// golang.org/x/crypto/ed25519 package, from after the SHA512
// calculation of the seed.
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>

Signieren:

<code class="go">// Calculate the signature from the (pre hashed) private key, public key
// and message.
//
// This code is mostly copied from the Sign function from
// golang.org/x/crypto/ed25519, from after the SHA512 calculation of the
// seed.
func sign(privateKey, publicKey, message []byte) []byte {

    var privateKeyA [32]byte
    copy(privateKeyA[:], privateKey) // we need this in an array later
    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>

Demonstration:

Der folgende Code demonstriert die Verwendung der benutzerdefinierten Funktionen zum Generieren des erwarteten öffentlichen Schlüssels und der erwarteten Signatur:

<code class="go">privateKeyHex := "e06d3183d14159228433ed599221b80bd0a5ce8352e4bdf0262f76786ef1c74db7e7a9fea2c0eb269d61e3b38e450a22e754941ac78479d6c54e1faf6037881d"

expectedPublicKey := "77ff84905a91936367c01360803104f92432fcd904a43511876df5cdf3e7e548"
expectedSig := "6834284b6b24c3204eb2fea824d82f88883a3d95e8b4a21b8c0ded553d17d17ddf9a8a7104b1258f30bed3787e6cb896fca78c58f8e03b5f18f14951a87d9a08"

privateKey, _ := hex.DecodeString(privateKeyHex)
publicKey := getPublicKey(privateKey)

fmt.Printf("Calculated key: %x\n", publicKey)
fmt.Printf("Expected key:   %s\n", expectedPublicKey)
keyMatches := expectedPublicKey == hex.EncodeToString(publicKey)
fmt.Printf("Public key matches expected: %v\n", keyMatches)

buffer := []byte("4:salt6:foobar3:seqi1e1:v12:Hello World!")
calculatedSig := sign(privateKey, publicKey, buffer)

fmt.Printf("Calculated sig: %x\n", calculatedSig)
fmt.Printf("Expected sig:   %s\n", expectedSig)
sigMatches := expectedSig == hex.EncodeToString(calculatedSig)
fmt.Printf("Signature matches expected: %v\n", sigMatches)</code>

Durch die Integration dieser benutzerdefinierten Funktionen Wenn Sie Funktionen in Ihren Code integrieren, können Sie Testvektoren verarbeiten, die im alternativen privaten Schlüsselformat definiert sind, und Vorgänge wie die Generierung und Signierung öffentlicher Schlüssel ausführen, ohne auf nicht übereinstimmende Ergebnisse zu stoßen.

Das obige ist der detaillierte Inhalt vonWarum generiert die Go-Implementierung von ed25519 in bestimmten Fällen einen anderen öffentlichen Schlüssel als erwartet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!