Develop Reference

Instance PGPPublicKey using a PGP Public Key Block

I have been given a PGP Public Key block with which I should encrypt a csv file. Using the BouncyCastle library, this is the method I am using:
public static void encryptFile(
OutputStream out,
String fileName,
PGPPublicKey encKey,
boolean armor,
boolean withIntegrityCheck)
throws IOException, NoSuchProviderException, PGPException {
Security.addProvider(new BouncyCastleProvider());
if (armor) {
out = new ArmoredOutputStream(out);
}
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
PGPCompressedDataGenerator comData = new PGPCompressedDataGenerator(PGPCompressedData.ZIP);
PGPUtil.writeFileToLiteralData(
comData.open(bOut),
PGPLiteralData.BINARY,
new File(fileName));
comData.close();
BcPGPDataEncryptorBuilder dataEncryptor = new BcPGPDataEncryptorBuilder(PGPEncryptedData.TRIPLE_DES);
dataEncryptor.setWithIntegrityPacket(withIntegrityCheck);
dataEncryptor.setSecureRandom(new SecureRandom());
PGPEncryptedDataGenerator encryptedDataGenerator = new PGPEncryptedDataGenerator(dataEncryptor);
encryptedDataGenerator.addMethod(new BcPublicKeyKeyEncryptionMethodGenerator(encKey));
byte[] bytes = bOut.toByteArray();
OutputStream cOut = encryptedDataGenerator.open(out, bytes.length);
cOut.write(bytes);
cOut.close();
out.close();
}
I am not quite sure how can I provide the arguments to this method when it comes to PGPPublicKey. How can I instantiate this object given only my Key block?

Pass your key file(assuming you have your key as file) to this method and it will return PGPPublicKey
/** The fingerprint calculator to use whenever it is needed. */
static final KeyFingerPrintCalculator FP_CALC = new BcKeyFingerprintCalculator();
// Private class method readPublicKeyFromCol
private static PGPPublicKey readPublicKeyFromCol(InputStream in)
throws Exception {
PGPPublicKeyRing pkRing = null;
PGPPublicKeyRingCollection pkCol = new PGPPublicKeyRingCollection(in, FP_CALC);
System.out.println("key ring size=" + pkCol.size());
Iterator it = pkCol.getKeyRings();
while (it.hasNext()) {
pkRing = (PGPPublicKeyRing) it.next();
Iterator pkIt = pkRing.getPublicKeys();
while (pkIt.hasNext()) {
PGPPublicKey key = (PGPPublicKey) pkIt.next();
System.out.println("Encryption key = " + key.isEncryptionKey() + ", Master key = " +
key.isMasterKey());
if (key.isEncryptionKey())
return key;
}
}
return null;
}
!!!code is copied from sample code

How To Decrypt PGP Encrypted File (Encrypted by two PGP keys. Key1 having public, private key. Key2 having only in public key) Through JAVA API

I have two PGP keys in PGP desktop.
Key1 - Created in my PGP desktop. which contains both public and private key
Key2 - Created by my client and shared with us only public key. I added key2 public key only in my PGP desktop.
Now I encrypted the file using above two keys. I can successfully decrypt the file by using PGP Desktop.
But I can not decrypt the file using Java API.
public static void decryptFile(File input, File key, char[] passwd, File destDir) throws Exception {
File destFile = null;
InputStream keyIn = new FileInputStream(key);
Security.addProvider(new BouncyCastleProvider());
InputStream is = new FileInputStream(input);
InputStream in = org.bouncycastle.openpgp.PGPUtil.getDecoderStream(is);
try {
PGPObjectFactory pgpF = new PGPObjectFactory(in);
PGPEncryptedDataList enc;
Object o = pgpF.nextObject();
if (o instanceof PGPEncryptedDataList) {
enc = (PGPEncryptedDataList) o;
} else {
enc = (PGPEncryptedDataList) pgpF.nextObject();
}
Iterator<PGPPublicKeyEncryptedData> encDataObjects = enc.getEncryptedDataObjects();
PGPPublicKeyEncryptedData encryptedData = null;
List<Long> keyIds = new LinkedList<Long>();
while (encDataObjects.hasNext()) {
encryptedData = (PGPPublicKeyEncryptedData) encDataObjects.next();
long decipheringKeyID = encryptedData.getKeyID();
System.out.println("****** Key ID ****** "+decipheringKeyID);
keyIds.add(decipheringKeyID);
}
PGPSecretKey decipheringKey = readSecretKey(keyIn, keyIds);
if (decipheringKey == null) {
throw new IllegalArgumentException("Secret key for message not found.");
}
PGPPrivateKey decryptionKey = findPrivateKey(decipheringKey, passwd);
if (decryptionKey == null) {
throw new IllegalArgumentException("Private key for message not found.");
}
PublicKeyDataDecryptorFactory dataDecryptorFactory = new BcPublicKeyDataDecryptorFactory(decryptionKey);
InputStream clear = encryptedData.getDataStream(dataDecryptorFactory);
PGPObjectFactory plainFact = new PGPObjectFactory(clear);
Object message = plainFact.nextObject();
if (message instanceof PGPCompressedData) {
PGPCompressedData cData = (PGPCompressedData) message;
PGPObjectFactory pgpFact = new PGPObjectFactory(cData.getDataStream());
message = pgpFact.nextObject();
}
if (message instanceof PGPOnePassSignatureList) {
// TODO: Verify file
message = plainFact.nextObject();
}
if (message instanceof PGPLiteralData) {
PGPLiteralData ld = (PGPLiteralData) message;
InputStream unc = ld.getInputStream();
int ch;
ByteArrayOutputStream out = new ByteArrayOutputStream();
if(ld.getFileName().toString() == null || ld.getFileName().toString().equals(""))
{
String[] fname = input.getAbsolutePath().split("\\\\");
destFile = new File(destDir,fname[fname.length-1].replace(".pgp", ""));
}
else
{
destFile = new File(destDir, ld.getFileName());
}
FileOutputStream fos = new FileOutputStream(destFile);
while ((ch = unc.read()) >= 0) {
out.write(ch);
}
byte[] returnBytes = out.toByteArray();
out.close();
fos.write(returnBytes);
fos.close();
} else {
throw new PGPException("Message is not a simple encrypted file - type unknown.");
}
} catch (Exception ex) {
ex.printStackTrace();
throw new Exception(ex.getMessage());
} finally {
if (keyIn != null) {
keyIn.close();
}
if (in != null) {
in.close();
}
if (is != null) {
is.close();
}
}
}
I am getting following error
org.bouncycastle.openpgp.PGPException: exception encrypting session info: unknown block type
at org.bouncycastle.openpgp.operator.bc.BcPublicKeyDataDecryptorFactory.recoverSessionData(Unknown Source)
at org.bouncycastle.openpgp.PGPPublicKeyEncryptedData.getDataStream(Unknown Source)
at com.pgp.util.PGPUtils.decryptFile(PGPUtils.java:312)
at com.pgp.util.PGPUtils.main(PGPUtils.java:576)
Caused by: org.bouncycastle.crypto.InvalidCipherTextException: unknown block type
at org.bouncycastle.crypto.encodings.PKCS1Encoding.decodeBlock(Unknown Source)
at org.bouncycastle.crypto.encodings.PKCS1Encoding.processBlock(Unknown Source)
at org.bouncycastle.crypto.BufferedAsymmetricBlockCipher.doFinal(Unknown Source)
... 4 more
Exception in thread "main" java.lang.Exception: exception encrypting session info: unknown block type
at com.pgp.util.PGPUtils.decryptFile(PGPUtils.java:373)
at com.pgp.util.PGPUtils.main(PGPUtils.java:576)

javax.crypto.BadPaddingException: Decryption error

Here is the error I have got when run my Encode & Decode Class.
javax.crypto.BadPaddingException: Decryption error
at sun.security.rsa.RSAPadding.unpadV15(RSAPadding.java:380)
at sun.security.rsa.RSAPadding.unpad(RSAPadding.java:291)
at com.sun.crypto.provider.RSACipher.doFinal(RSACipher.java:365)
at com.sun.crypto.provider.RSACipher.engineDoFinal(RSACipher.java:391)
at javax.crypto.Cipher.doFinal(Cipher.java:2087)
at RSAEncDecDemo.decryptData(RSAEncDecDemo.java:64)
at RSAEncDecDemo.main(RSAEncDecDemo.java:47)
java.lang.NullPointerException
at java.lang.String.<init>(String.java:556)
at RSAEncDecDemo.decryptData(RSAEncDecDemo.java:70)
at RSAEncDecDemo.main(RSAEncDecDemo.java:47)
Here is the source code of RSAEncDecDemo.java class file.
public class RSAEncDecDemo {
private static final String PUBLIC_KEY_FILE = "lk.public.key";
private static final String PRIVATE_KEY_FILE = "lk.private.key";
#SuppressWarnings("restriction")
public static void main(String[] args) throws IOException {
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();
writeStringkey(PUBLIC_KEY_FILE,new BASE64Encoder().encode(publicKey.getEncoded()));
writeStringkey(PRIVATE_KEY_FILE,new BASE64Encoder().encode(privateKey.getEncoded()));
String demoString = "123346";
RSAEncDecDemo rsa = new RSAEncDecDemo();
String decrypted = rsa.decryptData(demoString);
String msisdn = decrypted.substring(0,decrypted.indexOf("|"));
} catch (Exception e) {
e.printStackTrace();
}
}
private String decryptData(String strData) throws IOException {
byte[] data = DatatypeConverter.parseHexBinary(strData);
byte[] descryptedData = null;
try {
PrivateKey privateKey = readPrivateKeyFromFile(PRIVATE_KEY_FILE);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
descryptedData = cipher.doFinal(data);
} catch (Exception e) {
e.printStackTrace();
}
return new String(descryptedData);
}
#SuppressWarnings("restriction")
public PrivateKey readPrivateKeyFromFile(String fileName)throws IOException, NoSuchAlgorithmException,InvalidKeySpecException {
String publicK = readStringKey(fileName);
byte[] keyBytes = new BASE64Decoder().decodeBuffer(publicK);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory fact = KeyFactory.getInstance("RSA");
return fact.generatePrivate(keySpec);
}
public PrivateKey readPrivateKeyFromFileold(String fileName)throws IOException {
FileInputStream fis = null;
ObjectInputStream ois = null;
try {
fis = new FileInputStream(new File(fileName));
ois = new ObjectInputStream(fis);
BigInteger modulus = (BigInteger) ois.readObject();
BigInteger exponent = (BigInteger) ois.readObject();
RSAPrivateKeySpec rsaPrivateKeySpec = new RSAPrivateKeySpec(modulus, exponent);
KeyFactory fact = KeyFactory.getInstance("RSA");
PrivateKey privateKey = fact.generatePrivate(rsaPrivateKeySpec);
return privateKey;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (ois != null) {
ois.close();
if (fis != null) {
fis.close();
}
}
}
return null;
}
public static void writeStringkey(String fileName, String data) {
try {
FileWriter out = new FileWriter(new File(fileName));
out.write(data);
out.close();
} catch (IOException e) {
}
}
public static String readStringKey(String fileName) {
BufferedReader reader = null;
StringBuffer fileData = null;
try {
fileData = new StringBuffer(2048);
reader = new BufferedReader(new FileReader(fileName));
char[] buf = new char[1024];
int numRead = 0;
while ((numRead = reader.read(buf)) != -1) {
String readData = String.valueOf(buf, 0, numRead);
fileData.append(readData);
buf = new char[1024];
}
reader.close();
} catch (Exception e) {
} finally {
if (reader != null) {
reader = null;
}
}
return fileData.toString();
}
}
Where is mistaken point.? Decryption part is give that error.
Whole class uploaded here
LINK TO SOURCE CODE
-Thanks

In principle a ciphertext should be indistinguishable from random. That said, ciphers do place constraints on the domain (size and possible values). In the case of RSA PKCS#1 - which is the default mode for "RSA" within the Oracle provider - the output must be precisely the key size (in bytes). Furthermore, the value must be smaller than the modulus.
Now assume that you've just shown us a demo value (because the exception doesn't match the input) and the size of the ciphertext is correct. In that case you would get an unpadding exception when either:
the private key doesn't match the public key used;
the wrong padding mode (e.g. OAEP) was used to create the ciphertext;
the ciphertext was altered (e.g. due to an invalid conversion to a string).
You would have to try until you find the culprit, without the required information we cannot test this for you.

Chacha Encryption in android using sponge castle

I simply want to encrypt and decrypt text in Android using ChaCha20.
I have found some example but can't find a solution to make it in the right way. I want ChaCha encryption. Can someOne guide me how could I achieve it. I tried modifying these code a lot.
SecurityUtil
public class SecurityUtil extends Properties {
public String decrypt(String name, String keyString)
throws Exception {
BlowfishEngine engine = new BlowfishEngine();
PaddedBufferedBlockCipher cipher =
new PaddedBufferedBlockCipher(engine);
StringBuffer result = new StringBuffer();
KeyParameter key = new KeyParameter(keyString.getBytes());
cipher.init(false, key);
byte out[] = Base64.decode(name);
byte out2[] = new byte[cipher.getOutputSize(out.length)];
int len2 = cipher.processBytes(out, 0, out.length, out2, 0);
cipher.doFinal(out2, len2);
String s2 = new String(out2);
for (int i = 0; i < s2.length(); i++) {
char c = s2.charAt(i);
if (c != 0) {
result.append(c);
}
}
return result.toString();
}
public String encrypt(String value, String keyString)
throws Exception {
BlowfishEngine engine = new BlowfishEngine();
PaddedBufferedBlockCipher cipher =
new PaddedBufferedBlockCipher(engine);
KeyParameter key = new KeyParameter(keyString.getBytes());
cipher.init(true, key);
byte in[] = value.getBytes();
byte out[] = new byte[cipher.getOutputSize(in.length)];
int len1 = cipher.processBytes(in, 0, in.length, out, 0);
try {
cipher.doFinal(out, len1);
} catch (CryptoException e) {
e.printStackTrace();
throw new Exception(e.getMessage());
}
String s = new String(Base64.encode(out));
return s;
}
}
I have tried changing BlowfishEngine to ChaChaEngine but It is a class not an interface. And tried a lot more way.
AESWrapper
public class AESWrapper {
public byte[] encrypt(byte[] plainData, byte[] key) throws AESEncryptionFailedException {
PaddedBufferedBlockCipher paddedBufferedBlockCipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(new AESEngine()), new PKCS7Padding());
ParametersWithRandom params = new ParametersWithRandom(new KeyParameter(key));
paddedBufferedBlockCipher.init(true, params);
byte[] cipherText = new byte[paddedBufferedBlockCipher.getOutputSize(plainData.length)];
int val = paddedBufferedBlockCipher.processBytes(plainData, 0, plainData.length, cipherText, 0);
try {
paddedBufferedBlockCipher.doFinal(cipherText, val);
} catch (DataLengthException e) {
throw new AESEncryptionFailedException("AES Encryption failed due to data length mismatch");
} catch (IllegalStateException e) {
throw new AESEncryptionFailedException("AES Encryption failed");
} catch (InvalidCipherTextException e) {
throw new AESEncryptionFailedException("AES Encryption failed due to invalid cipher text");
}
return cipherText;
}
public byte[] decrypt(byte[] cipherText, byte[] key) throws AESDecryptionFailedException {
PaddedBufferedBlockCipher paddedBufferedBlockCipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(new AESEngine()), new PKCS7Padding());
ParametersWithRandom params = new ParametersWithRandom(new KeyParameter(key));
paddedBufferedBlockCipher.init(false, params);
byte[] plainText = new byte[paddedBufferedBlockCipher.getOutputSize(cipherText.length)];
int val = paddedBufferedBlockCipher.processBytes(cipherText, 0, cipherText.length, plainText, 0);
try {
int len = paddedBufferedBlockCipher.doFinal(plainText, val);
byte[] decryptedData = new byte[val + len];
System.arraycopy(plainText, 0, decryptedData, 0, len + val);
return decryptedData;
} catch (DataLengthException e) {
throw new AESDecryptionFailedException("AES Decryption failed due to data length mismatch");
} catch (IllegalStateException e) {
throw new AESDecryptionFailedException("AES Decryption failed");
} catch (InvalidCipherTextException e) {
throw new AESDecryptionFailedException("AES Decryption failed due to invalid cipher text");
}
}
}
Is there an easy way to simply encrypt and decrypt text using chacha.

Decrypted string not the same as pre encrypted string

I have the following pieces of code:
Globals
public static PublicKey pubKey;
public static PrivateKey privKey;
public static Cipher cip;
Main
public static void main(String[] args) throws Exception {
//Generate the keys
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
kpg.initialize(1024);
KeyPair kp = kpg.genKeyPair();
Key publicKey = kp.getPublic();
Key privateKey = kp.getPrivate();
KeyFactory fact = KeyFactory.getInstance("RSA");
cip = Cipher.getInstance("RSA/ECB/NoPadding");
// Store Public Key.
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(
publicKey.getEncoded());
FileOutputStream fos = new FileOutputStream("public.key");
fos.write(x509EncodedKeySpec.getEncoded());
fos.close();
// Store Private Key.
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
privateKey.getEncoded());
fos = new FileOutputStream("private.key");
fos.write(pkcs8EncodedKeySpec.getEncoded());
fos.close();
//Get the public and private keys out of their files
getPubAndPrivateKey();
//Check if the keys gotten out of the files are the same as the generated files (this returns truetrue)
System.out.print(publicKey.equals(pubKey));
System.out.print(privateKey.equals(privKey));
byte[] text = "This is my super secret secret".getBytes();
encryptToFile("encrypted.txt", text );
decryptToFile("encrypted.txt", "decrypted.txt");
}
Getting the keys from the files
private static void getPubAndPrivateKey() throws IOException, Exception {
// Read Public Key.
File filePublicKey = new File("public.key");
FileInputStream fis = new FileInputStream("public.key");
byte[] encodedPublicKey = new byte[(int) filePublicKey.length()];
fis.read(encodedPublicKey);
fis.close();
// Read Private Key.
File filePrivateKey = new File("private.key");
fis = new FileInputStream("private.key");
byte[] encodedPrivateKey = new byte[(int) filePrivateKey.length()];
fis.read(encodedPrivateKey);
fis.close();
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
encodedPublicKey);
pubKey = keyFactory.generatePublic(publicKeySpec);
PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
encodedPrivateKey);
privKey = keyFactory.generatePrivate(privateKeySpec);
}
Encrypting
public static void encryptToFile(String fileName, byte[] data)
throws IOException {
try {
cip.init(Cipher.ENCRYPT_MODE, privKey);
byte[] cipherData = cip.doFinal(data);
String encryptedData = cipherData.toString();
BufferedWriter out = new BufferedWriter(new FileWriter(fileName));
out.write(encryptedData);
out.close();
} catch (Exception e) {
throw new RuntimeException("Spurious serialisation error", e);
}
}
Decrypting
private static void decryptToFile(String string, String string2)
throws Exception {
try {
File encryptedFile = new File("encrypted.txt");
byte[] encrypted = getContents(encryptedFile).getBytes();
cip = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cip.init(Cipher.DECRYPT_MODE, pubKey);
byte[] cipherData = cip.doFinal(encrypted);
String decryptedData = cipherData.toString();
BufferedWriter out = new BufferedWriter(new FileWriter(
"decrypted.txt"));
out.write(decryptedData);
out.close();
} catch (Exception e) {
throw e;
}
}
Things I already checked
The data used in the decryption is the same as in the encrypted file
The generated keys are the same as the ones gotten from the file
The encryption and decryption both don't give errors
Results
Original string:
My super secret secret
The encryption results in:
[B#1747b17
The decryption results in:
[B#91a4fb

If you print out a byte array via toString() method you are getting a value that is totally independent of the content.
Therefore the values [B#1747b17 [B#91a4fb are just garbage that does not tell you anything.
If you want to print the content of a byte array convert it to Base64 or hex-string.
System.out.println(new sun.misc.BASE64Encoder().encode(myByteArray));
A hex string can be generated by using org.apache.commons.codec.binary.Hex from Apache Commons Codec library.

I agree with the above answer.
I would like to add that in your case, you can simply use FileOutputStream, write the bytes to a file -
For example:
public static void encryptToFile(String fileName, byte[] data)
throws IOException {
FileOutputStream out = null;
try {
cip.init(Cipher.ENCRYPT_MODE, privKey);
byte[] cipherData = cip.doFinal(data);
out = new FileOutputStream(fileName);
out.write(cipherData);
} catch (Exception e) {
throw new RuntimeException("Spurious serialisation error", e);
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException ex) {
}
}
}
}