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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
using Org.BouncyCastle.Crypto.Utilities;
namespace Org.BouncyCastle.Pqc.Math.LinearAlgebra
{
/**
* This is a utility class containing data type conversions using little-endian
* byte order.
*
*/
class LittleEndianConversions
{
/**
* Default constructor (private).
*/
private LittleEndianConversions()
{
// empty
}
/**
* Convert an octet string of length 4 to an integer. No length checking is
* performed.
*
* @param input the byte array holding the octet string
* @return an integer representing the octet string <tt>input</tt>
* @throws ArithmeticException if the length of the given octet string is larger than 4.
*/
public static int OS2IP(byte[] input)
{
return (int)Pack.LE_To_UInt32(input);
}
/**
* Convert an byte array of length 4 beginning at <tt>offset</tt> into an
* integer.
*
* @param input the byte array
* @param inOff the offset into the byte array
* @return the resulting integer
*/
public static int OS2IP(byte[] input, int inOff)
{
return (int)Pack.LE_To_UInt32(input, inOff);
}
/**
* Convert a byte array of the given length beginning at <tt>offset</tt>
* into an integer.
*
* @param input the byte array
* @param inOff the offset into the byte array
* @param inLen the length of the encoding
* @return the resulting integer
*/
public static int OS2IP(byte[] input, int inOff, int inLen)
{
int result = 0;
for (int i = inLen - 1; i >= 0; i--)
{
result |= (input[inOff + i] & 0xff) << (8 * i);
}
return result;
}
/**
* Convert a byte array of length 8 beginning at <tt>inOff</tt> into a
* long integer.
*
* @param input the byte array
* @param inOff the offset into the byte array
* @return the resulting long integer
*/
public static long OS2LIP(byte[] input, int inOff)
{
return (long)Pack.LE_To_UInt64(input, inOff);
}
/**
* Convert an integer to an octet string of length 4.
*
* @param x the integer to convert
* @return the converted integer
*/
public static byte[] I2OSP(int x)
{
return Pack.UInt32_To_LE((uint)x);
}
/**
* Convert an integer into a byte array beginning at the specified offset.
*
* @param value the integer to convert
* @param output the byte array to hold the result
* @param outOff the integer offset into the byte array
*/
public static void I2OSP(int value, byte[] output, int outOff)
{
Pack.UInt32_To_LE((uint)value, output, outOff);
}
/**
* Convert an integer to a byte array beginning at the specified offset. No
* length checking is performed (i.e., if the integer cannot be encoded with
* <tt>length</tt> octets, it is truncated).
*
* @param value the integer to convert
* @param output the byte array to hold the result
* @param outOff the integer offset into the byte array
* @param outLen the length of the encoding
*/
public static void I2OSP(int value, byte[] output, int outOff, int outLen)
{
uint valueTmp = (uint)value;
for (int i = outLen - 1; i >= 0; i--)
{
output[outOff + i] = (byte)(valueTmp >> (8 * i));
}
}
/**
* Convert an integer to a byte array of length 8.
*
* @param input the integer to convert
* @return the converted integer
*/
public static byte[] I2OSP(long input)
{
return Pack.UInt64_To_LE((ulong)input);
}
/**
* Convert an integer to a byte array of length 8.
*
* @param input the integer to convert
* @param output byte array holding the output
* @param outOff offset in output array where the result is stored
*/
public static void I2OSP(long input, byte[] output, int outOff)
{
Pack.UInt64_To_LE((ulong)input, output, outOff);
}
/**
* Convert an int array to a byte array of the specified length. No length
* checking is performed (i.e., if the last integer cannot be encoded with
* <tt>length % 4</tt> octets, it is truncated).
*
* @param input the int array
* @param outLen the length of the converted array
* @return the converted array
*/
public static byte[] ToByteArray(int[] input, int outLen)
{
int intLen = input.Length;
byte[] result = new byte[outLen];
int index = 0;
for (int i = 0; i <= intLen - 2; i++, index += 4)
{
I2OSP(input[i], result, index);
}
I2OSP(input[intLen - 1], result, index, outLen - index);
return result;
}
/**
* Convert a byte array to an int array.
*
* @param input the byte array
* @return the converted array
*/
public static int[] ToIntArray(byte[] input)
{
int intLen = (input.Length + 3) / 4;
int lastLen = input.Length & 0x03;
int[] result = new int[intLen];
int index = 0;
for (int i = 0; i <= intLen - 2; i++, index += 4)
{
result[i] = OS2IP(input, index);
}
if (lastLen != 0)
{
result[intLen - 1] = OS2IP(input, index, lastLen);
}
else
{
result[intLen - 1] = OS2IP(input, index);
}
return result;
}
}
}
|
