Bouncy GPG 2.2.0 released

  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.
    // These are wrappers for the test.
    KeyringConfig keyringConfigOfSender = Configs
        .keyringConfigFromResourceForSender();

    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")
            .andSignWith("sender@example.com")
            .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();

    //////// Now decrypt the stream and check the signature

    // Most likely you will use  one of the KeyringConfigs.... methods.
    // These are wrappers for the test.
    KeyringConfig keyringConfigOfRecipient = Configs
        .keyringConfigFromResourceForRecipient();

    final OutputStream output = new ByteArrayOutputStream();
    try (
        final InputStream cipherTextStream = new ByteArrayInputStream(chipertext);

        final BufferedOutputStream bufferedOut = new BufferedOutputStream(output);

        final InputStream plaintextStream = BouncyGPG
            .decryptAndVerifyStream()
            .withConfig(keyringConfigOfRecipient)
            .andRequireSignatureFromAllKeys("sender@example.com")
            .fromEncryptedInputStream(cipherTextStream)

    ) {
      Streams.pipeAll(plaintextStream, bufferedOut);
    }

    output.close();
    final String decrypted_message = new String(((ByteArrayOutputStream) output).toByteArray());

    final KeyringConfig rsaKeyRing = BouncyGPG.createSimpleKeyring()
        .simpleRsaKeyRing("Juliet Capulet <juliet@example.com>", RsaLength.RSA_3072_BIT);

        final KeySpec signingSubey = KeySpecBuilder
                .newSpec(RSAForSigningKeyType.withLength(RsaLength.RSA_2048_BIT))
                .allowKeyToBeUsedTo(KeyFlag.SIGN_DATA)
                .withDefaultAlgorithms();

        final KeySpec authenticationSubey = KeySpecBuilder
                .newSpec(RSAForEncryptionKeyType.withLength(RsaLength.RSA_2048_BIT))
                .allowKeyToBeUsedTo(KeyFlag.AUTHENTICATION)
                .withDefaultAlgorithms();

        final KeySpec encryptionSubey = KeySpecBuilder
                .newSpec(RSAForEncryptionKeyType.withLength(RsaLength.RSA_2048_BIT))
                .allowKeyToBeUsedTo(KeyFlag.ENCRYPT_COMMS, KeyFlag.ENCRYPT_STORAGE)
                .withDefaultAlgorithms();

        final KeySpec masterKey = KeySpecBuilder.newSpec(
                RSAForSigningKeyType.withLength(RsaLength.RSA_3072_BIT)
        )
                .allowKeyToBeUsedTo(KeyFlag.CERTIFY_OTHER)
                .withDetailedConfiguration()
                .withPreferredSymmetricAlgorithms(
                        PGPSymmetricEncryptionAlgorithms.recommendedAlgorithms()
                )
                .withPreferredHashAlgorithms(
                        PGPHashAlgorithms.recommendedAlgorithms()
                )
                .withPreferredCompressionAlgorithms(
                        PGPCompressionAlgorithms.recommendedAlgorithms()
                )
                .withFeature(Feature.MODIFICATION_DETECTION)
                .done();

        final KeyringConfig complexKeyRing = BouncyGPG
                .createKeyring()
                .withSubKey(signingSubey)
                .withSubKey(authenticationSubey)
                .withSubKey(encryptionSubey)
                .withMasterKey(masterKey)
                .withPrimaryUserId("Juliet Capulet <juliet@example.com>")
                .withPassphrase(Passphrase.fromString("O Romeo, Romeo! Wherefore art thou Romeo?"))
                .build();

        return complexKeyRing;

        // 1. Create a new keyring with new keys
        KeyringConfig createdKeyRing = ...

        // 2. Get the persisted keys in a binary format
        ByteArrayOutputStream pubKeyRingBuffer = new ByteArrayOutputStream();
        createdKeyRing.getPublicKeyRings().encode(pubKeyRingBuffer);
        pubKeyRingBuffer.close();
        byte[] publicKey = pubKeyRingBuffer.toByteArray();


        ByteArrayOutputStream secretKeyRingBuffer = new ByteArrayOutputStream();
        createdKeyRing.getSecretKeyRings().encode(secretKeyRingBuffer);
        secretKeyRingBuffer.close();
        byte[] secretKey = secretKeyRingBuffer.toByteArray();

        // 2.a
        // now persist secretKey and publicKey into a database

        // 3. load the persisted keys
        InMemoryKeyring memoryKeyring = KeyringConfigs.forGpgExportedKeys(keyId -> PASSPHRASE.toCharArray());
        memoryKeyring.addPublicKey(publicKey);
        memoryKeyring.addSecretKey(secretKey);
    }

        // 1. Create a new keyring with new keys
        KeyringConfig createdKeyRing = ...

        // 2. Get the persisted keys in a ascii format

        String publicKey;
        try (
                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                ArmoredOutputStream armored = new ArmoredOutputStream(buffer);
        ) {
            createdKeyRing.getPublicKeyRings().encode(armored);
            armored.close();
            buffer.close();

            publicKey = new String(buffer.toByteArray(), StandardCharsets.US_ASCII);
        }

        String secretKey;
        try (
                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                ArmoredOutputStream armored = new ArmoredOutputStream(buffer);
        ) {
            createdKeyRing.getSecretKeyRings().encode(armored);
            armored.close();
            buffer.close();

            secretKey = new String(buffer.toByteArray(), StandardCharsets.US_ASCII);
        }

        // 2.a
        // now persist secretKey and publicKey into a database

        // 3. load the persisted keys
        InMemoryKeyring memoryKeyring = KeyringConfigs.forGpgExportedKeys(keyId -> PASSPHRASE.toCharArray());
        memoryKeyring.addPublicKey(publicKey.getBytes());
        memoryKeyring.addSecretKey(secretKey.getBytes());