Java PGPLiteralDataGenerator类代码示例

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
public static byte[] encrypt( final byte[] message, final PGPPublicKey publicKey, boolean armored )
        throws PGPException
{
    try
    {
        final ByteArrayInputStream in = new ByteArrayInputStream( message );
        final ByteArrayOutputStream bOut = new ByteArrayOutputStream();
        final PGPLiteralDataGenerator literal = new PGPLiteralDataGenerator();
        final PGPCompressedDataGenerator comData = new PGPCompressedDataGenerator( CompressionAlgorithmTags.ZIP );
        final OutputStream pOut =
                literal.open( comData.open( bOut ), PGPLiteralData.BINARY, "filename", in.available(), new Date() );
        Streams.pipeAll( in, pOut );
        comData.close();
        final byte[] bytes = bOut.toByteArray();
        final PGPEncryptedDataGenerator generator = new PGPEncryptedDataGenerator(
                new JcePGPDataEncryptorBuilder( SymmetricKeyAlgorithmTags.AES_256 ).setWithIntegrityPacket( true )
                                                                                   .setSecureRandom(
                                                                                           new SecureRandom() )

                                                                                   .setProvider( provider ) );
        generator.addMethod( new JcePublicKeyKeyEncryptionMethodGenerator( publicKey ).setProvider( provider ) );
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        OutputStream theOut = armored ? new ArmoredOutputStream( out ) : out;
        OutputStream cOut = generator.open( theOut, bytes.length );
        cOut.write( bytes );
        cOut.close();
        theOut.close();
        return out.toByteArray();
    }
    catch ( Exception e )
    {
        throw new PGPException( "Error in encrypt", e );
    }
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private static void produceSign( byte[] data, BCPGOutputStream bcOut, PGPSignatureGenerator signGen )
        throws IOException, PGPException
{
    PGPLiteralDataGenerator literalGen = new PGPLiteralDataGenerator();

    OutputStream os = literalGen.open( bcOut, PGPLiteralData.BINARY, "", data.length, new Date() );

    InputStream is = new ByteArrayInputStream( data );

    int ch;

    while ( ( ch = is.read() ) >= 0 )
    {
        signGen.update( ( byte ) ch );
        os.write( ch );
    }

    literalGen.close();

    signGen.generate().encode( bcOut );
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
void createEncryptedNonCompressedData(ByteArrayOutputStream bos, String keyringPath) throws Exception, IOException, PGPException,
        UnsupportedEncodingException {
    PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(new JcePGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.CAST5)
            .setSecureRandom(new SecureRandom()).setProvider(getProvider()));
    encGen.addMethod(new JcePublicKeyKeyEncryptionMethodGenerator(readPublicKey(keyringPath)));
    OutputStream encOut = encGen.open(bos, new byte[512]);
    PGPLiteralDataGenerator litData = new PGPLiteralDataGenerator();
    OutputStream litOut = litData.open(encOut, PGPLiteralData.BINARY, PGPLiteralData.CONSOLE, new Date(), new byte[512]);

    try {
        litOut.write("Test Message Without Compression".getBytes("UTF-8"));
        litOut.flush();
    } finally {
        IOHelper.close(litOut);
        IOHelper.close(encOut, bos);
    }
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private static byte[] compress(byte[] clearData, String fileName, int algorithm) throws IOException
{
    ByteArrayOutputStream bOut = new ByteArrayOutputStream();
    PGPCompressedDataGenerator comData = new PGPCompressedDataGenerator(algorithm);
    OutputStream cos = comData.open(bOut); // open it with the final destination

    PGPLiteralDataGenerator lData = new PGPLiteralDataGenerator();

    // we want to generate compressed data. This might be a user option later,
    // in which case we would pass in bOut.
    OutputStream  pOut = lData.open(cos, // the compressed output stream
                                    PGPLiteralData.BINARY,
                                    fileName,  // "filename" to store
                                    clearData.length, // length of clear data
                                    new Date()  // current time
                                  );

    pOut.write(clearData);
    pOut.close();

    comData.close();

    return bOut.toByteArray();
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private void readBackTest(
    PGPLiteralDataGenerator generator)
    throws IOException
{
    Random                  rand = new Random();
    byte[]                  buf = new byte[MAX];
    
    rand.nextBytes(buf);
    
    for (int i = 1; i <= 200; i++)
    {
        bufferTest(generator, buf, i);
    }
    
    bufferTest(generator, buf, 8382);
    bufferTest(generator, buf, 8383);
    bufferTest(generator, buf, 8384);
    bufferTest(generator, buf, 8385);
    
    for (int i = 200; i < MAX; i += 100)
    {
        bufferTest(generator, buf, i);
    }
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private static void writeBytesToLiteralData(OutputStream out, char fileType, String name, byte[] bytes)
		throws IOException
{
	PGPLiteralDataGenerator lData = new PGPLiteralDataGenerator();
	OutputStream pOut = lData.open(out, fileType, name, bytes.length, new Date());
	pOut.write(bytes);
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
/**
 * Wraps with stream that ouputs literal data packet.
 */
protected OutputStream packet(OutputStream out, FileMetadata meta)
throws IOException, PGPException {
    char format = meta.getFormat().getCode();
    String name = meta.getName();
    Date date = meta.getLastModifiedDate();
    byte[] buf = getLiteralBuffer(meta);
    return new PGPLiteralDataGenerator().open(out, format, name, date, buf);
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private static OutputStream
    createDelegate(int bufferSize, OutputStream os, DateTime modified, String filename) {
  try {
    checkArgument(filename.endsWith(".tar"),
        "Ryde PGP message should contain a tar file.");
    return new PGPLiteralDataGenerator().open(
        os, BINARY, filename, modified.toDate(), new byte[bufferSize]);
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
@Test
public void testExceptionDecryptorIncorrectInputFormatSymmetricEncryptedData() throws Exception {

    byte[] payload = "Not Correct Format".getBytes("UTF-8");
    ByteArrayOutputStream bos = new ByteArrayOutputStream();

    PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(new JcePGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.CAST5)
            .setSecureRandom(new SecureRandom()).setProvider(getProvider()));

    encGen.addMethod(new JcePBEKeyEncryptionMethodGenerator("pw".toCharArray()));

    OutputStream encOut = encGen.open(bos, new byte[1024]);
    PGPCompressedDataGenerator comData = new PGPCompressedDataGenerator(CompressionAlgorithmTags.ZIP);
    OutputStream comOut = new BufferedOutputStream(comData.open(encOut));
    PGPLiteralDataGenerator litData = new PGPLiteralDataGenerator();
    OutputStream litOut = litData.open(comOut, PGPLiteralData.BINARY, PGPLiteralData.CONSOLE, new Date(), new byte[1024]);
    litOut.write(payload);
    litOut.flush();
    litOut.close();
    comOut.close();
    encOut.close();
    MockEndpoint mock = getMockEndpoint("mock:exception");
    mock.expectedMessageCount(1);
    template.sendBody("direct:subkeyUnmarshal", bos.toByteArray());
    assertMockEndpointsSatisfied();

    checkThrownException(mock, IllegalArgumentException.class, null, "The input message body has an invalid format.");
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
public String encryptString(PGPPublicKey key, String clearText)
		throws IOException, PGPException {

	byte[] clearData = clearText.getBytes(StandardCharsets.UTF_8);

	ByteArrayOutputStream encOut = new ByteArrayOutputStream();
	OutputStream out = new ArmoredOutputStream(encOut);
	ByteArrayOutputStream bOut = new ByteArrayOutputStream();

	PGPCompressedDataGenerator comData = new PGPCompressedDataGenerator(
			PGPCompressedDataGenerator.ZIP);
	OutputStream cos = comData.open(bOut);
	PGPLiteralDataGenerator lData = new PGPLiteralDataGenerator();

	OutputStream pOut = lData.open(cos, PGPLiteralData.BINARY,
			PGPLiteralData.CONSOLE, clearData.length, new Date());
	pOut.write(clearData);

	lData.close();
	comData.close();

	PGPEncryptedDataGenerator encGen = new PGPEncryptedDataGenerator(
			new JcePGPDataEncryptorBuilder(PGPEncryptedData.CAST5)
					.setWithIntegrityPacket(true)
					.setSecureRandom(new SecureRandom()).setProvider(BouncyCastleProvider.PROVIDER_NAME));

	encGen.addMethod(new JcePublicKeyKeyEncryptionMethodGenerator(key)
			.setProvider(BouncyCastleProvider.PROVIDER_NAME));

	byte[] bytes = bOut.toByteArray();
	OutputStream cOut = encGen.open(out, bytes.length);
	cOut.write(bytes);
	cOut.close();
	out.close();

	return new String(encOut.toByteArray());
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private static void writeBytesToLiteralData(OutputStream out,
        char fileType, String name, byte[] bytes) throws IOException {
    PGPLiteralDataGenerator lData = new PGPLiteralDataGenerator();
    OutputStream pOut = lData.open(out, fileType, name,
            bytes.length, new Date());
    pOut.write(bytes);
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private void bufferTest(
    PGPLiteralDataGenerator generator, 
    byte[] buf, 
    int i)
    throws IOException
{
    ByteArrayOutputStream bOut = new ByteArrayOutputStream();
    OutputStream out = generator.open(
        new UncloseableOutputStream(bOut),
        PGPLiteralData.BINARY,
        PGPLiteralData.CONSOLE,
        i,
        new Date());

    out.write(buf, 0, i);
    
    generator.close();
    
    PGPObjectFactory        fact = new PGPObjectFactory(bOut.toByteArray());
    PGPLiteralData          data = (PGPLiteralData)fact.nextObject();
    InputStream             in = data.getInputStream();

    for (int count = 0; count != i; count++)
    {
        if (in.read() != (buf[count] & 0xff))
        {
            fail("failed readback test - length = " + i);
        }
    }
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
public void performTest()
    throws IOException
{
    PGPLiteralDataGenerator oldGenerator = new PGPLiteralDataGenerator(true);

    readBackTest(oldGenerator);
    
    PGPLiteralDataGenerator newGenerator = new PGPLiteralDataGenerator(false);
    
    readBackTest(newGenerator);
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private void testSig(
    int           encAlgorithm,
    int           hashAlgorithm,
    PGPPublicKey  pubKey,
    PGPPrivateKey privKey)
    throws Exception
{            
    ByteArrayOutputStream bOut = new ByteArrayOutputStream();
    ByteArrayInputStream  testIn = new ByteArrayInputStream(TEST_DATA);
    PGPSignatureGenerator sGen = new PGPSignatureGenerator(new JcaPGPContentSignerBuilder(encAlgorithm, hashAlgorithm).setProvider("BC"));
    
    sGen.init(PGPSignature.BINARY_DOCUMENT, privKey);
    sGen.generateOnePassVersion(false).encode(bOut);

    PGPLiteralDataGenerator    lGen = new PGPLiteralDataGenerator();
    OutputStream               lOut = lGen.open(
        new UncloseableOutputStream(bOut),
        PGPLiteralData.BINARY,
        "_CONSOLE",
        TEST_DATA.length * 2,
        new Date());

    int ch;
    while ((ch = testIn.read()) >= 0)
    {
        lOut.write(ch);
        sGen.update((byte)ch);
    }

    lOut.write(TEST_DATA);
    sGen.update(TEST_DATA);
    
    lGen.close();

    sGen.generate().encode(bOut);

    verifySignature(bOut.toByteArray(), hashAlgorithm, pubKey, TEST_DATA);
}
 

import org.bouncycastle.openpgp.PGPLiteralDataGenerator; //导入依赖的package包/类
private byte[] generateV3BinarySig(PGPPrivateKey privKey, int encAlgorithm, int hashAlgorithm) 
    throws Exception
{
    ByteArrayOutputStream   bOut = new ByteArrayOutputStream();
    ByteArrayInputStream    testIn = new ByteArrayInputStream(TEST_DATA);
    PGPV3SignatureGenerator sGen = new PGPV3SignatureGenerator(new JcaPGPContentSignerBuilder(encAlgorithm, hashAlgorithm).setProvider("BC"));
    
    sGen.init(PGPSignature.BINARY_DOCUMENT, privKey);
    sGen.generateOnePassVersion(false).encode(bOut);

    PGPLiteralDataGenerator lGen = new PGPLiteralDataGenerator();
    OutputStream            lOut = lGen.open(
        new UncloseableOutputStream(bOut),
        PGPLiteralData.BINARY,
        "_CONSOLE",
        TEST_DATA.length * 2,
        new Date());

    int ch;
    while ((ch = testIn.read()) >= 0)
    {
        lOut.write(ch);
        sGen.update((byte)ch);
    }

    lOut.write(TEST_DATA);
    sGen.update(TEST_DATA);
    
    lGen.close();

    sGen.generate().encode(bOut);
    
    return bOut.toByteArray();
}