Wie um zu überprüfen, ob die privaten Schlüssel entspricht, der mit dem Zertifikat..?

So, was ist das problem mit pairwise parameter überprüfen?

• Wenn das Zertifikat gibt den öffentlichen Schlüssel vom Typ "RSA", dann:
  1. Extrakt n, e aus der key-Datei.
  2. Vergleichen Sie diese Werte mit denen im Zertifikat.
• Wenn das Zertifikat gibt den öffentlichen Schlüssel vom Typ "DSA", dann:
  1. Extrakt p, q, g, y aus der key-Datei.
  2. Vergleichen Sie diese Werte mit denen im Zertifikat.
• Wenn das Zertifikat gibt den öffentlichen Schlüssel der Art "bla-bla", dann:
  1. Extrahieren entsprechenden Werte aus der key-Datei.
  2. Vergleichen Sie diese Werte mit denen im Zertifikat.

Und so, ich. e. jeder Algorithmus benötigt seine eigene Behandlung. Keinen Allgemeinen Algorithmus existieren können, vorausgesetzt, dass die Schlüssel-Datei-format ist tatsächlich Gewohnheit. Jedoch können Sie immer noch etwas verallgemeinern, indem Sie Wert-Indizes nur:

ComparisonScheme = new Dictionary<String, Integer[2][]> {
    { "RSA", {{0, 0}, {1, 1}} },
    { "DSA", {{0, 1}, {1, 2}, {2, 3}, {3, 0}} },
}

Dies ist nur ein Beispiel, natürlich, — nicht bekommen, syntax und zahlen ernst.

Wenn Sie überprüfen möchten, wenn Sie einen RSA-publicKey, und einen RSA-privateKey gehören zusammen, Sie können den folgenden code verwenden:

RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
return rsaPublicKey.getModulus().equals( rsaPrivateKey.getModulus() )
    && BigInteger.valueOf( 2 ).modPow( rsaPublicKey.getPublicExponent()
    .multiply( rsaPrivateKey.getPrivateExponent() ).subtract( BigInteger.ONE ),
    rsaPublicKey.getModulus() ).equals( BigInteger.ONE );

Ich bin auf der Suche nach einer ähnlichen Lösung für die EG...

Indem wir jetzt schon einen Weg gefunden, für ECC:
Es ist allerdings ein wenig komplizierter:

ECPublicKey pk = (ECPublicKey) publicKey;
ECPrivateKey sk = (ECPrivateKey) privateKey;
ECParameterSpec pkSpec = pk.getParams(), skSpec = sk.getParams();
EllipticCurve skCurve = skSpec.getCurve(), pkCurve = pkSpec.getCurve();
ECField skField = skCurve.getField(), pkField = pkCurve.getField();
BigInteger skA = skCurve.getA(), skB = skCurve.getB();
if ( pkSpec != skSpec //
  && ( pkSpec.getCofactor() != skSpec.getCofactor() //
    || ! pkSpec.getOrder().equals( skSpec.getOrder() ) //
    || ! pkSpec.getGenerator().equals( skSpec.getGenerator() ) //
    || pkCurve != skCurve //
    && ( ! pkCurve.getA().equals( skA ) //
      || ! pkCurve.getB().equals( skB ) //
      || skField.getFieldSize() != pkField.getFieldSize() ) ) ) //
  return false;
ECPoint w = pk.getW();
BigInteger x = w.getAffineX(), y = w.getAffineY();
if ( skField instanceof ECFieldFp ) {
  BigInteger skP = ( (ECFieldFp) skField ).getP();
  return pkField instanceof ECFieldFp && skP.equals( ( (ECFieldFp) pkField ).getP() ) //
    && y.pow( 2 ).subtract( x.pow( 3 ) ).subtract( skA.multiply( x ) ).subtract( skB ).mod( skP ).signum() == 0;
}
if ( skField instanceof ECFieldF2m ) {
  int m = ( (ECFieldF2m) skField ).getM();
  BigInteger rp = ( (ECFieldF2m) skField ).getReductionPolynomial();
  if ( ! ( pkField instanceof ECFieldF2m ) || m != ( (ECFieldF2m) skField ).getM() || ! rp.equals( ( (ECFieldF2m) skField ).getReductionPolynomial() ) )
    return false;
  BigInteger x2 = f2mReduce( f2mMultiply( x, x ), rp, m );
  return f2mReduce( f2mSum( f2mMultiply( y, y ), f2mMultiply( x, y ), f2mMultiply( x, x2 ), f2mMultiply( skA, x2 ), skB ), rp, m ).signum() == 0;
}

Und hier sind die Mathe-Helfer-Funktion:

public static final BigInteger f2mSum( BigInteger ... values )
{
  if ( values.length == 0 )
    return BigInteger.ZERO;
  BigInteger result = values[ 0 ];
  for ( int i = values.length - 1; i > 0; i -- )
    result = result.xor( values[ i ] );
  return result;
}


public static final BigInteger f2mAdd( BigInteger a, BigInteger b )
{
  return a.xor( b );
}


public static final BigInteger f2mSubtract( BigInteger a, BigInteger b )
{
  return a.xor( b );
}


public static final BigInteger f2mMultiply( BigInteger a, BigInteger b )
{
  BigInteger result = BigInteger.ZERO, sparse, full;
  if ( a.bitCount() > b.bitCount() ) {
    sparse = b;
    full = a;
  } else {
    sparse = b;
    full = a;
  }
  for ( int i = sparse.bitLength(); i >= 0; i -- )
    if ( sparse.testBit( i ) )
      result = result.xor( full.shiftLeft( i ) );
  return result;
}


public static final BigInteger f2mReduce( BigInteger input, BigInteger reductionPolynom, int bitLength )
{
  while ( input.bitLength() > bitLength )
    input = input.xor( reductionPolynom.shiftLeft( input.bitLength() - reductionPolynom.bitLength() ) );
  return input;
}

Ich bin ein wenig eingerostet, aber eine kleine Hilfe ist besser als keine richtige?

Im Allgemeinen, wenn Sie einen öffentlichen/privaten Schlüssel haben, sollten Sie in der Lage sein zu verwenden, eine Chiffre zu verschlüsseln, eine kleine Menge von Daten mit nur einer Taste, und sehen, ob es erfolgreich entschlüsselt mit den anderen. Das ist brute-force-und könnte Auswirkungen auf die Leistung, kann aber geeignet sein für das, was Sie zu tun versuchen (ich würde code, aber ich bin in einer Umgebung wo ich nicht überprüfen kann, und ich will nicht, um nichts zu posten, was noch nicht getestet. Verschlüsseln und entschlüsseln von großen string in java mithilfe von RSA hat code-snippets für die Verwendung einer Chiffre, wenn Sie interessiert sind).

Auch, es sei denn, die Header manipuliert wurden in Ihrem Beispiel private Schlüssel-Datei, ist es nicht in PKCS8-format. PKCS8-Dateien werden nicht geben Sie einen Algorithmus (z.B. RSA) in der Kopfzeile, wie Sie können, verwenden verschiedene algorithmen, und damit geben Sie den Algorithmus für die Kodierung selbst.

Zusätzlich, wenn ich mich Recht erinnere, native java hat schreckliche Unterstützung für PEM. Ich glaube, Sie müssen entfernen, die die PEM-Header aus der Schlüssel-Datei und base64 Dekodieren, bevor Sie irgendetwas tun können, mit. Alternativ, wenn möglich, können Sie sicherstellen, dass Ihre keyfiles sind DER codiert ist, in welchem Fall die Taste spec Lesen sollte es ganz gut.