Showing 2 of 11 files from the diff.

@@ -0,0 +1,388 @@
Loading
1 +
/*
2 +
*******************************************************************************
3 +
\file bash_prg.c
4 +
\brief STB 34.101.77 (bash): programmable algorithms
5 +
\project bee2 [cryptographic library]
6 +
\author (C) Sergey Agievich [agievich@{bsu.by|gmail.com}]
7 +
\created 2018.10.30
8 +
\version 2020.06.23
9 +
\license This program is released under the GNU General Public License 
10 +
version 3. See Copyright Notices in bee2/info.h.
11 +
*******************************************************************************
12 +
*/
13 +
14 +
#include "bee2/core/blob.h"
15 +
#include "bee2/core/mem.h"
16 +
#include "bee2/core/util.h"
17 +
#include "bee2/crypto/bash.h"
18 +
19 +
/*
20 +
*******************************************************************************
21 +
Программируемые алгоритмы
22 +
23 +
\remark В bash_prg_st::s хранится состояние автомата. Состояние как строка 
24 +
октетов состоит из двух частей:
25 +
1) буфер (первые buf_len октетов);
26 +
2) память (все остальное).
27 +
28 +
Данные загружаются в буфер и выгружаются из буфера блоками по buf_len октетов.
29 +
30 +
В бесключевом режиме память содержит 2dl битов, в ключевом -- (l + dl/2) битов.
31 +
Эти факты используются в функции bashPrgIsKeymode() для проверки того, что
32 +
автомат находится в ключевом режиме.
33 +
34 +
Первый бит памяти является контрольным -- он инвертируется в bashPrgCommit().
35 +
36 +
Длина buf_len в зависимости от параметров и режима:
37 +
38 +
 l  | d | key | keyless
39 +
-----------------------
40 +
128 | 1 | 168 | 160
41 +
128 | 2 | 160 | 128
42 +
192 | 1 | 156 | 144
43 +
192 | 2 | 144 |  96 
44 +
256 | 1 | 144 | 128
45 +
256 | 2 | 128 |  64
46 +
47 +
6-битовые коды NULL, KEY, DATA, TEXT, OUT дополнены (справа) парой битов 01
48 +
и объявлены как BASH_PRG_XXX.
49 +
*******************************************************************************
50 +
*/
51 +
52 +
#define BASH_PRG_NULL		0x01	/* 000000 01 */
53 +
#define BASH_PRG_KEY		0x05	/* 000001 01 */
54 +
#define BASH_PRG_DATA		0x09	/* 000010 01 */
55 +
#define BASH_PRG_TEXT		0x0D	/* 000011 01 */
56 +
#define BASH_PRG_OUT		0x11	/* 000100 01 */
57 +
58 +
typedef struct {
59 +
	size_t l;			/*< уровень стойкости */
60 +
	size_t d;			/*< емкость */
61 +
	octet s[192];		/*< состояние */
62 +
	size_t buf_len;		/*< длина буфера */
63 +
	size_t pos;			/*< позиция в буфере */
64 +
	octet stack[];		/*< max(bashF_deep(), 192) стек bashF/ratchet */
65 +
} bash_prg_st;
66 +
67 +
size_t bashPrg_keep()
68 +
{
69 +
	return sizeof(bash_prg_st) + MAX2(bashF_deep(), 192);
70 +
}
71 +
72 +
/*
73 +
*******************************************************************************
74 +
Вспомогательные функции
75 +
*******************************************************************************
76 +
*/
77 +
78 +
static bool_t bashPrgIsKeymode(const void* state)
79 +
{
80 +
	const bash_prg_st* st = (const bash_prg_st*)state;
81 +
	ASSERT(memIsValid(st, bashPrg_keep()));
82 +
	// (192 - buf_len) ==? (l + d * l / 2) / 8
83 +
	return 16 * (192 - st->buf_len) == st->l * (2 + st->d);
84 +
}
85 +
86 +
/*
87 +
*******************************************************************************
88 +
Commit: завершить предыдущую команду и начать новую с кодом code
89 +
*******************************************************************************
90 +
*/
91 +
92 +
static void bashPrgCommit(octet code, void* state)
93 +
{
94 +
	bash_prg_st* st = (bash_prg_st*)state;
95 +
	ASSERT(memIsValid(st, bashPrg_keep()));
96 +
	ASSERT(st->pos < st->buf_len);
97 +
	// учесть code
98 +
	st->s[st->pos] ^= code;
99 +
	// инвертировать контрольный бит
100 +
	st->s[st->buf_len] ^= 0x80;
101 +
	// применить sponge-функцию
102 +
	bashF(st->s, st->stack);
103 +
	// сбросить pos
104 +
	st->pos = 0;
105 +
}
106 +
107 +
/*
108 +
*******************************************************************************
109 +
Start: инициализировать
110 +
*******************************************************************************
111 +
*/
112 +
113 +
void bashPrgStart(void* state, size_t l, size_t d, const octet ann[],
114 +
	size_t ann_len, const octet key[], size_t key_len)
115 +
{
116 +
	bash_prg_st* st = (bash_prg_st*)state;
117 +
	ASSERT(memIsValid(st, bashPrg_keep()));
118 +
	ASSERT(l == 128 || l == 192 || l == 256);
119 +
	ASSERT(d == 1 || d == 2);
120 +
	ASSERT(ann_len % 4 == 0 && ann_len <= 60);
121 +
	ASSERT(key_len % 4 == 0 && key_len <= 60);
122 +
	ASSERT(key_len == 0 || key_len >= l / 8);
123 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), ann, ann_len));
124 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), key, key_len));
125 +
	// pos <- 8 + |ann| + |key|
126 +
	st->pos = 1 + ann_len + key_len;
127 +
	// s[0..pos) <- <|ann|/2 + |key|/32>_8 || ann || key
128 +
	st->s[0] = (octet)(ann_len * 4 + key_len / 4);
129 +
	memCopy(st->s + 1, ann, ann_len); 
130 +
	memCopy(st->s + 1 + ann_len, key, key_len);
131 +
	// s[pos..) <- 0
132 +
	memSetZero(st->s + st->pos, 192 - st->pos);
133 +
	// s[1472..) <- <l / 4 + d>_{64}
134 +
	st->s[192 - 8] = (octet)(l / 4  + d);
135 +
	// длина буфера
136 +
	st->buf_len = key_len ? (192 - l * (2 + d) / 16) : (192 - d * l / 4);
137 +
	// сохранить параметры
138 +
	st->l = l, st->d = d;
139 +
}
140 +
141 +
/*
142 +
*******************************************************************************
143 +
Restart: повторно инициализировать
144 +
*******************************************************************************
145 +
*/
146 +
147 +
void bashPrgRestart(const octet ann[], size_t ann_len, 
148 +
	const octet key[], size_t key_len, void* state)
149 +
{
150 +
	bash_prg_st* st = (bash_prg_st*)state;
151 +
	ASSERT(memIsValid(st, bashPrg_keep()));
152 +
	ASSERT(ann_len % 4 == 0 && ann_len <= 60);
153 +
	ASSERT(key_len % 4 == 0 && key_len <= 60);
154 +
	ASSERT(key_len == 0 || key_len >= st->l / 8);
155 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), ann, ann_len));
156 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), key, key_len));
157 +
	// вводится ключ?
158 +
	if (key_len)
159 +
	{
160 +
		bashPrgCommit(BASH_PRG_KEY, state);
161 +
		// перейти в ключевой режим (если еще не в нем)
162 +
		st->buf_len = 192 - st->l * (2 + st->d) / 16;
163 +
	}
164 +
	else
165 +
		bashPrgCommit(BASH_PRG_NULL, state);
166 +
	// pos <- 8 + |ann| + |key|
167 +
	st->pos = 1 + ann_len + key_len;
168 +
	// s[0..pos) <- s[0..pos) ^ <|ann|/2 + |key|/32>_8  || ann || key
169 +
	st->s[0] ^= (octet)(ann_len * 4 + key_len / 4);
170 +
	memXor2(st->s + 1, ann, ann_len); 
171 +
	memXor2(st->s + 1 + ann_len, key, key_len);
172 +
}
173 +
174 +
/*
175 +
*******************************************************************************
176 +
Absorb: загрузить
177 +
*******************************************************************************
178 +
*/
179 +
180 +
void bashPrgAbsorbStart(void* state)
181 +
{
182 +
	bashPrgCommit(BASH_PRG_DATA, state);
183 +
}
184 +
185 +
void bashPrgAbsorbStep(const void* buf, size_t count, void* state)
186 +
{
187 +
	bash_prg_st* st = (bash_prg_st*)state;
188 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), buf, count));
189 +
	// не накопился полный буфер?
190 +
	if (count < st->buf_len - st->pos)
191 +
	{
192 +
		memXor2(st->s + st->pos, buf, count);
193 +
		st->pos += count;
194 +
		return;
195 +
	}
196 +
	// новый полный буфер
197 +
	memXor2(st->s + st->pos, buf, st->buf_len - st->pos);
198 +
	buf = (const octet*)buf + st->buf_len - st->pos;
199 +
	count -= st->buf_len - st->pos;
200 +
	bashF(st->s, st->stack);
201 +
	// цикл по полным блокам
202 +
	while (count >= st->buf_len)
203 +
	{
204 +
		memXor2(st->s, buf, st->buf_len);
205 +
		buf = (const octet*)buf + st->buf_len;
206 +
		count -= st->buf_len;
207 +
		bashF(st->s, st->stack);
208 +
	}
209 +
	// неполный блок?
210 +
	if (st->pos = count)
211 +
		memXor2(st->s, buf, count);
212 +
}
213 +
214 +
void bashPrgAbsorb(const void* buf, size_t count, void* state)
215 +
{
216 +
	bashPrgAbsorbStart(state);
217 +
	bashPrgAbsorbStep(buf, count, state);
218 +
}
219 +
220 +
/*
221 +
*******************************************************************************
222 +
Squeeze: выгрузить
223 +
*******************************************************************************
224 +
*/
225 +
226 +
void bashPrgSqueezeStart(void* state)
227 +
{
228 +
	bashPrgCommit(BASH_PRG_OUT, state);
229 +
}
230 +
231 +
void bashPrgSqueezeStep(void* buf, size_t count, void* state)
232 +
{
233 +
	bash_prg_st* st = (bash_prg_st*)state;
234 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), buf, count));
235 +
	// остатка буфера достаточно?
236 +
	if (count < st->buf_len - st->pos)
237 +
	{
238 +
		memCopy(buf, st->s + st->pos, count);
239 +
		st->pos += count;
240 +
		return;
241 +
	}
242 +
	// новый буфер
243 +
	memCopy(buf, st->s + st->pos, st->buf_len - st->pos);
244 +
	buf = (octet*)buf + st->buf_len - st->pos;
245 +
	count -= st->buf_len - st->pos;
246 +
	bashF(st->s, st->stack);
247 +
	// цикл по полным блокам
248 +
	while (count >= st->buf_len)
249 +
	{
250 +
		memCopy(buf, st->s, st->buf_len);
251 +
		buf = (octet*)buf + st->buf_len;
252 +
		count -= st->buf_len;
253 +
		bashF(st->s, st->stack);
254 +
	}
255 +
	// неполный блок
256 +
	if (st->pos = count)
257 +
		memCopy(buf, st->s, count);
258 +
}
259 +
260 +
void bashPrgSqueeze(void* buf, size_t count, void* state)
261 +
{
262 +
	bashPrgSqueezeStart(state);
263 +
	bashPrgSqueezeStep(buf, count, state);
264 +
}
265 +
266 +
/*
267 +
*******************************************************************************
268 +
Encr: зашифровать
269 +
*******************************************************************************
270 +
*/
271 +
272 +
void bashPrgEncrStart(void* state)
273 +
{
274 +
	ASSERT(bashPrgIsKeymode(state));
275 +
	bashPrgCommit(BASH_PRG_TEXT, state);
276 +
}
277 +
278 +
void bashPrgEncrStep(void* buf, size_t count, void* state)
279 +
{
280 +
	bash_prg_st* st = (bash_prg_st*)state;
281 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), buf, count));
282 +
	// остатка буфера достаточно?
283 +
	if (count < st->buf_len - st->pos)
284 +
	{
285 +
		memXor2(st->s + st->pos, buf, count);
286 +
		memCopy(buf, st->s + st->pos, count);
287 +
		st->pos += count;
288 +
		return;
289 +
	}
290 +
	// новый буфер
291 +
	memXor2(st->s + st->pos, buf, st->buf_len - st->pos);
292 +
	memCopy(buf, st->s + st->pos, st->buf_len - st->pos);
293 +
	buf = (octet*)buf + st->buf_len - st->pos;
294 +
	count -= st->buf_len - st->pos;
295 +
	bashF(st->s, st->stack);
296 +
	// цикл по полным блокам
297 +
	while (count >= st->buf_len)
298 +
	{
299 +
		memXor2(st->s, buf, st->buf_len);
300 +
		memCopy(buf, st->s, st->buf_len);
301 +
		buf = (octet*)buf + st->buf_len;
302 +
		count -= st->buf_len;
303 +
		bashF(st->s, st->stack);
304 +
	}
305 +
	// неполный блок
306 +
	if (st->pos = count)
307 +
	{
308 +
		memXor2(st->s, buf, count);
309 +
		memCopy(buf, st->s, count);
310 +
	}
311 +
}
312 +
313 +
void bashPrgEncr(void* buf, size_t count, void* state)
314 +
{
315 +
	bashPrgEncrStart(state);
316 +
	bashPrgEncrStep(buf, count, state);
317 +
}
318 +
319 +
/*
320 +
*******************************************************************************
321 +
Decr: расшифровать
322 +
*******************************************************************************
323 +
*/
324 +
325 +
void bashPrgDecrStart(void* state)
326 +
{
327 +
	ASSERT(bashPrgIsKeymode(state));
328 +
	bashPrgCommit(BASH_PRG_TEXT, state);
329 +
}
330 +
331 +
void bashPrgDecrStep(void* buf, size_t count, void* state)
332 +
{
333 +
	bash_prg_st* st = (bash_prg_st*)state;
334 +
	ASSERT(memIsDisjoint2(st, bashPrg_keep(), buf, count));
335 +
	// остатка буфера достаточно?
336 +
	if (count < st->buf_len - st->pos)
337 +
	{
338 +
		memXor2(buf, st->s + st->pos, count);
339 +
		memXor2(st->s + st->pos, buf, count);
340 +
		st->pos += count;
341 +
		return;
342 +
	}
343 +
	// новый буфер
344 +
	memXor2(buf, st->s + st->pos, st->buf_len - st->pos);
345 +
	memXor2(st->s + st->pos, buf, st->buf_len - st->pos);
346 +
	buf = (octet*)buf + st->buf_len - st->pos;
347 +
	count -= st->buf_len - st->pos;
348 +
	bashF(st->s, st->stack);
349 +
	// цикл по полным блокам
350 +
	while (count >= st->buf_len)
351 +
	{
352 +
		memXor2(buf, st->s, st->buf_len);
353 +
		memXor2(st->s, buf, st->buf_len);
354 +
		buf = (octet*)buf + st->buf_len;
355 +
		count -= st->buf_len;
356 +
		bashF(st->s, st->stack);
357 +
	}
358 +
	// неполный блок
359 +
	if (st->pos = count)
360 +
	{
361 +
		memXor2(buf, st->s, count);
362 +
		memXor2(st->s, buf, count);
363 +
	}
364 +
}
365 +
366 +
void bashPrgDecr(void* buf, size_t count, void* state)
367 +
{
368 +
	bashPrgDecrStart(state);
369 +
	bashPrgDecrStep(buf, count, state);
370 +
}
371 +
372 +
/*
373 +
*******************************************************************************
374 +
Ratchet: необратимо изменить
375 +
*******************************************************************************
376 +
*/
377 +
378 +
void bashPrgRatchet(void* state)
379 +
{
380 +
	bash_prg_st* st = (bash_prg_st*)state;
381 +
	ASSERT(memIsValid(st, bashPrg_keep()));
382 +
	// завершить предыдущую команду
383 +
	bashPrgCommit(BASH_PRG_NULL, state);
384 +
	// необратимо изменить
385 +
	memCopy(st->stack, st->s, 192);
386 +
	bashF(st->s, st->stack);
387 +
	memXor2(st->s, st->stack, 192);
388 +
}

@@ -6,7 +6,7 @@
Loading
6 6
\author (C) Sergey Agievich [agievich@{bsu.by|gmail.com}]
7 7
\author (C) Vlad Semenov [semenov.vlad.by@gmail.com]
8 8
\created 2014.07.15
9 -
\version 2019.07.09
9 +
\version 2020.06.23
10 10
\license This program is released under the GNU General Public License 
11 11
version 3. See Copyright Notices in bee2/info.h.
12 12
*******************************************************************************
@@ -28,9 +28,9 @@
Loading
28 28
typedef struct {
29 29
	octet s[192];		/*< состояние */
30 30
	octet s1[192];		/*< копия s */
31 -
	size_t block_len;	/*< длина блока */
32 -
	size_t filled;		/*< накоплено октетов в блоке */
33 -
	octet stack[];		/*< [[bashF_deep()] стек bashF */
31 +
	size_t buf_len;		/*< длина буфера */
32 +
	size_t pos;		/*< позиция в буфере (накоплено октетов) */
33 +
	octet stack[];		/*< [bashF_deep()] стек bashF */
34 34
} bash_hash_st;
35 35
36 36
size_t bashHash_keep()
@@ -40,86 +40,82 @@
Loading
40 40
41 41
void bashHashStart(void* state, size_t l)
42 42
{
43 -
	bash_hash_st* s = (bash_hash_st*)state;
43 +
	bash_hash_st* st = (bash_hash_st*)state;
44 44
	ASSERT(l > 0 && l % 16 == 0 && l <= 256);
45 -
	ASSERT(memIsValid(s, bashHash_keep()));
45 +
	ASSERT(memIsValid(st, bashHash_keep()));
46 46
	// s <- 0^{1536 - 64} || <l / 4>_{64}
47 -
	memSetZero(s->s, sizeof(s->s));
48 -
	s->s[192 - 8] = (octet)(l / 4);
47 +
	memSetZero(st->s, sizeof(st->s));
48 +
	st->s[192 - 8] = (octet)(l / 4);
49 49
	// длина блока
50 -
	s->block_len = 192 - l / 2;
51 -
	// нет накопленнных данных
52 -
	s->filled = 0;
50 +
	st->buf_len = 192 - l / 2;
51 +
	// нет накопленнных октетов
52 +
	st->pos = 0;
53 53
}
54 54
55 55
void bashHashStepH(const void* buf, size_t count, void* state)
56 56
{
57 -
	bash_hash_st* s = (bash_hash_st*)state;
58 -
	ASSERT(memIsDisjoint2(buf, count, s, bashHash_keep()));
59 -
	// есть накопленные данные?
60 -
	if (s->filled)
57 +
	bash_hash_st* st = (bash_hash_st*)state;
58 +
	ASSERT(memIsDisjoint2(st, bashHash_keep(), buf, count));
59 +
	// не накопился полный буфер?
60 +
	if (count < st->buf_len - st->pos)
61 61
	{
62 -
		if (count < s->block_len - s->filled)
63 -
		{
64 -
			memCopy(s->s + s->filled, buf, count);
65 -
			s->filled += count;
66 -
			return;
67 -
		}
68 -
		memCopy(s->s + s->filled, buf, s->block_len - s->filled);
69 -
		count -= s->block_len - s->filled;
70 -
		buf = (const octet*)buf + s->block_len - s->filled;
71 -
		bashF(s->s, s->stack);
72 -
		s->filled = 0;
62 +
		memCopy(st->s + st->pos, buf, count);
63 +
		st->pos += count;
64 +
		return;
73 65
	}
66 +
	// новый полный буфер
67 +
	memCopy(st->s + st->pos, buf, st->buf_len - st->pos);
68 +
	buf = (const octet*)buf + st->buf_len - st->pos;
69 +
	count -= st->buf_len - st->pos;
70 +
	bashF(st->s, st->stack);
74 71
	// цикл по полным блокам
75 -
	while (count >= s->block_len)
72 +
	while (count >= st->buf_len)
76 73
	{
77 -
		memCopy(s->s, buf, s->block_len);
78 -
		bashF(s->s, s->stack);
79 -
		buf = (const octet*)buf + s->block_len;
80 -
		count -= s->block_len;
74 +
		memCopy(st->s, buf, st->buf_len);
75 +
		buf = (const octet*)buf + st->buf_len;
76 +
		count -= st->buf_len;
77 +
		bashF(st->s, st->stack);
81 78
	}
82 79
	// неполный блок?
83 -
	if (count)
84 -
		memCopy(s->s, buf, s->filled = count);
80 +
	if (st->pos = count)
81 +
		memCopy(st->s, buf, count);
85 82
}
86 83
87 84
static void bashHashStepG_internal(size_t hash_len, void* state)
88 85
{
89 -
	bash_hash_st* s = (bash_hash_st*)state;
90 -
	// pre
91 -
	ASSERT(memIsValid(s, bashHash_keep()));
92 -
	ASSERT(s->block_len + hash_len * 2 <= 192);
93 -
	// создать копию s->s
94 -
	memCopy(s->s1, s->s, sizeof(s->s));
86 +
	bash_hash_st* st = (bash_hash_st*)state;
87 +
	ASSERT(memIsValid(st, bashHash_keep()));
88 +
	ASSERT(st->buf_len + hash_len * 2 <= 192);
89 +
	// создать копию s
90 +
	memCopy(st->s1, st->s, sizeof(st->s));
95 91
	// есть необработанные данные?
96 -
	if (s->filled)
92 +
	if (st->pos)
97 93
	{
98 -
		memSetZero(s->s1 + s->filled, s->block_len - s->filled);
99 -
		s->s1[s->filled] = 0x40;
94 +
		memSetZero(st->s1 + st->pos, st->buf_len - st->pos);
95 +
		st->s1[st->pos] = 0x40;
100 96
	}
101 97
	// дополнительный блок
102 98
	else
103 99
	{
104 -
		memSetZero(s->s1, s->block_len);
105 -
		s->s1[0] = 0x40;
100 +
		memSetZero(st->s1, st->buf_len);
101 +
		st->s1[0] = 0x40;
106 102
	}
107 103
	// последний шаг
108 -
	bashF(s->s1, s->stack);
104 +
	bashF(st->s1, st->stack);
109 105
}
110 106
111 107
void bashHashStepG(octet hash[], size_t hash_len, void* state)
112 108
{
113 -
	bash_hash_st* s = (bash_hash_st*)state;
109 +
	bash_hash_st* st = (bash_hash_st*)state;
114 110
	bashHashStepG_internal(hash_len, state);
115 -
	memMove(hash, s->s1, hash_len);
111 +
	memMove(hash, st->s1, hash_len);
116 112
}
117 113
118 114
bool_t bashHashStepV(const octet hash[], size_t hash_len, void* state)
119 115
{
120 -
	bash_hash_st* s = (bash_hash_st*)state;
116 +
	bash_hash_st* st = (bash_hash_st*)state;
121 117
	bashHashStepG_internal(hash_len, state);
122 -
	return memEq(hash, s->s1, hash_len);
118 +
	return memEq(hash, st->s1, hash_len);
123 119
}
124 120
125 121
err_t bashHash(octet hash[], size_t l, const void* src, size_t count)
Files Coverage
src 84.69%
Project Totals (65 files) 84.69%
112.7
TRAVIS_OS_NAME=linux

No yaml found.

Create your codecov.yml to customize your Codecov experience

Sunburst
The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.
Icicle
The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.
Grid
Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.
Loading