RSA Decrypt Frage

[geqoo]

Hallo,

ich sitze hier gerade an meinem Programm, was RSA ver- und entschlüsseln können soll. Die Verschlüsselungsmethode sieht bisher so aus:

	public static String encrypt(String to_encrypt) {
		// Get an instance of the RSA key generator
		KeyPairGenerator kpg;
		try {
			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		    RSAPrivateKeySpec privKeySpec = new RSAPrivateKeySpec(new BigInteger("geheim1"), new BigInteger("geheim2"));
			RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger("geheim1"), new BigInteger("geheim3"));
			RSAPublicKey pubKey = (RSAPublicKey) keyFactory.generatePublic(pubKeySpec);
		    RSAPrivateKey privKey = (RSAPrivateKey) keyFactory.generatePrivate(privKeySpec);

		    Cipher cipher = Cipher.getInstance("RSA");
		    cipher.init(Cipher.ENCRYPT_MODE, pubKey);

		    // Encrypt that message using a new SealedObject and the Cipher we created before
		    SealedObject myEncyptedMessage = new SealedObject(to_encrypt, cipher);

		    Cipher decCipher = Cipher.getInstance("RSA");
		    decCipher.init(Cipher.DECRYPT_MODE, privKey);

		    // Tell the SealedObject we created before to decrypt the data and return it
		    String message = (String)myEncyptedMessage.getObject(decCipher);
		    System.out.println("foo = "+myEncyptedMessage.toString());

		    return message;
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (BadPaddingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return "";
	}

So wie ich das Beispielprogramm verstanden habe, macht das SealedObject die Verschlüsselung und danach kann man dann auch wieder eine Entschlüsselung durchführen (funktioniert auch soweit).
Meine Problem ist jetzt aber: Da ich einen verschlüsselten String zugeschickt bekomme, kann ich nicht anfangen zu verschlüsseln, sondern muss diesen ja logischerweise entschlüsseln.

Frage ist: Wie mache ich das genau?

 

[Loep]

Weil's um das gleiche Thema geht, hänge ich mich mal mit ein...

Ich möchte den Inhalt einer Datei asymmetrisch verschlüsseln und bin auf Code gestoßen, der dies machen soll. Aber ich bekomme immer java.security.InvalidKeyException: Invalid RSA public key und finde den Fehler nicht. Achja, das RSA Keypaar habe ich mit PuTTYgen erstellt.

package crypto;

import java.io.*;
import java.security.*;
import java.security.spec.*;

import javax.crypto.*;
import javax.crypto.spec.*;

/**
 * Utility class for encrypting/decrypting files.
 * 
 * @author Michael Lones
 */
public class FileEncryption {

	public static final int AES_Key_Size = 256;

	Cipher pkCipher, aesCipher;
	byte[] aesKey;
	SecretKeySpec aeskeySpec;

	public static void main(String[] args) {
		File storedAesKey = new File("aes.key");
		File storedRsaPrivateKey = new File("key.pub");
		File input = new File("build.xml");
		File outputEncoded = new File("decoded.dec");
		File outputDecoded = new File("encoded.enc");
		try {
			FileEncryption rsa = new FileEncryption();
			rsa.generateAndsaveKeypair();
			rsa.makeKey();
			rsa.saveKey(storedAesKey, storedRsaPrivateKey);
			rsa.encrypt(input, outputEncoded);
			rsa.decrypt(outputEncoded, outputDecoded);
		} catch (GeneralSecurityException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Constructor: creates ciphers
	 */
	public FileEncryption() throws GeneralSecurityException {
		// create RSA public key cipher
		pkCipher = Cipher.getInstance("RSA");
		// create AES shared key cipher
		aesCipher = Cipher.getInstance("AES");
	}

	/**
	 * Creates a new AES key
	 */
	public void makeKey() throws NoSuchAlgorithmException {
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(AES_Key_Size);
		SecretKey key = kgen.generateKey();
		aesKey = key.getEncoded();
		aeskeySpec = new SecretKeySpec(aesKey, "AES");
	}

	/**
	 * Decrypts an AES key from a file using an RSA private key
	 */
	public void loadKey(File in, File privateKeyFile) throws GeneralSecurityException, IOException {
		// read private key to be used to decrypt the AES key
		byte[] encodedKey = new byte[(int) privateKeyFile.length()];
		new FileInputStream(privateKeyFile).read(encodedKey);

		// create private key
		PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedKey);
		KeyFactory kf = KeyFactory.getInstance("RSA");
		PrivateKey pk = kf.generatePrivate(privateKeySpec);

		// read AES key
		pkCipher.init(Cipher.DECRYPT_MODE, pk);
		aesKey = new byte[AES_Key_Size / 8];
		CipherInputStream is = new CipherInputStream(new FileInputStream(in), pkCipher);
		is.read(aesKey);
		aeskeySpec = new SecretKeySpec(aesKey, "AES");
	}

	/**
	 * Encrypts the AES key to a file using an RSA public key
	 */
	public void saveKey(File out, File publicKeyFile) throws IOException, GeneralSecurityException {
		// read public key to be used to encrypt the AES key
		byte[] encodedKey = new byte[(int) publicKeyFile.length()];
		new FileInputStream(publicKeyFile).read(encodedKey);

		// create public key
		X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedKey);
		KeyFactory kf = KeyFactory.getInstance("RSA");
		PublicKey pk = kf.generatePublic(publicKeySpec);

		// write AES key
		pkCipher.init(Cipher.ENCRYPT_MODE, pk);
		CipherOutputStream os = new CipherOutputStream(new FileOutputStream(out), pkCipher);
		os.write(aesKey);
		os.close();
	}

	/**
	 * Encrypts and then copies the contents of a given file.
	 */
	public void encrypt(File in, File out) throws IOException, InvalidKeyException {
		aesCipher.init(Cipher.ENCRYPT_MODE, aeskeySpec);

		FileInputStream is = new FileInputStream(in);
		CipherOutputStream os = new CipherOutputStream(new FileOutputStream(out), aesCipher);

		copy(is, os);

		os.close();
	}

	/**
	 * Decrypts and then copies the contents of a given file.
	 */
	public void decrypt(File in, File out) throws IOException, InvalidKeyException {
		aesCipher.init(Cipher.DECRYPT_MODE, aeskeySpec);

		CipherInputStream is = new CipherInputStream(new FileInputStream(in), aesCipher);
		FileOutputStream os = new FileOutputStream(out);

		copy(is, os);

		is.close();
		os.close();
	}

	/**
	 * Copies a stream.
	 */
	private void copy(InputStream is, OutputStream os) throws IOException {
		int i;
		byte[] b = new byte[1024];
		while ((i = is.read(b)) != -1) {
			os.write(b, 0, i);
		}
	}

	public void generateAndsaveKeypair() {
		/* Generate Public and Private Keys */
		try {
			KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA", "SUN");
			SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
			keyGen.initialize(1024, random);
			KeyPair pair = keyGen.generateKeyPair();
			PrivateKey priv = pair.getPrivate();
			PublicKey pub = pair.getPublic();
			/* save the public key in a file */
			byte[] publickey = pub.getEncoded();
			FileOutputStream publickeyfos = new FileOutputStream("key.pub");
			publickeyfos.write(publickey);
			publickeyfos.close();
			/* save the private key in a file */
			byte[] privatekey = priv.getEncoded();
			FileOutputStream privatekeyfos = new FileOutputStream("key.prv");
			privatekeyfos.write(privatekey);
			privatekeyfos.close();
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchProviderException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

Ich nehme auch gerne andere Copy&Paste Lösungen zur asymmetrischen Ver-/Entschlüsselung, da ich mich mit den Thema nicht unbedingt intensiv auseinander setzen möchte (gibt noch andere Baustellen 😉).

 

[irgendjemand]

@geqoo

verstehe nicht wirklich das problem ... du musst doch nur alles was mit VERschlüsseln zu tun hat rausschmeißen ... was überbelibt ist dann zum ENTschlüsseln ... oder hakt es bei der umwandlung des Strings in binär-daten ?

@Loep

kompletter StackTrace !!!

es ist zwar schön das du im gegensatz zu anderen gesagt hast was genau als fehler geflogen kommt ... aber wir wissen weder WO noch genau was schief gelaufen ist ...
mal bitte den kompletten StackTrace posten ...

 

[JavaProfi]

Hallo GEQOO,

RSA ist ein asymetrisches Verfahren, welches auf Primzahlen, dem Faktorisierungsproblem und modularer Arithmetik basiert. Insofern benötigst du einen öffentlichen und eine privaten Schlüssel.

Nehmen wir an ich will dir etwas verschlüsselt schicken.

Dazu hast du den privaten und öffentlichen Schlüssel erzeugt. Den privaten Schlüssel hältst du unter allen Umständen geheim. Den öffentlichen Schlüssel gibst du mir. Mit dem öffentlichen Schlüssel von dir verschlüssele ich nun meine Nachricht, die ich an dich senden will. Die verschlüsselte Nachricht übersende ich an dich.

Du nimmst zur Entschlüsselung den privaten Schlüssel, den ja nur du kennst.
Damit ist es nur dir möglich die Nachricht zu entschlüsseln. Aufgrund des Faktorisierungsproblems bei großen Primzahlen kann ich anhand des öffentlichen Schlüssels (der im Übrigen ein Tupel ist) den privaten Schlüssel nicht herausfinden (zumindest nicht in effizienter Rechenzeit) .

Gruß
Der JavaProfi