Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_crypto/src/c/pack_unpack.c

8.5 KiB, 1 run

created by r1870400018:208, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1#include "pack_unpack.h"
2#include "api.h"
3#include <string.h>
4
5void POLT2BS(uint8_t bytes[SABER_SCALEBYTES_KEM], const uint16_t data[SABER_N])
6{
7 size_t j, offset_byte, offset_data;
8#if SABER_ET == 3
9 for (j = 0; j < SABER_N / 8; j++)
10 {
11 offset_byte = 3 * j;
12 offset_data = 8 * j;
13 bytes[offset_byte + 0] = (data[offset_data + 0] & 0x7) | ((data[offset_data + 1] & 0x7) << 3) | ((data[offset_data + 2] & 0x3) << 6);
14 bytes[offset_byte + 1] = ((data[offset_data + 2] >> 2) & 0x01) | ((data[offset_data + 3] & 0x7) << 1) | ((data[offset_data + 4] & 0x7) << 4) | (((data[offset_data + 5]) & 0x01) << 7);
15 bytes[offset_byte + 2] = ((data[offset_data + 5] >> 1) & 0x03) | ((data[offset_data + 6] & 0x7) << 2) | ((data[offset_data + 7] & 0x7) << 5);
16 }
17#elif SABER_ET == 4
18 for (j = 0; j < SABER_N / 2; j++)
19 {
20 offset_byte = j;
21 offset_data = 2 * j;
22 bytes[offset_byte] = (data[offset_data] & 0x0f) | ((data[offset_data + 1] & 0x0f) << 4);
23 }
24#elif SABER_ET == 6
25 for (j = 0; j < SABER_N / 4; j++)
26 {
27 offset_byte = 3 * j;
28 offset_data = 4 * j;
29 bytes[offset_byte + 0] = (data[offset_data + 0] & 0x3f) | ((data[offset_data + 1] & 0x03) << 6);
30 bytes[offset_byte + 1] = ((data[offset_data + 1] >> 2) & 0x0f) | ((data[offset_data + 2] & 0x0f) << 4);
31 bytes[offset_byte + 2] = ((data[offset_data + 2] >> 4) & 0x03) | ((data[offset_data + 3] & 0x3f) << 2);
32 }
33#else
34#error "Unsupported SABER parameter."
35#endif
36}
37
38void BS2POLT(const uint8_t bytes[SABER_SCALEBYTES_KEM], uint16_t data[SABER_N])
39{
40 size_t j, offset_byte, offset_data;
41#if SABER_ET == 3
42 for (j = 0; j < SABER_N / 8; j++)
43 {
44 offset_byte = 3 * j;
45 offset_data = 8 * j;
46 data[offset_data + 0] = (bytes[offset_byte + 0]) & 0x07;
47 data[offset_data + 1] = ((bytes[offset_byte + 0]) >> 3) & 0x07;
48 data[offset_data + 2] = (((bytes[offset_byte + 0]) >> 6) & 0x03) | (((bytes[offset_byte + 1]) & 0x01) << 2);
49 data[offset_data + 3] = ((bytes[offset_byte + 1]) >> 1) & 0x07;
50 data[offset_data + 4] = ((bytes[offset_byte + 1]) >> 4) & 0x07;
51 data[offset_data + 5] = (((bytes[offset_byte + 1]) >> 7) & 0x01) | (((bytes[offset_byte + 2]) & 0x03) << 1);
52 data[offset_data + 6] = ((bytes[offset_byte + 2] >> 2) & 0x07);
53 data[offset_data + 7] = ((bytes[offset_byte + 2] >> 5) & 0x07);
54 }
55#elif SABER_ET == 4
56 for (j = 0; j < SABER_N / 2; j++)
57 {
58 offset_byte = j;
59 offset_data = 2 * j;
60 data[offset_data] = bytes[offset_byte] & 0x0f;
61 data[offset_data + 1] = (bytes[offset_byte] >> 4) & 0x0f;
62 }
63#elif SABER_ET == 6
64 for (j = 0; j < SABER_N / 4; j++)
65 {
66 offset_byte = 3 * j;
67 offset_data = 4 * j;
68 data[offset_data + 0] = bytes[offset_byte + 0] & 0x3f;
69 data[offset_data + 1] = ((bytes[offset_byte + 0] >> 6) & 0x03) | ((bytes[offset_byte + 1] & 0x0f) << 2);
70 data[offset_data + 2] = ((bytes[offset_byte + 1] & 0xff) >> 4) | ((bytes[offset_byte + 2] & 0x03) << 4);
71 data[offset_data + 3] = ((bytes[offset_byte + 2] & 0xff) >> 2);
72 }
73#else
74#error "Unsupported SABER parameter."
75#endif
76}
77
78static void POLq2BS(uint8_t bytes[SABER_POLYBYTES], const uint16_t data[SABER_N])
79{
80 size_t j, offset_byte, offset_data;
81 for (j = 0; j < SABER_N / 8; j++)
82 {
83 offset_byte = 13 * j;
84 offset_data = 8 * j;
85 bytes[offset_byte + 0] = (data[offset_data + 0] & (0xff));
86 bytes[offset_byte + 1] = ((data[offset_data + 0] >> 8) & 0x1f) | ((data[offset_data + 1] & 0x07) << 5);
87 bytes[offset_byte + 2] = ((data[offset_data + 1] >> 3) & 0xff);
88 bytes[offset_byte + 3] = ((data[offset_data + 1] >> 11) & 0x03) | ((data[offset_data + 2] & 0x3f) << 2);
89 bytes[offset_byte + 4] = ((data[offset_data + 2] >> 6) & 0x7f) | ((data[offset_data + 3] & 0x01) << 7);
90 bytes[offset_byte + 5] = ((data[offset_data + 3] >> 1) & 0xff);
91 bytes[offset_byte + 6] = ((data[offset_data + 3] >> 9) & 0x0f) | ((data[offset_data + 4] & 0x0f) << 4);
92 bytes[offset_byte + 7] = ((data[offset_data + 4] >> 4) & 0xff);
93 bytes[offset_byte + 8] = ((data[offset_data + 4] >> 12) & 0x01) | ((data[offset_data + 5] & 0x7f) << 1);
94 bytes[offset_byte + 9] = ((data[offset_data + 5] >> 7) & 0x3f) | ((data[offset_data + 6] & 0x03) << 6);
95 bytes[offset_byte + 10] = ((data[offset_data + 6] >> 2) & 0xff);
96 bytes[offset_byte + 11] = ((data[offset_data + 6] >> 10) & 0x07) | ((data[offset_data + 7] & 0x1f) << 3);
97 bytes[offset_byte + 12] = ((data[offset_data + 7] >> 5) & 0xff);
98 }
99}
100
101static void BS2POLq(const uint8_t bytes[SABER_POLYBYTES], uint16_t data[SABER_N])
102{
103 size_t j, offset_byte, offset_data;
104 for (j = 0; j < SABER_N / 8; j++)
105 {
106 offset_byte = 13 * j;
107 offset_data = 8 * j;
108 data[offset_data + 0] = (bytes[offset_byte + 0] & (0xff)) | ((bytes[offset_byte + 1] & 0x1f) << 8);
109 data[offset_data + 1] = (bytes[offset_byte + 1] >> 5 & (0x07)) | ((bytes[offset_byte + 2] & 0xff) << 3) | ((bytes[offset_byte + 3] & 0x03) << 11);
110 data[offset_data + 2] = (bytes[offset_byte + 3] >> 2 & (0x3f)) | ((bytes[offset_byte + 4] & 0x7f) << 6);
111 data[offset_data + 3] = (bytes[offset_byte + 4] >> 7 & (0x01)) | ((bytes[offset_byte + 5] & 0xff) << 1) | ((bytes[offset_byte + 6] & 0x0f) << 9);
112 data[offset_data + 4] = (bytes[offset_byte + 6] >> 4 & (0x0f)) | ((bytes[offset_byte + 7] & 0xff) << 4) | ((bytes[offset_byte + 8] & 0x01) << 12);
113 data[offset_data + 5] = (bytes[offset_byte + 8] >> 1 & (0x7f)) | ((bytes[offset_byte + 9] & 0x3f) << 7);
114 data[offset_data + 6] = (bytes[offset_byte + 9] >> 6 & (0x03)) | ((bytes[offset_byte + 10] & 0xff) << 2) | ((bytes[offset_byte + 11] & 0x07) << 10);
115 data[offset_data + 7] = (bytes[offset_byte + 11] >> 3 & (0x1f)) | ((bytes[offset_byte + 12] & 0xff) << 5);
116 }
117}
118
119static void POLp2BS(uint8_t bytes[SABER_POLYCOMPRESSEDBYTES], const uint16_t data[SABER_N])
120{
121 size_t j, offset_byte, offset_data;
122 for (j = 0; j < SABER_N / 4; j++)
123 {
124 offset_byte = 5 * j;
125 offset_data = 4 * j;
126 bytes[offset_byte + 0] = (data[offset_data + 0] & (0xff));
127 bytes[offset_byte + 1] = ((data[offset_data + 0] >> 8) & 0x03) | ((data[offset_data + 1] & 0x3f) << 2);
128 bytes[offset_byte + 2] = ((data[offset_data + 1] >> 6) & 0x0f) | ((data[offset_data + 2] & 0x0f) << 4);
129 bytes[offset_byte + 3] = ((data[offset_data + 2] >> 4) & 0x3f) | ((data[offset_data + 3] & 0x03) << 6);
130 bytes[offset_byte + 4] = ((data[offset_data + 3] >> 2) & 0xff);
131 }
132}
133
134static void BS2POLp(const uint8_t bytes[SABER_POLYCOMPRESSEDBYTES], uint16_t data[SABER_N])
135{
136 size_t j, offset_byte, offset_data;
137 for (j = 0; j < SABER_N / 4; j++)
138 {
139 offset_byte = 5 * j;
140 offset_data = 4 * j;
141 data[offset_data + 0] = (bytes[offset_byte + 0] & (0xff)) | ((bytes[offset_byte + 1] & 0x03) << 8);
142 data[offset_data + 1] = ((bytes[offset_byte + 1] >> 2) & (0x3f)) | ((bytes[offset_byte + 2] & 0x0f) << 6);
143 data[offset_data + 2] = ((bytes[offset_byte + 2] >> 4) & (0x0f)) | ((bytes[offset_byte + 3] & 0x3f) << 4);
144 data[offset_data + 3] = ((bytes[offset_byte + 3] >> 6) & (0x03)) | ((bytes[offset_byte + 4] & 0xff) << 2);
145 }
146}
147
148void POLVECq2BS(uint8_t bytes[SABER_POLYVECBYTES], const uint16_t data[SABER_L][SABER_N])
149{
150 size_t i;
151 for (i = 0; i < SABER_L; i++)
152 {
153 POLq2BS(bytes + i * SABER_POLYBYTES, data[i]);
154 }
155}
156
157void BS2POLVECq(const uint8_t bytes[SABER_POLYVECBYTES], uint16_t data[SABER_L][SABER_N])
158{
159 size_t i;
160 for (i = 0; i < SABER_L; i++)
161 {
162 BS2POLq(bytes + i * SABER_POLYBYTES, data[i]);
163 }
164}
165
166void POLVECp2BS(uint8_t bytes[SABER_POLYVECCOMPRESSEDBYTES], const uint16_t data[SABER_L][SABER_N])
167{
168 size_t i;
169 for (i = 0; i < SABER_L; i++)
170 {
171 POLp2BS(bytes + i * (SABER_EP * SABER_N / 8), data[i]);
172 }
173}
174
175void BS2POLVECp(const uint8_t bytes[SABER_POLYVECCOMPRESSEDBYTES], uint16_t data[SABER_L][SABER_N])
176{
177 size_t i;
178 for (i = 0; i < SABER_L; i++)
179 {
180 BS2POLp(bytes + i * (SABER_EP * SABER_N / 8), data[i]);
181 }
182}
183
184void BS2POLmsg(const uint8_t bytes[SABER_KEYBYTES], uint16_t data[SABER_N])
185{
186 size_t i, j;
187 for (j = 0; j < SABER_KEYBYTES; j++)
188 {
189 for (i = 0; i < 8; i++)
190 {
191 data[j * 8 + i] = ((bytes[j] >> i) & 0x01);
192 }
193 }
194}
195
196void POLmsg2BS(uint8_t bytes[SABER_KEYBYTES], const uint16_t data[SABER_N])
197{
198 size_t i, j;
199 memset(bytes, 0, SABER_KEYBYTES);
200
201 for (j = 0; j < SABER_KEYBYTES; j++)
202 {
203 for (i = 0; i < 8; i++)
204 {
205 bytes[j] = bytes[j] | ((data[j * 8 + i] & 0x01) << i);
206 }
207 }
208}
209
210void hexdump(char *str, uint8_t *bytes, const int start, const int end)
211{
212 printf("%s start: %d end: %d\n", str, start, end);
213 uint64_t j = 0;
214 for(int i=start; i<end; i++)
215 {
216 printf(" %02x", bytes[i]);
217 j += 1;
218 if(j == 16){
219 printf("\n");
220 j = 0;
221 }
222 }
223}
224
225void hexdump2(char *str, uint16_t *bytes, const int start, const int end)
226{
227 printf("%s start: %d end: %d\n", str, start, end);
228 uint64_t j = 0;
229 for(int i=start; i<end; i++)
230 {
231 printf(" %04x", bytes[i]);
232 j += 1;
233 if(j == 16){
234 printf("\n");
235 j = 0;
236 }
237 }
238}