blob: bfb2946a4c1e8afc6d8468a29ba08ceadf2ed3db (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
package org.spongycastle.openpgp.operator.bc;
import java.io.OutputStream;
import java.security.SecureRandom;
import org.spongycastle.bcpg.SymmetricKeyAlgorithmTags;
import org.spongycastle.crypto.BlockCipher;
import org.spongycastle.crypto.BufferedBlockCipher;
import org.spongycastle.crypto.io.CipherOutputStream;
import org.spongycastle.openpgp.PGPException;
import org.spongycastle.openpgp.operator.PGPDataEncryptor;
import org.spongycastle.openpgp.operator.PGPDataEncryptorBuilder;
import org.spongycastle.openpgp.operator.PGPDigestCalculator;
/**
* {@link PGPDataEncryptorBuilder} implementation that uses the Bouncy Castle lightweight API to
* implement cryptographic primitives.
*/
public class BcPGPDataEncryptorBuilder
implements PGPDataEncryptorBuilder
{
private SecureRandom random;
private boolean withIntegrityPacket;
private int encAlgorithm;
/**
* Constructs a new data encryptor builder for a specified cipher type.
*
* @param encAlgorithm one of the {@link SymmetricKeyAlgorithmTags supported symmetric cipher
* algorithms}. May not be {@link SymmetricKeyAlgorithmTags#NULL}.
*/
public BcPGPDataEncryptorBuilder(int encAlgorithm)
{
this.encAlgorithm = encAlgorithm;
if (encAlgorithm == 0)
{
throw new IllegalArgumentException("null cipher specified");
}
}
/**
* Sets whether or not the resulting encrypted data will be protected using an integrity packet.
*
* @param withIntegrityPacket true if an integrity packet is to be included, false otherwise.
* @return the current builder.
*/
public BcPGPDataEncryptorBuilder setWithIntegrityPacket(boolean withIntegrityPacket)
{
this.withIntegrityPacket = withIntegrityPacket;
return this;
}
/**
* Provide a user defined source of randomness.
* <p/>
* If no SecureRandom is configured, a default SecureRandom will be used.
*
* @param random the secure random to be used.
* @return the current builder.
*/
public BcPGPDataEncryptorBuilder setSecureRandom(SecureRandom random)
{
this.random = random;
return this;
}
public int getAlgorithm()
{
return encAlgorithm;
}
public SecureRandom getSecureRandom()
{
if (random == null)
{
random = new SecureRandom();
}
return random;
}
public PGPDataEncryptor build(byte[] keyBytes)
throws PGPException
{
return new MyPGPDataEncryptor(keyBytes);
}
private class MyPGPDataEncryptor
implements PGPDataEncryptor
{
private final BufferedBlockCipher c;
MyPGPDataEncryptor(byte[] keyBytes)
throws PGPException
{
BlockCipher engine = BcImplProvider.createBlockCipher(encAlgorithm);
try
{
c = BcUtil.createStreamCipher(true, engine, withIntegrityPacket, keyBytes);
}
catch (IllegalArgumentException e)
{
throw new PGPException("invalid parameters: " + e.getMessage(), e);
}
}
public OutputStream getOutputStream(OutputStream out)
{
return new CipherOutputStream(out, c);
}
public PGPDigestCalculator getIntegrityCalculator()
{
if (withIntegrityPacket)
{
return new SHA1PGPDigestCalculator();
}
return null;
}
public int getBlockSize()
{
return c.getBlockSize();
}
}
}
|
