bouncy castle open gpg2 public key

Question

I tried to implement the solution here https://stackoverflow.com/a/33216302/4727842. My code looks like this

private fun readPublicKey(input: InputStream): PGPPublicKey {
    val publicKey = PGPPublicKeyRingCollection(PGPUtil.getDecoderStream(input), BcKeyFingerprintCalculator())
    var key: PGPPublicKey? = null

    publicKey.keyRings.forEach { ring: PGPPublicKeyRing ->
        ring.publicKeys.forEach { k: PGPPublicKey ->
            if (k.isEncryptionKey) {
                key = k
            }
        }
    }

    if (key == null) {
        throw IllegalArgumentException("Can't find encryption key input key ring.")
    } else {
        return key!!
    }
}

private fun encrypt(file: File): String {
    val input = IOUtils.toInputStream("pub.asc", "UTF-8")
    val key = readPublicKey(input)

    Security.addProvider(BouncyCastleProvider())

    val out = ByteArrayOutputStream()
    val compressor = PGPCompressedDataGenerator(PGPCompressedData.ZIP)

    PGPUtil.writeFileToLiteralData(compressor.open(out), PGPLiteralData.BINARY, file)
    compressor.close()

    val builder = BcPGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.TRIPLE_DES)
    val generator = PGPEncryptedDataGenerator(builder.setSecureRandom(SecureRandom()))

    generator.addMethod(BcPublicKeyKeyEncryptionMethodGenerator(key))

    return String(out.toByteArray())
}

Using the gpg cli (v2.2.15), after generating a key, I output the asc file.

gpg -ab -o ./pub.asc

its contents look like this

Then with the line

val input = IOUtils.toInputStream("pub.asc", "UTF-8")

I attempted to run. It output the message "Can't find encryption key input key ring." after failing to extract a key. After debugging I saw that publicKey.keyRings size was 0.

I didn't understand the situation since the linked guide seems to advocate using the .asc file for encrypting when I thought it was for signing. I don't know much about PGP but I thought those were different steps and that maybe signing was not necessary for my use case.

So, I tried exporting the public key

gpg --export -a "User" > public.key

containing

and ran with

val input = IOUtils.toInputStream("public.key", "UTF-8")

This yielded no change. bouncycastle found no keys in my public key file. I then saw that since I am using gpg2 there are differences in how key rings are handled. I found a solution to convert a .pkr to a .kbx here https://stackoverflow.com/a/34221494/4727842 but at this point this has become woefully complicated. I don't know the difference between a public key ring and a public key. I don't know why the first example used a .asc file as a suposedly valid keyring. I especially don't know why it is so hard to create a bouncycastle PGPPublicKey object from my public.key file.

@JamesKPolk I am trying to encrypt files with pgp. I am unable to provide a public key that bouncy castle will accept as outlined above. — Grayden Hormes, May 21 '19 at 17:51

score 1 · Answer 1 · answered Feb 11 '20 at 21:24

If you just want to do proper en-/decryption use bouncy-gpg (shameless plug: I am the author).

Also do not use 3DES, it is dead Slow and not the most modern algorithm (though it is still considered secure, AFAIK).

You export the public key via gpg --export -a me@example.com.

You manage keys using the InMemoryKeyring (see here for details):

public static KeyringConfig keyringConfigInMemoryForKeys(final String exportedPubKey, final String exportedPrivateKey, final String passphrase) throws IOException, PGPException {

   final InMemoryKeyring keyring = KeyringConfigs.forGpgExportedKeys(KeyringConfigCallbacks.withPassword(passphrase);

       keyring.addPublicKey(exportedPubKey.getBytes("US-ASCII"));
// you can add many more public keys

       // if you only want to encrypt you do not need a private key and can ignore this line
keyring.addSecretKey(exportedPrivateKey.getBytes("US-ASCII"));
// you can add many more private keys

return keyring;
}


final String original_message = "I love deadlines. I like the whooshing sound they make as they fly by. Douglas Adams";

// Most likely you will use  one of the KeyringConfigs.... methods.
KeyringConfig keyringConfigOfSender = keyringConfigInMemoryForKeys(..); // TODO - here comes your code to get keys

ByteArrayOutputStream result = new ByteArrayOutputStream();

try (
    BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(result);

    final OutputStream outputStream = BouncyGPG
        .encryptToStream()
        .withConfig(keyringConfigOfSender)
        .withStrongAlgorithms()
        .toRecipients("recipient@example.com", "sender@example.com") // TODO - also your job to set the recipients 
        .andSignWith("sender@example.com") // TODO - same here
        .binaryOutput()
        .andWriteTo(bufferedOutputStream);
    // Maybe read a file or a webservice?
    final ByteArrayInputStream is = new ByteArrayInputStream(original_message.getBytes())
) {
  Streams.pipeAll(is, outputStream);
// It is very important that outputStream is closed before the result stream is read.
// The reason is that GPG writes the signature at the end of the stream.
// This is triggered by closing the stream.
// In this example outputStream is closed via the try-with-resources mechanism of Java
}

result.close();
byte[] chipertext = result.toByteArray();

score 0 · Answer 2 · answered Apr 04 '22 at 17:57

You can use PGPainless for that (another shameless plug - Author here as well :P):

        // Prepare keys
        // Required by the sender
        PGPSecretKeyRing keyAlice = PGPainless.readKeyRing().secretKeyRing(ALICE_KEY);
        PGPPublicKeyRing certificateBob = PGPainless.readKeyRing().publicKeyRing(BOB_CERT);
        SecretKeyRingProtector protectorAlice = SecretKeyRingProtector.unprotectedKeys();

        // Required by the recipient
        PGPSecretKeyRing keyBob = PGPainless.readKeyRing().secretKeyRing(BOB_KEY);
        PGPPublicKeyRing certificateAlice = PGPainless.readKeyRing().publicKeyRing(ALICE_CERT);
        SecretKeyRingProtector protectorBob = SecretKeyRingProtector.unprotectedKeys();

        // plaintext message to encrypt
        String message = "Hello, World!\n";
        ByteArrayOutputStream ciphertext = new ByteArrayOutputStream();
        // Encrypt and sign
        EncryptionStream encryptor = PGPainless.encryptAndOrSign()
                .onOutputStream(ciphertext)
                .withOptions(ProducerOptions.signAndEncrypt(
                        // we want to encrypt communication (affects key selection based on key flags)
                        EncryptionOptions.encryptCommunications()
                                .addRecipient(certificateBob)
                                .addRecipient(certificateAlice),
                        new SigningOptions()
                                .addInlineSignature(protectorAlice, keyAlice, DocumentSignatureType.CANONICAL_TEXT_DOCUMENT)
                        ).setAsciiArmor(true)
                );

        // Pipe data trough and CLOSE the stream (important)
        Streams.pipeAll(new ByteArrayInputStream(message.getBytes(StandardCharsets.UTF_8)), encryptor);
        encryptor.close();

        // Encrypted message
        String encryptedMessage = ciphertext.toString();

        // Decrypt and verify signatures
        DecryptionStream decryptor = PGPainless.decryptAndOrVerify()
                .onInputStream(new ByteArrayInputStream(encryptedMessage.getBytes(StandardCharsets.UTF_8)))
                .withOptions(new ConsumerOptions()
                        .addDecryptionKey(keyBob, protectorBob)
                        .addVerificationCert(certificateAlice)
                );

        ByteArrayOutputStream plaintext = new ByteArrayOutputStream();

        Streams.pipeAll(decryptor, plaintext);
        decryptor.close();

        // Check the metadata to see how the message was encrypted/signed
        OpenPgpMetadata metadata = decryptor.getResult();
        assertTrue(metadata.isEncrypted());
        assertTrue(metadata.containsVerifiedSignatureFrom(certificateAlice));
        assertEquals(message, plaintext.toString());

And if you want it even simpler, PGPainless provides a SOP (Stateless OpenPGP Protocol) API via pgpainless-sop:

SOP sop = new SOPImpl();
        
// Generate an OpenPGP key - Alternatively just read existing (unencrypted) key from disk
byte[] key = sop.generateKey()
        .userId("Alice <alice@example.org>")
        .generate()
        .getBytes();

// Extract the certificate (public key) - alternatively just read certificate from disk
byte[] cert = sop.extractCert()
        .key(key)
        .getBytes();

// Encrypt a message
byte[] message = ...
byte[] encrypted = sop.encrypt()
        .withCert(cert)
        .signWith(key)
        .plaintext(message)
        .getBytes();

// Decrypt a message
ByteArrayAndResult<DecryptionResult> messageAndVerifications = sop.decrypt()
        .verifyWith(cert)
        .withKey(key)
        .ciphertext(encrypted)
        .toByteArrayAndResult();
byte[] decrypted = messageAndVerifications.getBytes();
// Signature Verifications
DecryptionResult messageInfo = messageAndVerifications.getResult();
List<Verification> signatureVerifications = messageInfo.getVerifications();

bouncy castle open gpg2 public key

2 Answers2