blob: ba6e793ba33aebc2e0b61d9fe193f8ac5bc8abb8 (
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
package org.spongycastle.openpgp.operator.jcajce;
import java.io.OutputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Provider;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.CipherOutputStream;
import javax.crypto.spec.IvParameterSpec;
import org.spongycastle.jcajce.DefaultJcaJceHelper;
import org.spongycastle.jcajce.NamedJcaJceHelper;
import org.spongycastle.jcajce.ProviderJcaJceHelper;
import org.spongycastle.openpgp.PGPException;
import org.spongycastle.openpgp.operator.PGPDataEncryptor;
import org.spongycastle.openpgp.operator.PGPDataEncryptorBuilder;
import org.spongycastle.openpgp.operator.PGPDigestCalculator;
public class JcePGPDataEncryptorBuilder
implements PGPDataEncryptorBuilder
{
private OperatorHelper helper = new OperatorHelper(new DefaultJcaJceHelper());
private SecureRandom random;
private boolean withIntegrityPacket;
private int encAlgorithm;
public JcePGPDataEncryptorBuilder(int encAlgorithm)
{
this.encAlgorithm = encAlgorithm;
if (encAlgorithm == 0)
{
throw new IllegalArgumentException("null cipher specified");
}
}
/**
* Determine 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 JcePGPDataEncryptorBuilder setWithIntegrityPacket(boolean withIntegrityPacket)
{
this.withIntegrityPacket = withIntegrityPacket;
return this;
}
public JcePGPDataEncryptorBuilder setProvider(Provider provider)
{
this.helper = new OperatorHelper(new ProviderJcaJceHelper(provider));
return this;
}
public JcePGPDataEncryptorBuilder setProvider(String providerName)
{
this.helper = new OperatorHelper(new NamedJcaJceHelper(providerName));
return this;
}
/**
* Provide a user defined source of randomness.
*
* @param random the secure random to be used.
* @return the current builder.
*/
public JcePGPDataEncryptorBuilder 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 Cipher c;
MyPGPDataEncryptor(byte[] keyBytes)
throws PGPException
{
c = helper.createStreamCipher(encAlgorithm, withIntegrityPacket);
byte[] iv = new byte[c.getBlockSize()];
try
{
c.init(Cipher.ENCRYPT_MODE, PGPUtil.makeSymmetricKey(encAlgorithm, keyBytes), new IvParameterSpec(iv));
}
catch (InvalidKeyException e)
{
throw new PGPException("invalid key: " + e.getMessage(), e);
}
catch (InvalidAlgorithmParameterException e)
{
throw new PGPException("imvalid algorithm parameter: " + 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();
}
}
}
|
