blob: 1888916e51e120834c94b89f431a47f646d7d5d4 (
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
|
package org.spongycastle.crypto.engines;
import org.spongycastle.crypto.AsymmetricBlockCipher;
import org.spongycastle.crypto.CipherParameters;
import org.spongycastle.crypto.DataLengthException;
import org.spongycastle.crypto.params.ParametersWithRandom;
import org.spongycastle.crypto.params.RSABlindingParameters;
import org.spongycastle.crypto.params.RSAKeyParameters;
import java.math.BigInteger;
/**
* This does your basic RSA Chaum's blinding and unblinding as outlined in
* "Handbook of Applied Cryptography", page 475. You need to use this if you are
* trying to get another party to generate signatures without them being aware
* of the message they are signing.
*/
public class RSABlindingEngine
implements AsymmetricBlockCipher
{
private RSACoreEngine core = new RSACoreEngine();
private RSAKeyParameters key;
private BigInteger blindingFactor;
private boolean forEncryption;
/**
* Initialise the blinding engine.
*
* @param forEncryption true if we are encrypting (blinding), false otherwise.
* @param param the necessary RSA key parameters.
*/
public void init(
boolean forEncryption,
CipherParameters param)
{
RSABlindingParameters p;
if (param instanceof ParametersWithRandom)
{
ParametersWithRandom rParam = (ParametersWithRandom)param;
p = (RSABlindingParameters)rParam.getParameters();
}
else
{
p = (RSABlindingParameters)param;
}
core.init(forEncryption, p.getPublicKey());
this.forEncryption = forEncryption;
this.key = p.getPublicKey();
this.blindingFactor = p.getBlindingFactor();
}
/**
* Return the maximum size for an input block to this engine.
* For RSA this is always one byte less than the key size on
* encryption, and the same length as the key size on decryption.
*
* @return maximum size for an input block.
*/
public int getInputBlockSize()
{
return core.getInputBlockSize();
}
/**
* Return the maximum size for an output block to this engine.
* For RSA this is always one byte less than the key size on
* decryption, and the same length as the key size on encryption.
*
* @return maximum size for an output block.
*/
public int getOutputBlockSize()
{
return core.getOutputBlockSize();
}
/**
* Process a single block using the RSA blinding algorithm.
*
* @param in the input array.
* @param inOff the offset into the input buffer where the data starts.
* @param inLen the length of the data to be processed.
* @return the result of the RSA process.
* @throws DataLengthException the input block is too large.
*/
public byte[] processBlock(
byte[] in,
int inOff,
int inLen)
{
BigInteger msg = core.convertInput(in, inOff, inLen);
if (forEncryption)
{
msg = blindMessage(msg);
}
else
{
msg = unblindMessage(msg);
}
return core.convertOutput(msg);
}
/*
* Blind message with the blind factor.
*/
private BigInteger blindMessage(
BigInteger msg)
{
BigInteger blindMsg = blindingFactor;
blindMsg = msg.multiply(blindMsg.modPow(key.getExponent(), key.getModulus()));
blindMsg = blindMsg.mod(key.getModulus());
return blindMsg;
}
/*
* Unblind the message blinded with the blind factor.
*/
private BigInteger unblindMessage(
BigInteger blindedMsg)
{
BigInteger m = key.getModulus();
BigInteger msg = blindedMsg;
BigInteger blindFactorInverse = blindingFactor.modInverse(m);
msg = msg.multiply(blindFactorInverse);
msg = msg.mod(m);
return msg;
}
}
|
