PublicKey einlesen und weiter verarbeiten

[Christian Thormeier]

Hallo,

Hatte irgendwann irgendjemand ansatzweise eine Antwort zu diesem Problem?

Ich habe einen Public Key und die Signatur vom private Key und möchte einen verifySignature ausführen. Damit ich das durchführen kann, muss ich unter anderem auch den unten stehenden PEM-File (PublicKey) einlesen. Hier liegt mein Problem. Das Einlesen und Erzeugen des PublicKey-Objekts habe ich in eine extra Methode gepackt, um später diese weiter zu verarbeiten.
Bei der Verarbeitung erhalte ich immer diese Meldung. Es nervt langsam.

java.security.spec.InvalidKeySpecException: java.security.InvalidKeyException: invalid key format

Der Code sieht so aus:

public static PublicKey getPublicKeyFromPEMFile(String fn) {   
      //fn = keyfile.pem   
      File pubKeyFile = null;
      PublicKey pubKey = null;
   try {
      // read public key DER file
        pubKeyFile = new File(fn);
        DataInputStream dis = new DataInputStream(new FileInputStream(pubKeyFile));
        byte[] pubKeyBytes = new byte[(int)pubKeyFile.length()];
        dis.readFully(pubKeyBytes);       
        dis.close();
   KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        X509EncodedKeySpec pubSpec = new X509EncodedKeySpec(pubKeyBytes);
        pubKey = keyFactory.generatePublic(pubSpec);
   } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
   } catch (NoSuchAlgorithmException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
   } catch (InvalidKeySpecException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
   }
         return pubKey;
}

Das Bsp. Pub KeyFile:

-----BEGIN PUBLIC KEY-----
MEowDQYJKoZIhvcNAQEBBQADOQAwNgIvNMCE91/Wbe4YoIQva8+f38gQm6EIVbyY
bgTouD/XRl+90W7Zj/Dn+cKSB4dKcdcCAwEAAQ==
-----END PUBLIC KEY-----

[Christian Thormeier]

Hier die Lösung:

<code>
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.io.File;

import org.bouncycastle.jce.provider.BouncyCastleProvider ;
import org.bouncycastle.util.encoders.Hex;

public class VerifyXXXXXXX {

/**
* Ueberprueft ob die Anwendung XXXXXX aus den iframe innerhalb der Anwendung Virtbus aufgerufen wurde.
*
* @param signatureToVerify zu verifizierende Signatur
* @param http_referer URL des umgebenen IFrame see: $_SERVER['HTTP_REFERER']
* @param clientip Ip des Clients
* @param application Passphrase zur eindeutigen Bestimmung der Anwendung
* @param expire timestamp, für das Ablaufen der Session see: $_GET['expire']
* @param filename DER-KEY-File
* @return true = Anwendung ist im iframe, false = Anwendung wurde ausserhalb der Anwendung aufgerufen
*/
public boolean runApp(String signatureToVerify, String http_referer, String clientip, String application, String expire, String filename) {

boolean p_return = false;

String data_combination = http_referer + clientip + application + expire;
byte[] data = data_combination.getBytes();

try {
RSAPublicKey pub = getPubKeyFromFile(filename);
p_return = verifySignature(pub, data, Hex.decode(signatureToVerify),"SHA1WithRSA", "BC");
return p_return;
} catch (Exception e) {
e.printStackTrace();
}
return p_return;
}

/**
* Liefert ein RSA Public Key Objekt zurueck.
*
* @param filename DER-KEY-File
* @return RSA Public Key Objekt
*/
protected RSAPublicKey getPubKeyFromFile(String filename) {

File pubKeyFile = null;
byte[] keyBytes = null;
RSAPublicKey pubKey = null;
X509EncodedKeySpec keySpec = null;

try {
// read public key DER file
pubKeyFile = new File(filename);
DataInputStream dis = new DataInputStream(new FileInputStream(pubKeyFile));
keyBytes = new byte[(int) pubKeyFile.length()];
dis.readFully(keyBytes);
dis.close();
keySpec = new X509EncodedKeySpec(keyBytes);
java.security.Security.addProvider(new BouncyCastleProvider());
pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(
keySpec);
return pubKey;

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return pubKey;

}

/**
* Verifies the signature for the given buffer of bytes using the public key.
*
* @param key
* eingelesener Key als PublicKey-Objekt
* @param buffer
* zu vergleichende Daten
* @param signature
* Vergleichssignatur
* @param algorithm
* Verschluesselungsalgorithmus der Signatur
* @param provider
* Provider, z.B.: "<code>BC</code>"
*/
protected boolean verifySignature(PublicKey key, byte[] buffer,
byte[] signature, String algorithm, String provider) {
try {
Signature sig = Signature.getInstance(algorithm, provider);
sig.initVerify(key);
sig.update(buffer, 0, buffer.length);
return sig.verify(signature);
} catch (SignatureException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchProviderException e) {
e.printStackTrace();
}
return false;
}
}

</code>