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
|
package org.bouncycastle.openpgp.operator.jcajce;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Provider;
import java.security.SecureRandom;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.bcpg.S2K;
import org.bouncycastle.jcajce.util.DefaultJcaJceHelper;
import org.bouncycastle.jcajce.util.NamedJcaJceHelper;
import org.bouncycastle.jcajce.util.ProviderJcaJceHelper;
import org.bouncycastle.openpgp.PGPException;
import org.bouncycastle.openpgp.operator.PBEKeyEncryptionMethodGenerator;
import org.bouncycastle.openpgp.operator.PGPDigestCalculator;
/**
* JCE based generator for password based encryption (PBE) data protection methods.
*/
public class JcePBEKeyEncryptionMethodGenerator
extends PBEKeyEncryptionMethodGenerator
{
private OperatorHelper helper = new OperatorHelper(new DefaultJcaJceHelper());
/**
* Create a PBE encryption method generator using the provided digest and the default S2K count
* for key generation.
*
* @param passPhrase the passphrase to use as the primary source of key material.
* @param s2kDigestCalculator the digest calculator to use for key calculation.
*/
public JcePBEKeyEncryptionMethodGenerator(char[] passPhrase, PGPDigestCalculator s2kDigestCalculator)
{
super(passPhrase, s2kDigestCalculator);
}
/**
* Create a PBE encryption method generator using the default SHA-1 digest and the default S2K
* count for key generation.
*
* @param passPhrase the passphrase to use as the primary source of key material.
*/
public JcePBEKeyEncryptionMethodGenerator(char[] passPhrase)
{
this(passPhrase, new SHA1PGPDigestCalculator());
}
/**
* Create a PBE encryption method generator using the provided calculator and S2K count for key
* generation.
*
* @param passPhrase the passphrase to use as the primary source of key material.
* @param s2kDigestCalculator the digest calculator to use for key calculation.
* @param s2kCount the single byte {@link S2K} count to use.
*/
public JcePBEKeyEncryptionMethodGenerator(char[] passPhrase, PGPDigestCalculator s2kDigestCalculator, int s2kCount)
{
super(passPhrase, s2kDigestCalculator, s2kCount);
}
/**
* Create a PBE encryption method generator using the default SHA-1 digest calculator and a S2K
* count other than the default for key generation.
*
* @param passPhrase the passphrase to use as the primary source of key material.
* @param s2kCount the single byte {@link S2K} count to use.
*/
public JcePBEKeyEncryptionMethodGenerator(char[] passPhrase, int s2kCount)
{
super(passPhrase, new SHA1PGPDigestCalculator(), s2kCount);
}
/**
* Sets the JCE provider to source cryptographic primitives from.
*
* @param provider the JCE provider to use.
* @return the current generator.
*/
public JcePBEKeyEncryptionMethodGenerator setProvider(Provider provider)
{
this.helper = new OperatorHelper(new ProviderJcaJceHelper(provider));
return this;
}
/**
* Sets the JCE provider to source cryptographic primitives from.
*
* @param providerName the name of the JCE provider to use.
* @return the current generator.
*/
public JcePBEKeyEncryptionMethodGenerator setProvider(String providerName)
{
this.helper = new OperatorHelper(new NamedJcaJceHelper(providerName));
return this;
}
public PBEKeyEncryptionMethodGenerator setSecureRandom(SecureRandom random)
{
super.setSecureRandom(random);
return this;
}
protected byte[] encryptSessionInfo(int encAlgorithm, byte[] key, byte[] sessionInfo)
throws PGPException
{
try
{
String cName = PGPUtil.getSymmetricCipherName(encAlgorithm);
Cipher c = helper.createCipher(cName + "/CFB/NoPadding");
SecretKey sKey = new SecretKeySpec(key, PGPUtil.getSymmetricCipherName(encAlgorithm));
c.init(Cipher.ENCRYPT_MODE, sKey, new IvParameterSpec(new byte[c.getBlockSize()]));
return c.doFinal(sessionInfo, 0, sessionInfo.length);
}
catch (IllegalBlockSizeException e)
{
throw new PGPException("illegal block size: " + e.getMessage(), e);
}
catch (BadPaddingException e)
{
throw new PGPException("bad padding: " + e.getMessage(), e);
}
catch (InvalidAlgorithmParameterException e)
{
throw new PGPException("IV invalid: " + e.getMessage(), e);
}
catch (InvalidKeyException e)
{
throw new PGPException("key invalid: " + e.getMessage(), e);
}
}
}
|
