Heavy use of public key

Question

I need to encrypt a lot of (maybe mllions) pieces of data (each 32 byte long, random looking) using a PublicKey. Each piece must be encrypted separately (since I need the possibility to decrypt it alone).
This way it is possible to obtain many plaintext-ciphertext pairs using my program. Is it too risky? Of course, cracking the program would reveal the PublicKey anyway, so maybe my whole problem is just stupid.....
I found out different ways, e.g., encrypting this way just a couple of random SecretKeys, which will be used to encrypt the pieces of data mentioned above. The storage overhead would be small, the computation could be even faster (using symmetrical cipher instead of RSA), but it's more complicated to maintain.... and loosing somehow the encrypted random SecretKeys would be a disaster.
null

Answer 1

I tried to figure out, how it works....
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import java.security.spec.*;
import sun.misc.*;
public class PBEEncryptDataString
    static public class EncryptionException extends Exception
        private EncryptionException(String text, Exception chain)
            super(text, chain);
    private static final String PROVIDER = "BC";
    private static final String ALGORITHM = "PBEWITHSHA-1AND192BITAES-CBC-BC";
    public PBEEncryptDataString(String passphrase, byte[] salt, int iterationCount, String characterEncoding) throws EncryptionException
        assert(passphrase != null);
        assert(passphrase.length() >= 6);
        assert(salt != null);
        assert((iterationCount > 6) && (iterationCount < 20));
        assert(characterEncoding != null);
        try
            PBEParameterSpec params = new PBEParameterSpec(salt, iterationCount);
            KeySpec keySpec = new PBEKeySpec(passphrase.toCharArray());
            SecretKey key = SecretKeyFactory.getInstance(ALGORITHM, PROVIDER).generateSecret(keySpec);
            this.characterEncoding = characterEncoding;
            this.encryptCipher = Cipher.getInstance(ALGORITHM, PROVIDER);
            this.encryptCipher.init(javax.crypto.Cipher.ENCRYPT_MODE, key, params);
            this.decryptCipher = Cipher.getInstance(ALGORITHM, PROVIDER);
            this.decryptCipher.init(javax.crypto.Cipher.DECRYPT_MODE, key, params);
        catch (Exception e)
            throw new EncryptionException("Problem constucting " + this.getClass().getName(), e);
    synchronized public byte[] encrypt(String dataString) throws EncryptionException
        assert dataString != null;
        try
            byte[] dataStringBytes = dataString.getBytes(characterEncoding);
            byte[] encryptedDataStringBytes = this.encryptCipher.doFinal(dataStringBytes);
            return encryptedDataStringBytes;
        catch (Exception e)
            throw new EncryptionException("Problem encrypting string", e);
    synchronized public String decrypt(byte[] encryptedDataStringBytes) throws EncryptionException
        assert encryptedDataStringBytes != null;
        try
            byte[] dataStringBytes = this.decryptCipher.doFinal(encryptedDataStringBytes);
            String recoveredDataString = new String(dataStringBytes, characterEncoding);
            return recoveredDataString;
        catch (Exception e)
            throw new EncryptionException("Problem decrypting string", e);
    public static void main(String[] args)
        try
            Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
            final byte[] salt =
            {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, };
            PBEEncryptDataString dataStringEncryptAgent = new PBEEncryptDataString("The Password - make if fairly long so that there is lots and lots of entropy", salt, 1000, "UTF-8");
            // Get the dataString to encrypt from the command line
            String dataString = (args.length == 0)? "The quick brown fox jumps over the lazy dog." : args[0];
            System.out.println("Data string ....................[" + dataString + "]");
            // Encrypt the data
            byte[] encryptedDataStringBytes = dataStringEncryptAgent.encrypt(dataString);
            BASE64Encoder base64Encoder = new BASE64Encoder();
            System.out.println("Encoded encrypted data string ..[" + base64Encoder.encode(encryptedDataStringBytes) + "]");
            // Decrypt the data
            String recoveredDataString = dataStringEncryptAgent.decrypt(encryptedDataStringBytes);
            System.out.println("Recovered data string ..........[" + recoveredDataString + "]");
        catch (Exception e)
            e.printStackTrace(System.out);
    private String characterEncoding;
    private Cipher encryptCipher;
    private Cipher decryptCipher;
}Here, to show the basic approch, I have used a fixed IV but one can use a random IV and write it as a prefix to the output so that it can be used in the decryption process. Schneier has shown that this in no way compromises the security of the approach BUT, of course, it does increase the effective length of the encrypted data.