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
|
package org.spongycastle.crypto;
/**
* a wrapper for block ciphers with a single byte block size, so that they
* can be treated like stream ciphers.
*/
public class StreamBlockCipher
implements StreamCipher
{
private BlockCipher cipher;
private byte[] oneByte = new byte[1];
/**
* basic constructor.
*
* @param cipher the block cipher to be wrapped.
* @exception IllegalArgumentException if the cipher has a block size other than
* one.
*/
public StreamBlockCipher(
BlockCipher cipher)
{
if (cipher.getBlockSize() != 1)
{
throw new IllegalArgumentException("block cipher block size != 1.");
}
this.cipher = cipher;
}
/**
* initialise the underlying cipher.
*
* @param forEncryption true if we are setting up for encryption, false otherwise.
* @param params the necessary parameters for the underlying cipher to be initialised.
*/
public void init(
boolean forEncryption,
CipherParameters params)
{
cipher.init(forEncryption, params);
}
/**
* return the name of the algorithm we are wrapping.
*
* @return the name of the algorithm we are wrapping.
*/
public String getAlgorithmName()
{
return cipher.getAlgorithmName();
}
/**
* encrypt/decrypt a single byte returning the result.
*
* @param in the byte to be processed.
* @return the result of processing the input byte.
*/
public byte returnByte(
byte in)
{
oneByte[0] = in;
cipher.processBlock(oneByte, 0, oneByte, 0);
return oneByte[0];
}
/**
* process a block of bytes from in putting the result into out.
*
* @param in the input byte array.
* @param inOff the offset into the in array where the data to be processed starts.
* @param len the number of bytes to be processed.
* @param out the output buffer the processed bytes go into.
* @param outOff the offset into the output byte array the processed data stars at.
* @exception DataLengthException if the output buffer is too small.
*/
public void processBytes(
byte[] in,
int inOff,
int len,
byte[] out,
int outOff)
throws DataLengthException
{
if (outOff + len > out.length)
{
throw new DataLengthException("output buffer too small in processBytes()");
}
for (int i = 0; i != len; i++)
{
cipher.processBlock(in, inOff + i, out, outOff + i);
}
}
/**
* reset the underlying cipher. This leaves it in the same state
* it was at after the last init (if there was one).
*/
public void reset()
{
cipher.reset();
}
}
|
