Generarea și validarea unei semnături cu cheia privată extinsă ED25519

Construiesc o aplicație de mesagerie criptată prin rețeaua tor și în prezent mă chinui să folosesc cheia privată ed25519 generată de tor pentru a semna și a verifica orice mesaj.

Piesa de cod de mai jos funcționează cu o cheie de 32 de octeți, totuși, după omiterea a 32 de octeți de antet hs_ed25519_secret_key nu reușește să verifice semnătura în cazurile de mai jos:

1 - secret: jumătate din stânga celor 64 de octeți rămași, public: jumătate din dreapta
2 - secret: jumătate din stânga celor 64 de octeți rămași, public: ultimii 32 de octeți din hs_ed25519_public_key după îndepărtarea antetului
3 - secret: toți cei 64 de octeți, public: ultimii 32 de octeți de hs_ed25519_public_key

Am găsit o bibliotecă python care pare să facă asta PyNaCl cu toate acestea nu sunt prea familiarizat cu py.

Există ceva ce fac greșit sau bouncycastle nu acceptă chei private extinse de 64 de octeți

import org.bouncycastle.crypto.Signer;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import java.nio.charset.StandardCharsets;
clasa publica ED25519 {
    public static void main(String[] args) aruncă Excepție {
        byte[] message = „un mesaj de semnat”.getBytes(StandardCharsets.UTF_8);
        Semnat semnatar = nou Ed25519Signer();
        signer.init(true, nou Ed25519PrivateKeyParameters(KeysUtil.myPrivKey, 0));
        signer.update(message, 0, message.length);
        Verificator semnatar = nou Ed25519Signer();
        verifier.init(false, nou Ed25519PublicKeyParameters(KeysUtil.myPubKey, 0));
        verifier.update(message, 0, message.length);
        boolean validSig = verifier.verifySignature(signer.generateSignature());
    }
}

```

Codul tău este în regulă dacă îi ceri lui BouncyCastle să genereze perechea de chei:

var gen = new Ed25519KeyPairGenerator();
gen.init(nou Ed25519KeyGenerationParameters(nou SecureRandom()));
var keyPair = gen.generateKeyPair();
var sk = octet nou[32];
((Ed25519PrivateKeyParameters) keyPair.getPrivate()).encode(sk, 0);
var pk = ((Ed25519PublicKeyParameters) keyPair.getPublic()).getEncoded();

Motivul pentru care nu funcționează pentru perechea de chei Tor este că BouncyCastle nu calculează cheia publică prin multiplicarea scalară a punctului de bază cu cheia secretă little-endian.

În schimb, urmează RFC 8032 și să faci SHA-512 pe materialul cheii tale inițiale, ștergând și setând anumiți biți, apoi folosind asta ca cheie secretă pentru a determina cheia publică.

Face asta:

MessageDigest md = MessageDigest.getInstance("SHA-512");
byte [] digest = md.digest(initialKeyMaterial);
var sk = subbarray(digest, 0, 32);
sk[0] &= 248;
sk[31] &= 127;
sk[31] |= 64;
var pk = basePoint.scalarMultiply(sk);

Dacă cheia secretă pe care o specificați a trecut deja prin această transformare SHA-512, atunci codul dvs. nu reușește, deoarece acum face SHA-512 de două ori. Deoarece nu puteți inversa operația SHA-512, atunci dacă trebuie să utilizați BouncyCastle, va trebui să generați cheia secretă în BouncyCastle și apoi să o utilizați cu tor, în loc de invers.

Cu toate acestea, deoarece probabil că trebuie să începeți cu perechea de chei Tor, ați putea lua în considerare modificarea codului BouncyCastle pentru a nu efectua transformarea SHA-512 înainte de a o folosi ca cheie de semnare.