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
|
package org.spongycastle.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.spongycastle.jcajce.DefaultJcaJceHelper;
import org.spongycastle.jcajce.NamedJcaJceHelper;
import org.spongycastle.jcajce.ProviderJcaJceHelper;
import org.spongycastle.openpgp.PGPException;
import org.spongycastle.openpgp.operator.PBEKeyEncryptionMethodGenerator;
import org.spongycastle.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 calculator for key calculation.
*
* @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 calculator for key calculation.
*
* @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 calculation.
*
* @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 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 of 0x60 for key calculation
*
* @param passPhrase the passphrase to use as the primary source of key material.
* @param s2kCount the S2K count to use.
*/
public JcePBEKeyEncryptionMethodGenerator(char[] passPhrase, int s2kCount)
{
super(passPhrase, new SHA1PGPDigestCalculator(), s2kCount);
}
public JcePBEKeyEncryptionMethodGenerator setProvider(Provider provider)
{
this.helper = new OperatorHelper(new ProviderJcaJceHelper(provider));
return this;
}
public JcePBEKeyEncryptionMethodGenerator 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 generator.
*/
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);
}
}
}
|
