1package org.bouncycastle.crypto.util;
2
3public abstract class Pack
4{
5    public static int bigEndianToInt(byte[] bs, int off)
6    {
7        int n = bs[  off] << 24;
8        n |= (bs[++off] & 0xff) << 16;
9        n |= (bs[++off] & 0xff) << 8;
10        n |= (bs[++off] & 0xff);
11        return n;
12    }
13
14    public static void bigEndianToInt(byte[] bs, int off, int[] ns)
15    {
16        for (int i = 0; i < ns.length; ++i)
17        {
18            ns[i] = bigEndianToInt(bs, off);
19            off += 4;
20        }
21    }
22
23    public static byte[] intToBigEndian(int n)
24    {
25        byte[] bs = new byte[4];
26        intToBigEndian(n, bs, 0);
27        return bs;
28    }
29
30    public static void intToBigEndian(int n, byte[] bs, int off)
31    {
32        bs[  off] = (byte)(n >>> 24);
33        bs[++off] = (byte)(n >>> 16);
34        bs[++off] = (byte)(n >>>  8);
35        bs[++off] = (byte)(n       );
36    }
37
38    public static byte[] intToBigEndian(int[] ns)
39    {
40        byte[] bs = new byte[4 * ns.length];
41        intToBigEndian(ns, bs, 0);
42        return bs;
43    }
44
45    public static void intToBigEndian(int[] ns, byte[] bs, int off)
46    {
47        for (int i = 0; i < ns.length; ++i)
48        {
49            intToBigEndian(ns[i], bs, off);
50            off += 4;
51        }
52    }
53
54    public static long bigEndianToLong(byte[] bs, int off)
55    {
56        int hi = bigEndianToInt(bs, off);
57        int lo = bigEndianToInt(bs, off + 4);
58        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
59    }
60
61    public static void bigEndianToLong(byte[] bs, int off, long[] ns)
62    {
63        for (int i = 0; i < ns.length; ++i)
64        {
65            ns[i] = bigEndianToLong(bs, off);
66            off += 8;
67        }
68    }
69
70    public static byte[] longToBigEndian(long n)
71    {
72        byte[] bs = new byte[8];
73        longToBigEndian(n, bs, 0);
74        return bs;
75    }
76
77    public static void longToBigEndian(long n, byte[] bs, int off)
78    {
79        intToBigEndian((int)(n >>> 32), bs, off);
80        intToBigEndian((int)(n & 0xffffffffL), bs, off + 4);
81    }
82
83    public static byte[] longToBigEndian(long[] ns)
84    {
85        byte[] bs = new byte[8 * ns.length];
86        longToBigEndian(ns, bs, 0);
87        return bs;
88    }
89
90    public static void longToBigEndian(long[] ns, byte[] bs, int off)
91    {
92        for (int i = 0; i < ns.length; ++i)
93        {
94            longToBigEndian(ns[i], bs, off);
95            off += 8;
96        }
97    }
98
99    public static int littleEndianToInt(byte[] bs, int off)
100    {
101        int n = bs[  off] & 0xff;
102        n |= (bs[++off] & 0xff) << 8;
103        n |= (bs[++off] & 0xff) << 16;
104        n |= bs[++off] << 24;
105        return n;
106    }
107
108    public static void littleEndianToInt(byte[] bs, int off, int[] ns)
109    {
110        for (int i = 0; i < ns.length; ++i)
111        {
112            ns[i] = littleEndianToInt(bs, off);
113            off += 4;
114        }
115    }
116
117    public static byte[] intToLittleEndian(int n)
118    {
119        byte[] bs = new byte[4];
120        intToLittleEndian(n, bs, 0);
121        return bs;
122    }
123
124    public static void intToLittleEndian(int n, byte[] bs, int off)
125    {
126        bs[  off] = (byte)(n       );
127        bs[++off] = (byte)(n >>>  8);
128        bs[++off] = (byte)(n >>> 16);
129        bs[++off] = (byte)(n >>> 24);
130    }
131
132    public static byte[] intToLittleEndian(int[] ns)
133    {
134        byte[] bs = new byte[4 * ns.length];
135        intToLittleEndian(ns, bs, 0);
136        return bs;
137    }
138
139    public static void intToLittleEndian(int[] ns, byte[] bs, int off)
140    {
141        for (int i = 0; i < ns.length; ++i)
142        {
143            intToLittleEndian(ns[i], bs, off);
144            off += 4;
145        }
146    }
147
148    public static long littleEndianToLong(byte[] bs, int off)
149    {
150        int lo = littleEndianToInt(bs, off);
151        int hi = littleEndianToInt(bs, off + 4);
152        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
153    }
154
155    public static void littleEndianToLong(byte[] bs, int off, long[] ns)
156    {
157        for (int i = 0; i < ns.length; ++i)
158        {
159            ns[i] = littleEndianToLong(bs, off);
160            off += 8;
161        }
162    }
163
164    public static byte[] longToLittleEndian(long n)
165    {
166        byte[] bs = new byte[8];
167        longToLittleEndian(n, bs, 0);
168        return bs;
169    }
170
171    public static void longToLittleEndian(long n, byte[] bs, int off)
172    {
173        intToLittleEndian((int)(n & 0xffffffffL), bs, off);
174        intToLittleEndian((int)(n >>> 32), bs, off + 4);
175    }
176
177    public static byte[] longToLittleEndian(long[] ns)
178    {
179        byte[] bs = new byte[8 * ns.length];
180        longToLittleEndian(ns, bs, 0);
181        return bs;
182    }
183
184    public static void longToLittleEndian(long[] ns, byte[] bs, int off)
185    {
186        for (int i = 0; i < ns.length; ++i)
187        {
188            longToLittleEndian(ns[i], bs, off);
189            off += 8;
190        }
191    }
192}
193