java - quién - ¿Cómo comprime o codifica la clave pública curva elíptica y la coloco sobre la red?

historia de las curvas elipticas

Question

Estoy desarrollando una firma digital distribuida que firma un documento y lo envía a través de la red al servidor de aplicaciones. Estoy usando la programación de socket en java para hacerlo. Creo que la clave pública debe estar codificada o comprimida, es decir, los valores xey se representan de alguna manera como datos binarios individuales y se guardan en un registro público o red. Pero no sé cómo hacerlo en Java.

 // I have class like this
public class CryptoSystem{
EllipticCurve ec = new EllipticCurve(new P192());
//-------------------
//--------------------
public ECKeyPair generatekeyPair()
{
return ECKeyPair(ec);
}
}
// i don''t think i have problem in the above
CryptoSystem crypto = new CryptoSystem();
ECKeyPair keyPair = crypto.generateKeyPair();
BigInteger prvKey = keyPair.getPrivateKey();
ECPoint pubKey = keyPair.getPublicKey();
// recommend me here to compress and send it the public key to a shared network.

Quiero saber cómo codificar la clave pública y los parámetros del dominio, para que el verificador de la firma lo decodifique para usarlo. Porque cuando los envíe por la red al verificador tendrá que codificar la matriz como un solo byte .no uso el proveedor de Bouncy Castle. Toda la implementación del algoritmo ECDSA es mi proyecto

Answer 1

Los puntos de curva elíptica casi siempre están codificados usando la codificación especificada en X9.62.

Es opcional usar la compresión de puntos. Es trivial codificar usando la compresión de puntos, pero decodificar un punto comprimido necesita un poco más de trabajo, así que a menos que realmente necesites guardar los bytes adicionales, no me molestaría. Avíseme si lo necesita y agregaré los detalles. Puede reconocer puntos codificados en X9.62 con compresión de puntos en el primer byte, que será 0x02 o 0x03.

La codificación sin compresión de puntos es realmente simple: comience con un 0x04 (para indicar que no hay compresión). A continuación, siga primero la coordenada x, luego la coordenada y, ambas con relleno cero en la izquierda hasta el tamaño en bytes del campo:

int qLength = (q.bitLength()+7)/8;
byte[] xArr = toUnsignedByteArray(x);
byte[] yArr = toUnsignedByteArray(y);
byte[] res = new byte[1+2*qLength];
res[0] = 0x04;
System.arraycopy(xArr, 0, res, qLength - xArr.length, xArr.length);
System.arraycopy(yArr, 0, res, 2* qLength - yArr.length, nLength);

Decodificar esto es, por supuesto, trivial.

Answer 2

Estoy bastante seguro de que la implementación de BC utiliza codificación X9.63, por lo que estas codificaciones serían bastante estandarizadas. Tendrá que agregar el proveedor de Bouncy Castle a su JRE ( Security.addProvider(new BouncyCastleProvider()) , consulte la documentación de rebote.

public static void showECKeyEncodings() {
try {
KeyPairGenerator kp = KeyPairGenerator.getInstance("ECDSA");
ECNamedCurveParameterSpec ecSpec = ECNamedCurveTable
.getParameterSpec("prime192v1");
kp.initialize(ecSpec);
KeyPair keyPair = kp.generateKeyPair();
PrivateKey privKey = keyPair.getPrivate();
byte[] encodedPrivKey = privKey.getEncoded();
System.out.println(toHex(encodedPrivKey));
PublicKey pubKey = keyPair.getPublic();
byte[] encodedPubKey = pubKey.getEncoded();
System.out.println(toHex(encodedPubKey));
KeyFactory kf = KeyFactory.getInstance("ECDSA");
PublicKey pubKey2 = kf.generatePublic(new X509EncodedKeySpec(encodedPubKey));
if (Arrays.equals(pubKey2.getEncoded(), encodedPubKey)) {
System.out.println("That worked for the public key");
}
PrivateKey privKey2 = kf.generatePrivate(new PKCS8EncodedKeySpec(encodedPrivKey));
if (Arrays.equals(privKey2.getEncoded(), encodedPrivKey)) {
System.out.println("That worked for the private key");
}
} catch (GeneralSecurityException e) {
throw new IllegalStateException(e);
}
}