blob: cd98ef38cdfa4fc4f8e52f29c08a8c73b003c05a (
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
|
package org.spongycastle.openpgp.operator.bc;
import java.io.OutputStream;
import java.security.SecureRandom;
import org.spongycastle.crypto.CryptoException;
import org.spongycastle.crypto.Signer;
import org.spongycastle.crypto.params.ParametersWithRandom;
import org.spongycastle.openpgp.PGPException;
import org.spongycastle.openpgp.PGPPrivateKey;
import org.spongycastle.openpgp.operator.PGPContentSigner;
import org.spongycastle.openpgp.operator.PGPContentSignerBuilder;
import org.spongycastle.openpgp.operator.PGPDigestCalculator;
import org.spongycastle.util.io.TeeOutputStream;
public class BcPGPContentSignerBuilder
implements PGPContentSignerBuilder
{
private BcPGPDigestCalculatorProvider digestCalculatorProvider = new BcPGPDigestCalculatorProvider();
private BcPGPKeyConverter keyConverter = new BcPGPKeyConverter();
private int hashAlgorithm;
private SecureRandom random;
private int keyAlgorithm;
public BcPGPContentSignerBuilder(int keyAlgorithm, int hashAlgorithm)
{
this.keyAlgorithm = keyAlgorithm;
this.hashAlgorithm = hashAlgorithm;
}
public BcPGPContentSignerBuilder setSecureRandom(SecureRandom random)
{
this.random = random;
return this;
}
public PGPContentSigner build(final int signatureType, final PGPPrivateKey privateKey)
throws PGPException
{
final PGPDigestCalculator digestCalculator = digestCalculatorProvider.get(hashAlgorithm);
final Signer signer = BcImplProvider.createSigner(keyAlgorithm, hashAlgorithm);
if (random != null)
{
signer.init(true, new ParametersWithRandom(keyConverter.getPrivateKey(privateKey), random));
}
else
{
signer.init(true, keyConverter.getPrivateKey(privateKey));
}
return new PGPContentSigner()
{
public int getType()
{
return signatureType;
}
public int getHashAlgorithm()
{
return hashAlgorithm;
}
public int getKeyAlgorithm()
{
return keyAlgorithm;
}
public long getKeyID()
{
return privateKey.getKeyID();
}
public OutputStream getOutputStream()
{
return new TeeOutputStream(new SignerOutputStream(signer), digestCalculator.getOutputStream());
}
public byte[] getSignature()
{
try
{
return signer.generateSignature();
}
catch (CryptoException e)
{ // TODO: need a specific runtime exception for PGP operators.
throw new IllegalStateException("unable to create signature");
}
}
public byte[] getDigest()
{
return digestCalculator.getDigest();
}
};
}
}
|