1belt.h(3) Library Functions Manual belt.h(3)
2
6 belt.h - Алгоритмы СТБ 34.101.31 (belt)
7
10 #include 'bee2/defs.h'
11 Макросы
14 #define beltCTRStepD beltCTRStepE
15 Расшифрование фрагмента в режиме CTR.
16 Функции
21 const octet * beltH ()
22 Блок подстановки H.
23 void beltKeyExpand (octet key_[32], const octet key[], size_t len)
24 Расширение ключа
25 void beltKeyExpand2 (u32 key_[8], const octet key[], size_t len)
26 Расширение и форматирование ключа
27 void beltBlockEncr (octet block[16], const u32 key[8])
28 Зашифрование блока
29 void beltBlockEncr2 (u32 block[4], const u32 key[8])
30 Зашифрование форматированного блока
31 void beltBlockEncr3 (u32 *a, u32 *b, u32 *c, u32 *d, const u32 key[8])
32 Зашифрование блока из четверки слов
33 void beltBlockDecr (octet block[16], const u32 key[8])
34 Расшифрование блока
35 void beltBlockDecr2 (u32 block[4], const u32 key[8])
36 Расшифрование форматированного блока
37 void beltBlockDecr3 (u32 *a, u32 *b, u32 *c, u32 *d, const u32 key[8])
38 Расшифрование блока из четверки слов
39 size_t beltWBL_keep ()
40 Длина состояния функций WBL.
41 void beltWBLStart (void *state, const octet key[], size_t len)
42 Инициализация функций WBL.
43 void beltWBLStepE (void *buf, size_t count, void *state)
44 Зашифрование в режиме WBL.
45 void beltWBLStepD (void *buf, size_t count, void *state)
46 Расшифрование в режиме WBL.
47 void beltWBLStepD2 (void *buf1, void *buf2, size_t count, void *state)
48 Расшифрование в режиме WBL с двумя частями
49 void beltWBLStepR (void *buf, size_t count, void *state)
50 Продолженное зашифрование в режиме WBL.
51 size_t beltCompr_deep ()
52 Глубина стека функций сжатия
53 void beltCompr (u32 h[8], const u32 X[8], void *stack)
54 Сжатие форматированных данных
55 void beltCompr2 (u32 s[4], u32 h[8], const u32 X[8], void *stack)
56 Сжатие форматированных данных со сложением
57 size_t beltECB_keep ()
58 Длина состояния функций ECB.
59 void beltECBStart (void *state, const octet key[], size_t len)
60 Инициализация шифрования в режиме ECB.
61 void beltECBStepE (void *buf, size_t count, void *state)
62 Зашифрование фрагмента в режиме ECB.
63 void beltECBStepD (void *buf, size_t count, void *state)
64 Расшифрование в режиме ECB.
65 err_t beltECBEncr (void *dest, const void *src, size_t count, const
66 octet key[], size_t len)
67 Зашифрование в режиме ECB.
68 err_t beltECBDecr (void *dest, const void *src, size_t count, const
69 octet key[], size_t len)
70 Расшифрование в режиме ECB.
71 size_t beltCBC_keep ()
72 Длина состояния функций CBC.
73 void beltCBCStart (void *state, const octet key[], size_t len, const
74 octet iv[16])
75 Инициализация шифрования в режиме CBC.
76 void beltCBCStepE (void *buf, size_t count, void *state)
77 Зашифрование в режиме CBC.
78 void beltCBCStepD (void *buf, size_t count, void *state)
79 Расшифрование в режиме CBC.
80 err_t beltCBCEncr (void *dest, const void *src, size_t count, const
81 octet key[], size_t len, const octet iv[16])
82 Зашифрование в режиме CBC.
83 err_t beltCBCDecr (void *dest, const void *src, size_t count, const
84 octet key[], size_t len, const octet iv[16])
85 Расшифрование в режиме CBC.
86 size_t beltCFB_keep ()
87 Длина состояния функций CFB.
88 void beltCFBStart (void *state, const octet key[], size_t len, const
89 octet iv[16])
90 Инициализация шифрования в режиме CFB.
91 void beltCFBStepE (void *buf, size_t count, void *state)
92 Зашифрование в режиме CFB.
93 void beltCFBStepD (void *buf, size_t count, void *state)
94 Расшифрование в режиме CFB.
95 err_t beltCFBEncr (void *dest, const void *src, size_t count, const
96 octet key[], size_t len, const octet iv[16])
97 Зашифрование в режиме CFB.
98 err_t beltCFBDecr (void *dest, const void *src, size_t count, const
99 octet key[], size_t len, const octet iv[16])
100 Расшифрование в режиме CFB.
101 size_t beltCTR_keep ()
102 Длина состояния функций CTR.
103 void beltCTRStart (void *state, const octet key[], size_t len, const
104 octet iv[16])
105 Инициализация шифрования в режиме CTR.
106 void beltCTRStepE (void *buf, size_t count, void *state)
107 Зашифрование фрагмента в режиме CTR.
108 err_t beltCTR (void *dest, const void *src, size_t count, const octet
109 key[], size_t len, const octet iv[16])
110 Шифрование в режиме CTR.
111 size_t beltMAC_keep ()
112 Длина состояния функций MAC.
113 void beltMACStart (void *state, const octet key[], size_t len)
114 Инициализация функций MAC.
115 void beltMACStepA (const void *buf, size_t count, void *state)
116 Имитозащита фрагмента данных в режиме MAC.
117 void beltMACStepG (octet mac[8], void *state)
118 Определение имитовставки в режиме MAC.
119 void beltMACStepG2 (octet mac[], size_t mac_len, void *state)
120 Определение усеченной имитовставки в режиме MAC.
121 bool_t beltMACStepV (const octet mac[8], void *state)
122 Проверка имитовставки в режиме MAC.
123 bool_t beltMACStepV2 (const octet mac[], size_t mac_len, void *state)
124 Проверка усеченной имитовставки
125 err_t beltMAC (octet mac[8], const void *src, size_t count, const octet
126 key[], size_t len)
127 Имитозащита в режиме MAC.
128 size_t beltDWP_keep ()
129 Длина состояния функций DWP.
130 void beltDWPStart (void *state, const octet key[], size_t len, const
131 octet iv[16])
132 Инициализация функций DWP.
133 void beltDWPStepE (void *buf, size_t count, void *state)
134 Зашифрование критического фрагмента в режиме DWP.
135 void beltDWPStepI (const void *buf, size_t count, void *state)
136 Имитозащита открытого фрагмента в режиме DWP.
137 void beltDWPStepA (const void *buf, size_t count, void *state)
138 Имитозащита критического фрагмента в режиме DWP.
139 void beltDWPStepG (octet mac[8], void *state)
140 Определение имитовставки в режиме DWP.
141 bool_t beltDWPStepV (const octet mac[8], void *state)
142 Проверка имитовставки в режиме DWP.
143 void beltDWPStepD (void *buf, size_t count, void *state)
144 Расшифрование критического фрагмента в режиме DWP.
145 err_t beltDWPWrap (void *dest, octet mac[8], const void *src1, size_t
146 count1, const void *src2, size_t count2, const octet key[], size_t
147 len, const octet iv[16])
148 Установка защиты в режиме DWP.
149 err_t beltDWPUnwrap (void *dest, const void *src1, size_t count1, const
150 void *src2, size_t count2, const octet mac[8], const octet key[],
151 size_t len, const octet iv[16])
152 Снятие защиты в режиме DWP.
153 size_t beltCHE_keep ()
154 Длина состояния функций CHE.
155 void beltCHEStart (void *state, const octet key[], size_t len, const
156 octet iv[16])
157 Инициализация функций CHE.
158 void beltCHEStepE (void *buf, size_t count, void *state)
159 Зашифрование критического фрагмента в режиме CHE.
160 void beltCHEStepI (const void *buf, size_t count, void *state)
161 Имитозащита открытого фрагмента в режиме CHE.
162 void beltCHEStepA (const void *buf, size_t count, void *state)
163 Имитозащита критического фрагмента в режиме CHE.
164 void beltCHEStepG (octet mac[8], void *state)
165 Определение имитовставки в режиме CHE.
166 bool_t beltCHEStepV (const octet mac[8], void *state)
167 Проверка имитовставки в режиме CHE.
168 void beltCHEStepD (void *buf, size_t count, void *state)
169 Расшифрование критического фрагмента в режиме CHE.
170 err_t beltCHEWrap (void *dest, octet mac[8], const void *src1, size_t
171 count1, const void *src2, size_t count2, const octet key[], size_t
172 len, const octet iv[16])
173 Установка защиты в режиме CHE.
174 err_t beltCHEUnwrap (void *dest, const void *src1, size_t count1, const
175 void *src2, size_t count2, const octet mac[8], const octet key[],
176 size_t len, const octet iv[16])
177 Снятие защиты в режиме CHE.
178 err_t beltKWPWrap (octet dest[], const octet src[], size_t count, const
179 octet header[16], const octet key[], size_t len)
180 Установка защиты в режиме KWP.
181 err_t beltKWPUnwrap (octet dest[], const octet src[], size_t count,
182 const octet header[16], const octet key[], size_t len)
183 Снятие защиты в режиме KWP.
184 size_t beltHash_keep ()
185 Длина состояния функции хэширования
186 void beltHashStart (void *state)
187 Инициализация функции хэширования
188 void beltHashStepH (const void *buf, size_t count, void *state)
189 Хэширование фрагмента данных
190 void beltHashStepG (octet hash[32], void *state)
191 Определение хэш-значения
192 void beltHashStepG2 (octet hash[], size_t hash_len, void *state)
193 Определение усеченного хэш-значения
194 bool_t beltHashStepV (const octet hash[32], void *state)
195 Проверка хэш-значения
196 bool_t beltHashStepV2 (const octet hash[], size_t hash_len, void
197 *state)
198 Проверка усеченного хэш-значения
199 err_t beltHash (octet hash[32], const void *src, size_t count)
200 Хэширование
201 size_t beltBDE_keep ()
202 Длина состояния функций BDE.
203 void beltBDEStart (void *state, const octet key[], size_t len, const
204 octet iv[16])
205 Инициализация шифрования в режиме BDE.
206 void beltBDEStepE (void *buf, size_t count, void *state)
207 Шаг зашифрования в режиме BDE.
208 void beltBDEStepD (void *buf, size_t count, void *state)
209 Шаг расшифрования в режиме BDE.
210 err_t beltBDEEncr (void *dest, const void *src, size_t count, const
211 octet key[], size_t len, const octet iv[16])
212 Зашифрование в режиме BDE.
213 err_t beltBDEDecr (void *dest, const void *src, size_t count, const
214 octet key[], size_t len, const octet iv[16])
215 Расшифрование в режиме BDE.
216 size_t beltSDE_keep ()
217 Длина состояния функций SDE.
218 void beltSDEStart (void *state, const octet key[], size_t len)
219 Инициализация шифрования в режиме SDE.
220 void beltSDEStepE (void *buf, size_t count, const octet iv[16], void
221 *state)
222 Шаг зашифрования в режиме SDE.
223 void beltSDEStepD (void *buf, size_t count, const octet iv[16], void
224 *state)
225 Шаг расшифрования в режиме SDE.
226 err_t beltSDEEncr (void *dest, const void *src, size_t count, const
227 octet key[], size_t len, const octet iv[16])
228 Зашифрование в режиме SDE.
229 err_t beltSDEDecr (void *dest, const void *src, size_t count, const
230 octet key[], size_t len, const octet iv[16])
231 Расшифрование в режиме SDE.
232 size_t beltFMT_keep (u32 mod, size_t count)
233 Длина состояния функций FMT.
234 void beltFMTStart (void *state, u32 mod, size_t count, const octet
235 key[], size_t len)
236 Инициализация шифрования в режиме FMT.
237 void beltFMTStepE (u16 buf[], const octet iv[16], void *state)
238 Шаг зашифрования в режиме FMT.
239 void beltFMTStepD (u16 buf[], const octet iv[16], void *state)
240 Шаг расшифрования в режиме FMT.
241 err_t beltFMTEncr (u16 dest[], u32 mod, const u16 src[], size_t count,
242 const octet key[], size_t len, const octet iv[16])
243 Зашифрование в режиме FMT.
244 err_t beltFMTDecr (u16 dest[], u32 mod, const u16 src[], size_t count,
245 const octet key[], size_t len, const octet iv[16])
246 Расшифрование в режиме FMT.
247 size_t beltKRP_keep ()
248 Длина состояния функций преобразования ключа
249 void beltKRPStart (void *state, const octet key[], size_t len, const
250 octet level[12])
251 Инициализация функций преобразования ключа
252 void beltKRPStepG (octet key_[], size_t key_len, const octet
253 header[16], void *state)
254 Тиражирование ключа
255 err_t beltKRP (octet dest[], size_t m, const octet src[], size_t n,
256 const octet level[12], const octet header[16])
257 Преобразование ключа
258 size_t beltHMAC_keep ()
259 Длина состояния функций HMAC.
260 void beltHMACStart (void *state, const octet key[], size_t len)
261 Инициализация функций HMAC.
262 void beltHMACStepA (const void *buf, size_t count, void *state)
263 Имитозащита фрагмента данных в режиме HMAC.
264 void beltHMACStepG (octet mac[32], void *state)
265 Определение имитовставки в режиме HMAC.
266 void beltHMACStepG2 (octet mac[], size_t mac_len, void *state)
267 Определение усеченной имитовставки в режиме HMAC.
268 bool_t beltHMACStepV (const octet mac[32], void *state)
269 Проверка имитовставки в режиме HMAC.
270 bool_t beltHMACStepV2 (const octet mac[], size_t mac_len, void *state)
271 Проверка усеченной имитовставки
272 err_t beltHMAC (octet mac[32], const void *src, size_t count, const
273 octet key[], size_t len)
274 Имитозащита в режиме HMAC.
275 err_t beltPBKDF2 (octet key[32], const octet pwd[], size_t pwd_len,
276 size_t iter, const octet salt[], size_t salt_len)
277 Построение ключа по паролю
278
280 Реализованы алгоритмы СТБ 34.101.31 (belt). Дополнительно реализованы
281 алгоритм ключезависимого хэширования (HMAC), основанный на функции
282 хэширования belt-hash, и алгоритм построения ключа по паролю,
283 основанный на HMAC[belt-hash]. Эти алгоритмы определены соответственно
284 в СТБ 34.101.47 и в СТБ 34.101.45.
285 Основные алгоритмы объединяются в группы, которые определяют следующие
287 криптографические механизмы:
288 • ECB --- шифрование в режиме простой замены;
290 • CBC --- шифрование в режиме сцепления блоков;
292 • CFB --- шифрование в режиме гаммирования с обратной связью;
294 • CTR --- шифрование в режиме счетчика;
296 • MAC --- имитозащита на основе шифрования;
298 • DWP --- аутентифицированное шифрование данных, схема DWP;
300 • CHE --- аутентифицированное шифрование данных, схема CHE;
302 • KWP --- аутентифицированное шифрование ключей;
304 • Hash --- хэширование;
306 • BDE --- блоковое дисковое шифрование;
308 • SDE --- секторное дисковое шифрование;
310 • FMT --- шифрование с сохранением формата;
312 • KRP --- преобразование ключей;
314 • HMAC --- имитозащита на основе хэширования.
316 Механизмы построены на базовых криптографических алгоритмах шифрования
318 блока (Block), шифрования широкого блока (WBL) и сжатия (Compr).
319 Механизм WBL определен в новой редакции СТБ 34.101.31 и представляет
320 собой ядро KWP.
321 В механизмах ECB, CBC, CFB, CTR, MAC, DWP, CHE, KWP, BDE, SDE, FMT, KRP
323 используется ключ из 32 октетов. Ключ такой длины может быть построен
324 по ключу из 16 или 24 октетов с помощью функции beltExpand().
325 В механизме HMAC используется ключ произвольной длины. Рекомендуется
327 использовать ключ из 32 октетов.
328 В механизмах ECB, CBC, CFB, CTR, MAC, DWP, CHE, KWP, BDE данные
330 обрабатываются блоками по 16 октетов.
331 В механизмах Hash, HMAC данные обрабатываются блоками по 32 октета.
333 В механизме SDE обрабатываются секторы. Сектор состоит из двух или
335 более полных 16-октетных блоков.
336 В механизме FMT обрабатываются строки длины count в алфавите ZZ_mod =
338 {0, 1,..., mod - 1}. Здесь mod -- размер алфавита или модуль. Должны
339 выполняться следующие ограничения:
340 • 2 <= mod && mod <= 65536;
342 • 2 <= count && count <= 600. Последнее ограничение -- ограничение
344 реализации.
345 На вход основных и вспомогательных функций данные и ключи подаются либо
347 как void-массивы (неформатированные данные, по умолчанию), либо как
348 массивы u32 (форматированные данные). Внутри функций неформатированные
349 данные форматируются перед использованием. На платформах с соглашениями
350 BIG_ENDIAN форматирование требует дополнительного времени.
351 Каждый механизм реализуется связкой из нескольких функций. Эти функции
353 используют общее состояние, указатель на которое передается в функции
354 как дополнительный параметр. Имеются функция определения объема памяти
355 для состояния (_keep). Память для состояния готовит вызывающая
356 программа и она же отвечает за очистку памяти.
357 Состояние можно копировать как фрагмент памяти.
359 В связке обязательно имеется функция инициализации механизма (Start) и
361 одна или несколько функций обработки фрагментов данных и получения
362 результатов обработки (StepX).
363 Логика суффиксов функций StepX:
365 • E -- encrypt (зашифровать);
367 • D -- decrypt (расшифровать);
369 • A -- authenticate (имитозащита);
371 • I -- имитозащита открытых данных в режиме DWP;
373 • H -- hashing (хэширование);
375 • G -- get (получить имитовставку, хэш-значение или новый ключ);
377 • V -- verify (проверить хэш-значение, имитовставку);
379 • R -- random (псевдослучайная генерация).
381 Функции связки спроектированы как максимально простые и эффективные. В
383 частности, в этих функциях не проверяются входные данные.
384 Каждая связка покрывается высокоуровневой функцией, которая
386 обрабатывает все данные целиком. В высокоуровневых функциях есть
387 проверка входных данных.
388 Механизмы MAC, Hash, HMAC, DWP, CHE реализованы с поддержкой принципа
390 get-then-continue. Это означает, что после обработки определенной
391 порции данных можно вызвать функцию типа StepG, а затем продолжить
392 обработку.
393 Ожидается
395 Общее состояние связки функций не изменяется вне этих функций.
396 Ожидается [ERR_BAD_INPUT]
398 Все входные указатели высокоуровневых функций действительны.
399 Предусловие
401 Все входные указатели низкоуровневых функций действительны.
402 Если не оговорено противное, то входные буферы функций связки не
404 пересекаются.
405
407 #define beltCTRStepD beltCTRStepE
408 Прим.
409 Зашифрование в режиме CTR не отличается от расшифрования.
410 #define beltKWP_keep beltWBL_keep
412 Прим.
413 Повторяются функции механизма WBL.
414
416 size_t beltBDE_keep ()
417 Возвращается длина состояния (в октетах) функций шифрования в режиме
418 BDE.
419 Возвращает
421 Длина состояние.
422 err_t beltBDEDecr (void * dest, const void * src, size_t count, const octet
424 key[], size_t len, const octet iv[16])
425 Буфер [count]src расшифровывается на ключе [len]key с использованием
426 синхропосылки iv. Результат расшифрования размещается в буфере
427 [count]dest.
428 Ожидается [ERR_BAD_INPUT]
430 • len == 16 || len == 24 || len == 32;
433 • count % 16 == 0 && count >= 16.
435 Возвращает
437 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
438 случае.
439 Прим.
441 Буферы могут пересекаться.
442 Аргументы
444 dest открытый текст
445 src шифртекст
446 count число октетов текста
447 key ключ
448 len длина ключа
449 iv синхропосылка
450 err_t beltBDEEncr (void * dest, const void * src, size_t count, const octet
452 key[], size_t len, const octet iv[16])
453 Буфер [count]src зашифровывается на ключе [len]key с использованием
454 синхропосылки iv. Результат зашифрования размещается в буфере
455 [count]dest.
456 Ожидается [ERR_BAD_INPUT]
458 • len == 16 || len == 24 || len == 32;
461 • count % 16 == 0 && count >= 16.
463 Возвращает
465 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
466 случае.
467 Прим.
469 Буферы могут пересекаться.
470 Аргументы
472 dest шифртекст
473 src открытый текст
474 count число октетов текста
475 key ключ
476 len длина ключа
477 iv синхропосылка
478 void beltBDEStart (void * state, const octet key[], size_t len, const octet
480 iv[16])
481 По ключу [len]key и синхропосылке iv в state формируются структуры
482 данных, необходимые для шифрования в режиме BDE.
483 Предусловие
485 len == 16 || len == 24 || len == 32.
486 По адресу state зарезервировано beltBDE_keep() октетов.
488 Прим.
490 Буферы key и state могут пересекаться.
491 Аргументы
493 state состояние
494 key ключ
495 len длина ключа в октетах
496 iv синхропосылка
497 void beltBDEStepD (void * buf, size_t count, void * state)
499 Буфер [count]buf расшифровывается в режиме BDE на ключе, размещенном в
500 state.
501 Предусловие
503 count % 16 == 0.
504 Ожидается
506 beltBDEStart() < beltBDEStepD()*.
507 Аргументы
509 buf шифртекст / открытый текст
510 count число октетов текста
511 state состояние
512 void beltBDEStepE (void * buf, size_t count, void * state)
514 Буфер [count]buf зашифровывается в режиме BDE на ключе, размещенном в
515 state.
516 Предусловие
518 count % 16 == 0.
519 Ожидается
521 beltBDEStart() < beltBDEStepE()*.
522 Аргументы
524 buf открытый текст / шифртекст
525 count число октетов текста
526 state состояние
527 void beltBlockDecr (octet block[16], const u32 key[8])
529 Выполняется расшифрование блока данных block на форматированном ключе
530 key. Результат расшифрования возвращается по адресу block.
531 Аргументы
533 block блок
534 key ключ
535 void beltBlockDecr2 (u32 block[4], const u32 key[8])
537 Выполняется расшифрование форматированного блока данных block на
538 форматированном ключе key. Результат расшифрования возвращается по
539 адресу block.
540 Аргументы
542 block блок
543 key ключ
544 void beltBlockDecr3 (u32 * a, u32 * b, u32 * c, u32 * d, const u32 key[8])
546 Выполняется расшифрование форматированного блока (a, b, c, d),
547 заданного четверкой последовательных 32-разрядных слов, на
548 форматированном ключе key. Результат расшифрования возвращается через
549 входные слова.
550 Аргументы
552 a слово a
553 b слово b
554 c слово c
555 d слово d
556 key ключ
557 void beltBlockEncr (octet block[16], const u32 key[8])
559 Выполняется зашифрование блока данных block на форматированном ключе
560 key. Результат зашифрования возвращается по адресу block.
561 Аргументы
563 block блок
564 key ключ
565 void beltBlockEncr2 (u32 block[4], const u32 key[8])
567 Выполняется зашифрование форматированного блока данных block на
568 форматированном ключе key. Результат зашифрования возвращается по
569 адресу block.
570 Аргументы
572 block блок
573 key ключ
574 void beltBlockEncr3 (u32 * a, u32 * b, u32 * c, u32 * d, const u32 key[8])
576 Выполняется зашифрование форматированного блока (a, b, c, d), заданного
577 четверкой последовательных 32-разрядных слов, на форматированном ключе
578 key. Результат зашифрования возвращается через входные слова.
579 Аргументы
581 a слово a
582 b слово b
583 c слово c
584 d слово d
585 key ключ
586 size_t beltCBC_keep ()
588 Возвращается длина состояния (в октетах) функций шифрования в режиме
589 CBC.
590 Возвращает
592 Длина состояние.
593 err_t beltCBCDecr (void * dest, const void * src, size_t count, const octet
595 key[], size_t len, const octet iv[16])
596 Буфер [count]src расшифровывается на ключе [len]key с использованием
597 синхропосылки iv. Результат расшифрования размещается в буфере
598 [count]dest.
599 Ожидается [ERR_BAD_INPUT]
601 • len == 16 || len == 24 || len == 32;
604 • count >= 16.
606 Возвращает
608 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
609 случае.
610 Прим.
612 Буферы могут пересекаться.
613 Аргументы
615 dest открытый текст
616 src шифртекст
617 count число октетов текста
618 key ключ
619 len длина ключа
620 iv синхропосылка
621 err_t beltCBCEncr (void * dest, const void * src, size_t count, const octet
623 key[], size_t len, const octet iv[16])
624 Буфер [count]src зашифровывается на ключе [len]key с использованием
625 синхропосылки iv. Результат зашифрования размещается в буфере
626 [count]dest.
627 Ожидается [ERR_BAD_INPUT]
629 • len == 16 || len == 24 || len == 32;
632 • count >= 16.
634 Возвращает
636 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
637 случае.
638 Прим.
640 Буферы могут пересекаться.
641 Аргументы
643 dest шифртекст
644 src открытый текст
645 count число октетов текста
646 key ключ
647 len длина ключа
648 iv синхропосылка
649 void beltCBCStart (void * state, const octet key[], size_t len, const octet
651 iv[16])
652 По ключу [len]key и синхропосылке iv в state формируются структуры
653 данных, необходимые для шифрования в режиме CBC.
654 Предусловие
656 len == 16 || len == 24 || len == 32.
657 По адресу state зарезервировано beltCBC_keep() октетов.
659 Прим.
661 Буферы key и state могут пересекаться.
662 Аргументы
664 state состояние
665 key ключ
666 len длина ключа в октетах
667 iv синхропосылка
668 void beltCBCStepD (void * buf, size_t count, void * state)
670 Буфер [count]buf расшифровывается в режиме CBC на ключе, размещенном в
671 state.
672 Предусловие
674 count >= 16.
675 Ожидается
677 beltCBCStart() < beltCBCStepD()*.
678 Прим.
680 Сохраняются замечания по функции beltCBCStepE().
681 Аргументы
683 buf шифртекст / открытый текст
684 count число октетов текста
685 state состояние
686 void beltCBCStepE (void * buf, size_t count, void * state)
688 Буфер [count]buf зашифровывается в режиме CBC на ключе, размещенном в
689 state.
690 Предусловие
692 count >= 16.
693 Ожидается
695 beltCBCStart() < beltCBCStepE()*.
696 Прим.
698 К функции можно обратиться несколько раз, передавая buf из полных
699 блоков. Неполный блок можно передать только при последнем
700 обращении. В этом случае выполняется 'кража' блока (ciphertext
701 stealing, CTS).
702 При организации последовательных обращений к функции следует
704 учитывать, что буфер buf должен содержать не менее одного блока.
705 Например для зашифрования 33 октетов можно зашифровать сначала 16
706 октетов, а затем еще 17. Но нельзя зашифровать сначала 32 октета, а
707 затем еще 1.
708 Аргументы
710 buf открытый текст / шифртекст
711 count число октетов текста
712 state состояние
713 size_t beltCFB_keep ()
715 Возвращается длина состояния (в октетах) функций шифрования в режиме
716 CFB.
717 Возвращает
719 Длина состояния.
720 err_t beltCFBDecr (void * dest, const void * src, size_t count, const octet
722 key[], size_t len, const octet iv[16])
723 Буфер [count]src расшифровывается на ключе [len]key с использованием
724 синхропосылки iv. Результат расшифрования размещается в буфере
725 [count]dest.
726 Ожидается [ERR_BAD_INPUT]
728 len == 16 || len == 24 || len == 32.
729 Возвращает
731 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
732 случае.
733 Прим.
735 Буферы могут пересекаться.
736 Аргументы
738 dest открытый текст
739 src шифртекст
740 count число октетов текста
741 key ключ
742 len длина ключа
743 iv синхропосылка
744 err_t beltCFBEncr (void * dest, const void * src, size_t count, const octet
746 key[], size_t len, const octet iv[16])
747 Буфер [count]src зашифровывается на ключе [len]key с использованием
748 синхропосылки iv. Результат зашифрования размещается в буфере
749 [count]dest.
750 Ожидается [ERR_BAD_INPUT]
752 len == 16 || len == 24 || len == 32.
753 Возвращает
755 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
756 случае.
757 Прим.
759 Буферы могут пересекаться.
760 Аргументы
762 dest шифртекст
763 src открытый текст
764 count число октетов текста
765 key ключ
766 len длина ключа
767 iv синхропосылка
768 void beltCFBStart (void * state, const octet key[], size_t len, const octet
770 iv[16])
771 По ключу [len]key и синхропосылке iv в state формируются структуры
772 данных, необходимые для шифрования в режиме CFB.
773 Предусловие
775 len == 16 || len == 24 || len == 32.
776 По адресу state зарезервировано beltCFB_keep() октетов.
778 Прим.
780 Буферы key и state могут пересекаться.
781 Аргументы
783 state состояние
784 key ключ
785 len длина ключа в октетах
786 iv синхропосылка
787 void beltCFBStepD (void * buf, size_t count, void * state)
789 Буфер [count]buf расшифровывается в режиме CFB на ключе, размещенном в
790 state.
791 Ожидается
793 beltCFBStart() < beltCFBStepD()*.
794 Аргументы
796 buf шифртекст / открытый текст
797 count число октетов текста
798 state состояние
799 void beltCFBStepE (void * buf, size_t count, void * state)
801 Буфер [count]buf зашифровывается в режиме CFB на ключе, размещенном в
802 state.
803 Ожидается
805 beltCFBStart() < beltCFBStepE()*.
806 Аргументы
808 buf открытый текст / шифртекст
809 count число октетов текста
810 state состояние
811 size_t beltCHE_keep ()
813 Возвращается длина состояния (в октетах) функций CHE.
814 Возвращает
816 Длина состояния.
817 void beltCHEStart (void * state, const octet key[], size_t len, const octet
819 iv[16])
820 По ключу [len]key и синхропосылке iv в state формируются структуры
821 данных, необходимые для аутентифицированного шифрования в режиме CHE.
822 Предусловие
824 len == 16 || len == 24 || len == 32.
825 По адресу state зарезервировано beltCHE_keep() октетов.
827 Прим.
829 Буферы key и state могут пересекаться.
830 Аргументы
832 state состояние
833 key ключ
834 len длина ключа в октетах
835 iv синхропосылка
836 void beltCHEStepA (const void * buf, size_t count, void * state)
838 Текущая имитовставка, размещенная в state, пересчитывается с учетом
839 нового фрагмента зашифрованных критических данных [count]buf. Пересчет
840 выполняется на ключе, также размещенном в state.
841 Ожидается
843 По адресу state зарезервировано beltCHE_keep() октетов.
844 Ожидается
846 beltCHEStepI()* < beltCHEStepA()*.
847 Ожидается
849 beltCHEStepE()* < beltCHEStepA()*.
850 Аргументы
852 buf критические данные
853 count число октетов данных
854 state состояние
855 void beltCHEStepD (void * buf, size_t count, void * state)
857 Фрагмент зашифрованных критических данных [count]buf расшифровывается
858 на ключе, размещенном в state. Результат расшифрования сохраняется в
859 buf.
860 Ожидается
862 beltCHEStepG() < beltCHEStepD().
863 Ожидается
865 beltCHEStepA()* < beltCHEStepD().
866 Аргументы
868 buf критические данные
869 count число октетов данных
870 state состояние
871 void beltCHEStepE (void * buf, size_t count, void * state)
873 Фрагмент критических данных [count]buf зашифровывается на ключе,
874 размещенном в state. Результат зашифрования сохраняется в buf.
875 Ожидается
877 beltCHEStart() < beltCHEStepE()*.
878 Аргументы
880 buf критические данные
881 count число октетов данных
882 state состояние
883 void beltCHEStepG (octet mac[8], void * state)
885 Определяется окончательная имитовставка mac всех данных, обработанных
886 до этого функциями beltCHEStepI() и beltCHEStepA().
887 Ожидается
889 beltCHEStepI()* < beltCHEStepG().
890 Ожидается
892 beltCHEStepA()* < beltCHEStepG().
893 Предупреждения
895 При выполнении функции состояние state изменяется так, что
896 продолжение имитозащиты становится некорректным.
897 Аргументы
899 mac имитовставка
900 state состояние
901 void beltCHEStepI (const void * buf, size_t count, void * state)
903 Текущая имитовставка, размещенная в state, пересчитывается с учетом
904 нового фрагмента открытых данных [count]buf. Пересчет выполняется на
905 ключе, также размещенном в state.
906 Ожидается
908 beltCHEStart() < beltCHEStepI()*.
909 Аргументы
911 buf открытые данные
912 count число октетов данных
913 state состояние
914 bool_t beltCHEStepV (const octet mac[8], void * state)
916 Проверяется, что окончательная имитовставка всех данных, обработанных
917 до этого функциями beltCHEStepI() и beltCHEStepA(), совпадает с mac.
918 Ожидается
920 beltCHEStepI()* < beltCHEStepV().
921 Ожидается
923 beltCHEStepA()* < beltCHEStepV().
924 Возвращает
926 Признак успеха.
927 Предупреждения
929 При выполнении функции состояние state изменяется так, что
930 продолжение имитозащиты становится некорректным.
931 Аргументы
933 mac контрольная имитовставка
934 state состояние
935 err_t beltCHEUnwrap (void * dest, const void * src1, size_t count1, const
937 void * src2, size_t count2, const octet mac[8], const octet key[],
938 size_t len, const octet iv[16])
939 На ключе [len]key октетов с использованием имитовставки iv снимается
940 защита зашифрованных критических данных [count1]src1 и открытых данных
941 [count2]src2. При снятии защиты проверяется целостность пары (src1,
942 src2) с помощью имитовставки mac. Если целостность не нарушена, то
943 данные src1 расшифровываются в буфер [count1]dest.
944 Ожидается [ERR_BAD_INPUT]
946 len == 16 || len == 24 || len == 32.
947 Возвращает
949 ERR_OK, если защита успешно снята, и код ошибки в противном случае.
950 Прим.
952 Буферы могут пересекаться.
953 Аргументы
955 dest расшифрованные критические данные
956 src1 зашифрованные критические данные
957 count1 число октетов критических данных
958 src2 открытые данные
959 count2 число октетов открытых данных
960 mac имитовставка
961 key ключ
962 len длина ключа
963 iv синхропосылка
964 err_t beltCHEWrap (void * dest, octet mac[8], const void * src1, size_t
966 count1, const void * src2, size_t count2, const octet key[], size_t
967 len, const octet iv[16])
968 На ключе [len]key с использованием имитовставки iv устанавливается
969 защита критических данных [count1]src1 и открытых данных [count2]src2.
970 При установке защиты критические данные зашифровываются и сохраняются в
971 буфере [count1]dest. Кроме этого определяется имитовставка mac пары
972 (src1, src2).
973 Ожидается [ERR_BAD_INPUT]
975 • len == 16 || len == 24 || len == 32;
978 • буферы dest и mac не пересекаются.
980 Возвращает
982 ERR_OK, если защита успешно установлена, и код ошибки в противном
983 случае.
984 Прим.
986 Буферы могут пересекаться, за исключением пересечения dest и mac.
987 Аргументы
989 dest зашифрованные критические данные
990 mac имитовставка
991 src1 критические данные
992 count1 число октетов критических данных
993 src2 открытые данные
994 count2 число октетов открытых данных
995 key ключ
996 len длина ключа
997 iv синхропосылка
998 void beltCompr (u32 h[8], const u32 X[8], void * stack)
1000 Форматированный буфер h || X сжимается до форматированного буфера h.
1001 Предусловие
1003 Буферы X и h не пересекаются.
1004 Схема расчета глубины stack
1006 beltCompr_deep().
1007 Аргументы
1009 h первая часть входа/выход
1010 X вторая часть входа
1011 stack стек
1012 void beltCompr2 (u32 s[4], u32 h[8], const u32 X[8], void * stack)
1014 Форматированный буфер h || X сжимается до форматированного буфера h.
1015 Внутренняя переменная S belt-compress добавдяется поразрядно по модулю
1016 2 к буферу s.
1017 Предусловие
1019 Буферы s и h, X и s, X и h не пересекаются.
1020 Схема расчета глубины stack
1022 beltCompr_deep().
1023 Аргументы
1025 s сумма
1026 h первая часть входа/выход
1027 X вторая часть входа
1028 stack стек
1029 size_t beltCompr_deep ()
1031 Возвращается глубина стека (в октетах) функций сжатия.
1032 Возвращает
1034 Глубина стека.
1035 err_t beltCTR (void * dest, const void * src, size_t count, const octet
1037 key[], size_t len, const octet iv[16])
1038 Буфер [count]src зашифровывается или расшифровывается на ключе [len]key
1039 с использованием синхропосылки iv. Результат шифрования размещается в
1040 буфере [count]dest.
1041 Ожидается [ERR_BAD_INPUT]
1043 len == 16 || len == 24 || len == 32.
1044 Возвращает
1046 ERR_OK, если шифрование завершено успешно, и код ошибки в противном
1047 случае.
1048 Прим.
1050 Буферы могут пересекаться.
1051 Аргументы
1053 dest шифртекст / открытый текст
1054 src открытый текст / шифртекст
1055 count число октетов текста
1056 key ключ
1057 len длина ключа
1058 iv синхропосылка
1059 size_t beltCTR_keep ()
1061 Возвращается длина состояния (в октетах) функций шифрования в режиме
1062 CTR.
1063 Возвращает
1065 Длина состояния.
1066 void beltCTRStart (void * state, const octet key[], size_t len, const octet
1068 iv[16])
1069 По ключу [len]key и синхропосылке iv в state формируются структуры
1070 данных, необходимые для шифрования в режиме CTR.
1071 Предусловие
1073 len == 16 || len == 24 || len == 32.
1074 По адресу state зарезервировано beltCTR_keep() октетов.
1076 Прим.
1078 Буферы key и state могут пересекаться.
1079 Аргументы
1081 state состояние
1082 key ключ
1083 len длина ключа в октетах
1084 iv синхропосылка
1085 void beltCTRStepE (void * buf, size_t count, void * state)
1087 Буфер [count]buf зашифровывается в режиме CTR на ключе, размещенном в
1088 state.
1089 Ожидается
1091 beltCTRStart() < beltCTRStepE()*.
1092 Аргументы
1094 buf открытый текст / шифртекст
1095 count число октетов текста
1096 state состояние
1097 size_t beltDWP_keep ()
1099 Возвращается длина состояния (в октетах) функций DWP.
1100 Возвращает
1102 Длина состояния.
1103 void beltDWPStart (void * state, const octet key[], size_t len, const octet
1105 iv[16])
1106 По ключу [len]key и синхропосылке iv в state формируются структуры
1107 данных, необходимые для аутентифицированного шифрования в режиме DWP.
1108 Предусловие
1110 len == 16 || len == 24 || len == 32.
1111 По адресу state зарезервировано beltDWP_keep() октетов.
1113 Прим.
1115 Буферы key и state могут пересекаться.
1116 Аргументы
1118 state состояние
1119 key ключ
1120 len длина ключа в октетах
1121 iv синхропосылка
1122 void beltDWPStepA (const void * buf, size_t count, void * state)
1124 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1125 нового фрагмента зашифрованных критических данных [count]buf. Пересчет
1126 выполняется на ключе, также размещенном в state.
1127 Ожидается
1129 По адресу state зарезервировано beltDWP_keep() октетов.
1130 Ожидается
1132 beltDWPStepI()* < beltDWPStepA()*.
1133 Ожидается
1135 beltDWPStepE()* < beltDWPStepA()*.
1136 Аргументы
1138 buf критические данные
1139 count число октетов данных
1140 state состояние
1141 void beltDWPStepD (void * buf, size_t count, void * state)
1143 Фрагмент зашифрованных критических данных [count]buf расшифровывается
1144 на ключе, размещенном в state. Результат расшифрования сохраняется в
1145 buf.
1146 Ожидается
1148 beltDWPStepG() < beltDWPStepD().
1149 Ожидается
1151 beltDWPStepA()* < beltDWPStepD().
1152 Аргументы
1154 buf критические данные
1155 count число октетов данных
1156 state состояние
1157 void beltDWPStepE (void * buf, size_t count, void * state)
1159 Фрагмент критических данных [count]buf зашифровывается на ключе,
1160 размещенном в state. Результат зашифрования сохраняется в buf.
1161 Ожидается
1163 beltDWPStart() < beltDWPStepE()*.
1164 Аргументы
1166 buf критические данные
1167 count число октетов данных
1168 state состояние
1169 void beltDWPStepG (octet mac[8], void * state)
1171 Определяется окончательная имитовставка mac всех данных, обработанных
1172 до этого функциями beltDWPStepI() и beltDWPStepA().
1173 Ожидается
1175 beltDWPStepI()* < beltDWPStepG().
1176 Ожидается
1178 beltDWPStepA()* < beltDWPStepG().
1179 Предупреждения
1181 При выполнении функции состояние state изменяется так, что
1182 продолжение имитозащиты становится некорректным.
1183 Аргументы
1185 mac имитовставка
1186 state состояние
1187 void beltDWPStepI (const void * buf, size_t count, void * state)
1189 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1190 нового фрагмента открытых данных [count]buf. Пересчет выполняется на
1191 ключе, также размещенном в state.
1192 Ожидается
1194 beltDWPStart() < beltDWPStepI()*.
1195 Аргументы
1197 buf открытые данные
1198 count число октетов данных
1199 state состояние
1200 bool_t beltDWPStepV (const octet mac[8], void * state)
1202 Проверяется, что окончательная имитовставка всех данных, обработанных
1203 до этого функциями beltDWPStepI() и beltDWPStepA(), совпадает с mac.
1204 Ожидается
1206 beltDWPStepI()* < beltDWPStepV().
1207 Ожидается
1209 beltDWPStepA()* < beltDWPStepV().
1210 Возвращает
1212 Признак успеха.
1213 Предупреждения
1215 При выполнении функции состояние state изменяется так, что
1216 продолжение имитозащиты становится некорректным.
1217 Аргументы
1219 mac контрольная имитовставка
1220 state состояние
1221 err_t beltDWPUnwrap (void * dest, const void * src1, size_t count1, const
1223 void * src2, size_t count2, const octet mac[8], const octet key[],
1224 size_t len, const octet iv[16])
1225 На ключе [len]key октетов с использованием имитовставки iv снимается
1226 защита зашифрованных критических данных [count1]src1 и открытых данных
1227 [count2]src2. При снятии защиты проверяется целостность пары (src1,
1228 src2) с помощью имитовставки mac. Если целостность не нарушена, то
1229 данные src1 расшифровываются в буфер [count1]dest.
1230 Ожидается [ERR_BAD_INPUT]
1232 len == 16 || len == 24 || len == 32.
1233 Возвращает
1235 ERR_OK, если защита успешно снята, и код ошибки в противном случае.
1236 Прим.
1238 Буферы могут пересекаться.
1239 Аргументы
1241 dest расшифрованные критические данные
1242 src1 зашифрованные критические данные
1243 count1 число октетов критических данных
1244 src2 открытые данные
1245 count2 число октетов открытых данных
1246 mac имитовставка
1247 key ключ
1248 len длина ключа
1249 iv синхропосылка
1250 err_t beltDWPWrap (void * dest, octet mac[8], const void * src1, size_t
1252 count1, const void * src2, size_t count2, const octet key[], size_t
1253 len, const octet iv[16])
1254 На ключе [len]key с использованием имитовставки iv устанавливается
1255 защита критических данных [count1]src1 и открытых данных [count2]src2.
1256 При установке защиты критические данные зашифровываются и сохраняются в
1257 буфере [count1]dest. Кроме этого определяется имитовставка mac пары
1258 (src1, src2).
1259 Ожидается [ERR_BAD_INPUT]
1261 • len == 16 || len == 24 || len == 32;
1264 • буферы dest и mac не пересекаются.
1266 Возвращает
1268 ERR_OK, если защита успешно установлена, и код ошибки в противном
1269 случае.
1270 Прим.
1272 Буферы могут пересекаться, за исключением пересечения dest и mac.
1273 Аргументы
1275 dest зашифрованные критические данные
1276 mac имитовставка
1277 src1 критические данные
1278 count1 число октетов критических данных
1279 src2 открытые данные
1280 count2 число октетов открытых данных
1281 key ключ
1282 len длина ключа
1283 iv синхропосылка
1284 size_t beltECB_keep ()
1286 Возвращается длина состояния (в октетах) функций шифрования в режиме
1287 ECB.
1288 Возвращает
1290 Длина состояния.
1291 err_t beltECBDecr (void * dest, const void * src, size_t count, const octet
1293 key[], size_t len)
1294 Буфер src из count октетов расшифровывается на ключе [len]key.
1295 Результат расшифрования размещается в буфере dest.
1296 Ожидается [ERR_BAD_INPUT]
1298 • len == 16 || len == 24 || len == 32;
1301 • count >= 16.
1303 Возвращает
1305 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
1306 случае.
1307 Аргументы
1309 dest открытый текст
1310 src шифртекст
1311 count число октетов текста
1312 key ключ
1313 len длина ключа
1314 err_t beltECBEncr (void * dest, const void * src, size_t count, const octet
1316 key[], size_t len)
1317 Буфер [count]src зашифровывается на ключе [len]key октетов. Результат
1318 зашифрования размещается в буфере [count]dest.
1319 Ожидается [ERR_BAD_INPUT]
1321 • len == 16 || len == 24 || len == 32;
1324 • count >= 16.
1326 Возвращает
1328 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
1329 случае.
1330 Аргументы
1332 dest шифртекст
1333 src открытый текст
1334 count число октетов текста
1335 key ключ
1336 len длина ключа
1337 void beltECBStart (void * state, const octet key[], size_t len)
1339 По ключу [len]key в state формируются структуры данных, необходимые для
1340 шифрования в режиме ECB.
1341 Предусловие
1343 len == 16 || len == 24 || len == 32.
1344 По адресу state зарезервировано beltECB_keep() октетов.
1346 Прим.
1348 Буферы key и state могут пересекаться.
1349 Аргументы
1351 state состояние
1352 key ключ
1353 len длина ключа в октетах
1354 void beltECBStepD (void * buf, size_t count, void * state)
1356 Буфер [count]buf расшифровывается в режиме ECB на ключе, размещенном в
1357 state.
1358 Предусловие
1360 count >= 16.
1361 Ожидается
1363 beltECBStart() < beltECBStepD()*.
1364 Прим.
1366 Сохраняются замечания по функции beltECBStepE().
1367 Аргументы
1369 buf шифртекст / открытый текст
1370 count число октетов текста
1371 state состояние
1372 void beltECBStepE (void * buf, size_t count, void * state)
1374 Буфер [count]buf зашифровывается в режиме ECB на ключе, размещенном в
1375 state.
1376 Предусловие
1378 count >= 16.
1379 Ожидается
1381 beltECBStart() < beltECBStepE()*.
1382 Прим.
1384 К функции можно обратиться несколько раз, передавая buf из полных
1385 блоков. Неполный блок можно передать только при последнем
1386 обращении. В этом случае выполняется 'кража' блока (ciphertext
1387 stealing, CTS).
1388 При организации последовательных обращений к функции следует
1390 учитывать, что буфер buf должен содержать не менее одного блока.
1391 Например для зашифрования 33 октетов можно зашифровать сначала 16
1392 октетов, а затем еще 17. Но нельзя зашифровать сначала 32 октета, а
1393 затем еще 1.
1394 Аргументы
1396 buf открытый текст / шифртекст
1397 count число октетов текста
1398 state состояние
1399 size_t beltFMT_keep (u32 mod, size_t count)
1401 Возвращается длина состояния (в октетах) функций шифрования при
1402 обработке слов длины count в алфавите {0, 1,..., mod - 1}.
1403 Предусловие
1405 2 <= mod && mod <= 65536.
1406 2 <= count && count <= 600.
1408 Возвращает
1410 Длина состояния.
1411 Аргументы
1413 mod размер алфавита
1414 count длина слов
1415 err_t beltFMTDecr (u16 dest[], u32 mod, const u16 src[], size_t count,
1417 const octet key[], size_t len, const octet iv[16])
1418 Строка [count]src в алфавите {0, 1,..., mod - 1} расшифровывается на
1419 ключе [len]key и синхропосылке iv. Результат расшифрования размещается
1420 в буфере [count]dest. При нулевом указателе iv используется нулевая
1421 синхропосылка.
1422 Ожидается [ERR_BAD_INPUT]
1424 • 2 <= mod && mod <= 65536;
1427 • 2 <= count;
1429 • len == 16 || len == 24 || len == 32;
1431 • если iv ненулевой, то буферы iv и [count]dest не пересекаются.
1433 Ожидается [ERR_NOT_IMPLEMENTED]
1435 count <= 600.
1436 Ожидается
1438 Символы src принадлежат алфавиту {0, 1,..., mod - 1}.
1439 Возвращает
1441 ERR_OK, если расшифрование успешно выполнено, и код ошибки в
1442 противном случае.
1443 Прим.
1445 Все буферы, кроме iv и [count]dest, могут пересекаться.
1446 Аргументы
1448 dest открытый текст
1449 mod размер алфавита
1450 src шифртекст
1451 count длина шифртекста / открытого текста
1452 key ключ
1453 len длина key в октетах
1454 iv синхропосылка
1455 err_t beltFMTEncr (u16 dest[], u32 mod, const u16 src[], size_t count,
1457 const octet key[], size_t len, const octet iv[16])
1458 Строка [count]src в алфавите {0, 1,..., mod - 1} зашифровывается на
1459 ключе [len]key и синхропосылке iv. Результат зашифрования размещается в
1460 буфере [count]dest. При нулевом указателе iv используется нулевая
1461 синхропосылка.
1462 Ожидается [ERR_BAD_INPUT]
1464 • 2 <= mod && mod <= 65536;
1467 • 2 <= count;
1469 • len == 16 || len == 24 || len == 32;
1471 • если iv ненулевой, то буферы iv и [count]dest не пересекаются.
1473 Ожидается [ERR_NOT_IMPLEMENTED]
1475 count <= 600.
1476 Ожидается
1478 Символы src принадлежат алфавиту {0, 1,..., mod - 1}.
1479 Возвращает
1481 ERR_OK, если зашифрование успешно выполнено, и код ошибки в
1482 противном случае.
1483 Прим.
1485 Все буферы, кроме iv и [count]dest, могут пересекаться.
1486 Аргументы
1488 dest шифртекст
1489 mod размер алфавита
1490 src открытый текст
1491 count длина открытого текста / шифртекста
1492 key ключ
1493 len длина key в октетах
1494 iv синхропосылка
1495 void beltFMTStart (void * state, u32 mod, size_t count, const octet key[],
1497 size_t len)
1498 По размеру алфавита mod, длине слов count и ключу [len]key в state
1499 формируются структуры данных, необходимые для шифрования в режиме FMT.
1500 Предусловие
1502 2 <= mod && mod <= 65536.
1503 2 <= count && count <= 600.
1505 len == 16 || len == 24 || len == 32.
1507 По адресу state зарезервировано beltFMT_keep() октетов.
1509 Прим.
1511 Буферы key и state могут пересекаться.
1512 Аргументы
1514 state состояние
1515 mod размер алфавита
1516 count длина слов
1517 key ключ
1518 len длина key в октетах
1519 void beltFMTStepD (u16 buf[], const octet iv[16], void * state)
1521 Строка [count]buf расшифровывается на ключе, размещенном в state, и
1522 синхропосылке iv. Здесь count -- длина строки, предварительно
1523 установленная в state функцией beltFMTStart(). Результат расшифрования
1524 сохраняется в buf.
1525 Ожидается
1527 beltFMTStart() < beltFMTStepD()*.
1528 Ожидается
1530 Символы строки принадлежат алфавиту {0,1,..., mod - 1}, размер mod
1531 которого предварительно установлен в state функцией beltFMTStart().
1532 Прим.
1534 При нулевом указателе iv используется нулевая синхропосылка.
1535 Аргументы
1537 buf шифртекст / открытый текст
1538 iv синхропосылка
1539 state состояние
1540 void beltFMTStepE (u16 buf[], const octet iv[16], void * state)
1542 Строка [count]buf зашифровывается на ключе, размещенном в state, и
1543 синхропосылке iv. Здесь count -- длина строки, предварительно
1544 установленная в state функцией beltFMTStart(). Результат зашифрования
1545 сохраняется в buf.
1546 Ожидается
1548 beltFMTStart() < beltFMTStepE()*.
1549 Ожидается
1551 Символы строки принадлежат алфавиту {0,1,..., mod - 1}, размер mod
1552 которого предварительно установлен в state функцией beltFMTStart().
1553 Прим.
1555 При нулевом указателе iv используется нулевая синхропосылка.
1556 Аргументы
1558 buf открытый текст / шифртекст
1559 iv синхропосылка
1560 state состояние
1561 const octet * beltH ()
1563 Возвращается таблица значений блока подстановки H.
1564 Возвращает
1566 Указатель на таблицу H.
1567 Прим.
1569 Таблица используется для формирования начальных значений переменных
1570 некоторых алгоритмов, а также в тестовых примерах.
1571 err_t beltHash (octet hash[32], const void * src, size_t count)
1573 Определяется хэш-значение hash буфера [count]src.
1574 Возвращает
1576 ERR_OK, если хэширование успешно завершено, и код ошибки в
1577 противном случае.
1578 Прим.
1580 Буферы могут пересекаться.
1581 Аргументы
1583 hash хэш-значение
1584 src данные
1585 count число октетов данных
1586 size_t beltHash_keep ()
1588 Возвращается длина состояния (в октетах) функции хэширования.
1589 Возвращает
1591 Длина состояния.
1592 void beltHashStart (void * state)
1594 В state формируются структуры данных, необходимые для хэширования.
1595 Предусловие
1597 По адресу state зарезервировано beltHash_keep() октетов.
1598 Аргументы
1600 state состояние
1601 void beltHashStepG (octet hash[32], void * state)
1603 Определяется окончательное хэш-значение hash всех данных, обработанных
1604 до этого функцией beltHashStepH().
1605 Ожидается
1607 (beltHashStepH()* < beltHashStepG())*.
1608 Прим.
1610 Если продолжение хэширования не предполагается, то буферы hash и
1611 state могут пересекаться.
1612 Аргументы
1614 hash хэш-значение
1615 state состояние
1616 void beltHashStepG2 (octet hash[], size_t hash_len, void * state)
1618 Определяется окончательное хэш-значение [hash_len]hash всех данных,
1619 обработанных до этого функцией beltHashStepH(). Возвращаемое
1620 хэш-значение состоит из первых hash_len октетов полного хэш-значения.
1621 Предусловие
1623 hash_len <= 32.
1624 Ожидается
1626 (beltHashStepH()* < beltHashStepG2())*.
1627 Прим.
1629 Если продолжение хэширования не предполагается, то буферы hash и
1630 state могут пересекаться.
1631 Аргументы
1633 hash хэш-значение
1634 hash_len длина hash
1635 state состояние
1636 void beltHashStepH (const void * buf, size_t count, void * state)
1638 Текущее хэш-значение, размещенное в state, пересчитывается с учетом
1639 нового фрагмента данных [count]buf.
1640 Ожидается
1642 beltHashStart() < beltHashStepH()*.
1643 Аргументы
1645 buf данные
1646 count число октетов данных
1647 state состояние
1648 bool_t beltHashStepV (const octet hash[32], void * state)
1650 Проверяется, что окончательное хэш-значение всех данных, обработанных
1651 до этого функцией beltHashStepH(), совпадает с hash.
1652 Ожидается
1654 (beltHashStepH()* < beltHashStepV())*.
1655 Аргументы
1657 hash контрольные хэш-значение
1658 state состояние
1659 bool_t beltHashStepV2 (const octet hash[], size_t hash_len, void * state)
1661 Проверяется, что первые hash_len октетов окончательного хэш-значения
1662 всех данных, обработанных до этого функцией beltHashStepH(), совпадают
1663 с [hash_len]hash.
1664 Предусловие
1666 hash_len <= 32.
1667 Ожидается
1669 (beltHashStepH()* < beltHashStepV2())*.
1670 Аргументы
1672 hash контрольное хэш-значение
1673 hash_len длина hash
1674 state состояние
1675 err_t beltHMAC (octet mac[32], const void * src, size_t count, const octet
1677 key[], size_t len)
1678 На ключе [len]key определяется имитовставка mac буфера [count]src.
1679 Возвращает
1681 ERR_OK, если имитовставка успешно вычислена, и код ошибки в
1682 противном случае.
1683 Прим.
1685 Буферы могут пересекаться.
1686 Аргументы
1688 mac имитовставка
1689 src данные
1690 count число октетов данных
1691 key ключ
1692 len длина ключа
1693 size_t beltHMAC_keep ()
1695 Возвращается длина состояния (в октетах) функций имитозащиты в режиме
1696 MAC.
1697 Возвращает
1699 Длина состояния.
1700 void beltHMACStart (void * state, const octet key[], size_t len)
1702 По ключу [len]key в state формируются структуры данных, необходимые для
1703 имитозащиты в режиме HMAC.
1704 Предусловие
1706 По адресу state зарезервировано beltHMAC_keep() октетов.
1707 Прим.
1709 Рекомендуется использовать ключ из 32 октетов.
1710 Аргументы
1712 state состояние
1713 key ключ
1714 len длина ключа в октетах
1715 void beltHMACStepA (const void * buf, size_t count, void * state)
1717 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1718 нового фрагмента данных [count]buf. Пересчет выполняется на ключе,
1719 также размещенном в state.
1720 Ожидается
1722 beltHMACStart() < beltHMACStepA()*.
1723 Аргументы
1725 buf данные
1726 count число октетов данных
1727 state состояние
1728 void beltHMACStepG (octet mac[32], void * state)
1730 Определяется окончательная имитовставка mac всех данных, обработанных
1731 до этого функцией beltHMACStepA().
1732 Ожидается
1734 (beltHMACStepA()* < beltHMACStepG())*.
1735 Аргументы
1737 mac имитовставка
1738 state состояние
1739 void beltHMACStepG2 (octet mac[], size_t mac_len, void * state)
1741 Определяется окончательная имитовставка [mac_len]mac всех данных,
1742 обработанных до этого функцией beltHMACStepA(). Возвращаемая
1743 имитовставка состоит из первых mac_len октетов полной имитовставки.
1744 Предусловие
1746 mac_len <= 32.
1747 Ожидается
1749 (beltHMACStepA()* < beltHMACStepG2())*.
1750 Прим.
1752 Если продолжение имитозащиты не предполагается, то буферы mac и
1753 state могут пересекаться.
1754 Аргументы
1756 mac имитовставка
1757 mac_len длина имитовставки
1758 state состояние
1759 bool_t beltHMACStepV (const octet mac[32], void * state)
1761 Проверяется, что окончательная имитовставка всех данных, обработанных
1762 до этого функцией beltHMACStepA(), совпадает с mac.
1763 Ожидается
1765 (beltHMACStepA()* < beltHMACStepV())*.
1766 Аргументы
1768 mac контрольная имитовставка
1769 state состояние
1770 bool_t beltHMACStepV2 (const octet mac[], size_t mac_len, void * state)
1772 Проверяется, что первые mac_len октетов окончательной имитовставки всех
1773 данных, обработанных до этого функцией beltHMACStepA(), совпадают с
1774 [mac_len]mac.
1775 Предусловие
1777 mac_len <= 32.
1778 Ожидается
1780 (beltHMACStepA()* < beltHMACStepV2())*.
1781 Аргументы
1783 mac контрольная имитовставка
1784 mac_len длина mac
1785 state состояние
1786 void beltKeyExpand (octet key_[32], const octet key[], size_t len)
1788 Ключ [len]key расширяется до ключа key_.
1789 Предусловие
1791 len == 16 || len == 24 || len == 32.
1792 Прим.
1794 Буферы key и key_ могут пересекаться.
1795 Аргументы
1797 key_ расширенный ключ
1798 key первоначальный ключ
1799 len длина key в октетах
1800 void beltKeyExpand2 (u32 key_[8], const octet key[], size_t len)
1802 Ключ [len]key форматируется и расширяется до ключа key_.
1803 Предусловие
1805 len == 16 || len == 24 || len == 32.
1806 Прим.
1808 Буферы key и key_ могут пересекаться.
1809 Аргументы
1811 key_ расширенный форматированный ключ
1812 key первоначальный ключ
1813 len длина ключа в октетах
1814 err_t beltKRP (octet dest[], size_t m, const octet src[], size_t n, const
1816 octet level[12], const octet header[16])
1817 По ключу [n]src, который имеет уровень level, строится ключ [m]dest,
1818 который имеет заголовок header.
1819 Ожидается [ERR_BAD_INPUT]
1821 • n == 16 || n == 24 || n == 32;
1824 • m == 16 || m == 24 || m == 32;
1826 • m <= n.
1828 Возвращает
1830 ERR_OK, если преобразование успешно завершено, и код ошибки в
1831 противном случае.
1832 Прим.
1834 Буферы могут пересекаться.
1835 Аргументы
1837 dest преобразованный ключ
1838 m длина dest в октетах
1839 src исходный ключ
1840 n длина src в октетах
1841 level уровень ключа src
1842 header заголовок ключа dest
1843 size_t beltKRP_keep ()
1845 Возвращается длина состояния (в октетах) функций преобразования ключа.
1846 Возвращает
1848 Длина состояния.
1849 void beltKRPStart (void * state, const octet key[], size_t len, const octet
1851 level[12])
1852 По ключу [len]key, который принадлежит уровню level, в state
1853 формируются структуры данных, необходимые для преобразования этого
1854 ключа.
1855 Предусловие
1857 len == 16 || len == 24 || len == 32.
1858 По адресу state зарезервировано beltKRP_keep() октетов.
1860 Прим.
1862 Буферы key и state могут пересекаться.
1863 Аргументы
1865 state состояние
1866 key ключ
1867 len длина ключа в октетах
1868 level уровень
1869 void beltKRPStepG (octet key_[], size_t key_len, const octet header[16],
1871 void * state)
1872 Ключ [len]key, размещенный в state функцией beltKRPStart(),
1873 преобразуется в ключ [key_len]key_, который имеет заголовок header.
1874 Предусловие
1876 (key_len == 16 || key_len == 24 || key_len == 32) && key_len <=
1877 len.
1878 Ожидается
1880 beltKRPStart() < beltKRPStepG()*.
1881 Аргументы
1883 key_ преобразованный ключ
1884 key_len длина key в октетах
1885 header заголовок key_
1886 state состояние
1887 err_t beltKWPUnwrap (octet dest[], const octet src[], size_t count, const
1889 octet header[16], const octet key[], size_t len)
1890 На ключе [len]key снимается защита с ключа [count]src. В результате
1891 определяется первоначальный ключ [count - 16]dest с заголовком header.
1892 Ожидается [ERR_BAD_INPUT]
1894 • len == 16 || len == 24 || len == 32;
1897 • count >= 32.
1899 Возвращает
1901 ERR_OK, если защита успешно снята, и код ошибки в противном случае.
1902 Прим.
1904 При нулевом указателе header используется нулевой заголовок.
1905 Буферы могут пересекаться.
1907 Аргументы
1909 dest ключ
1910 src защищенный ключ
1911 count длина src в октетах
1912 header заголовок ключа
1913 key ключ защиты
1914 len длина key в октетах
1915 err_t beltKWPWrap (octet dest[], const octet src[], size_t count, const
1917 octet header[16], const octet key[], size_t len)
1918 На ключе [len]key устанавливается защита ключа [count]src с заголовком
1919 header. В результате определяется защищенный ключ [count + 16]dest.
1920 Ожидается [ERR_BAD_INPUT]
1922 • len == 16 || len == 24 || len == 32;
1925 • count >= 16.
1927 Возвращает
1929 ERR_OK, если защита успешно установлена, и код ошибки в противном
1930 случае.
1931 Прим.
1933 При нулевом указателе header используется нулевой заголовок.
1934 Буферы могут пересекаться.
1936 Аргументы
1938 dest защищенный ключ
1939 src защищаемый ключ
1940 count длина src в октетах
1941 header заголовок ключа
1942 key ключ защиты
1943 len длина key в октетах
1944 err_t beltMAC (octet mac[8], const void * src, size_t count, const octet
1946 key[], size_t len)
1947 На ключе [len]key определяется имитовставка mac буфера [count]src.
1948 Ожидается [ERR_BAD_INPUT]
1950 len == 16 || len == 24 || len == 32.
1951 Возвращает
1953 ERR_OK, если имитовставка успешно вычислена, и код ошибки в
1954 противном случае.
1955 Прим.
1957 Буферы могут пересекаться.
1958 Аргументы
1960 mac имитовставка
1961 src данные
1962 count число октетов данных
1963 key ключ
1964 len длина ключа
1965 size_t beltMAC_keep ()
1967 Возвращается длина состояния (в октетах) функций имитозащиты в режиме
1968 MAC.
1969 Возвращает
1971 Длина состояния.
1972 void beltMACStart (void * state, const octet key[], size_t len)
1974 По ключу [len]key в state формируются структуры данных, необходимые для
1975 имитозащиты в режиме MAC.
1976 Предусловие
1978 len == 16 || len == 24 || len == 32.
1979 По адресу state зарезервировано beltMAC_keep() октетов.
1981 Прим.
1983 Буферы key и state могут пересекаться.
1984 Аргументы
1986 state состояние
1987 key ключ
1988 len длина ключа в октетах
1989 void beltMACStepA (const void * buf, size_t count, void * state)
1991 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1992 нового фрагмента данных [count]buf. Пересчет выполняется на ключе,
1993 также размещенном в state.
1994 Ожидается
1996 beltMACStart() < beltMACStepA()*.
1997 Аргументы
1999 buf данные
2000 count число октетов данных
2001 state состояние
2002 void beltMACStepG (octet mac[8], void * state)
2004 Определяется окончательная имитовставка mac всех данных, обработанных
2005 до этого функцией beltMACStepA().
2006 Ожидается
2008 (beltMACStepA()* < beltMACStepG())*.
2009 Прим.
2011 Если продолжение имитозащиты не предполагается, то буферы mac и
2012 state могут пересекаться.
2013 Аргументы
2015 mac имитовставка
2016 state состояние
2017 void beltMACStepG2 (octet mac[], size_t mac_len, void * state)
2019 Определяется окончательная имитовставка [mac_len]mac всех данных,
2020 обработанных до этого функцией beltMACStepA(). Возвращаемая
2021 имитовставка состоит из первых mac_len октетов полной имитовставки.
2022 Предусловие
2024 mac_len <= 8.
2025 Ожидается
2027 (beltMACStepA()* < beltMACStepG2())*.
2028 Прим.
2030 Если продолжение имитозащиты не предполагается, то буферы mac и
2031 state могут пересекаться.
2032 Аргументы
2034 mac имитовставка
2035 mac_len длина имитовставки
2036 state состояние
2037 bool_t beltMACStepV (const octet mac[8], void * state)
2039 Проверяется, что окончательная имитовставка всех данных, обработанных
2040 до этого функцией beltMACStepA(), совпадает с mac.
2041 Ожидается
2043 (beltMACStepA()* < beltMACStepV())*.
2044 Возвращает
2046 Признак успеха.
2047 Аргументы
2049 mac контрольная имитовставка
2050 state состояние
2051 bool_t beltMACStepV2 (const octet mac[], size_t mac_len, void * state)
2053 Проверяется, что первые mac_len октетов окончательной имитовставки всех
2054 данных, обработанных до этого функцией beltMACStepA(), совпадают с
2055 [mac_len]mac.
2056 Предусловие
2058 mac_len <= 8.
2059 Ожидается
2061 (beltMACStepA()* < beltMACStepV2())*.
2062 Аргументы
2064 mac контрольная имитовставка
2065 mac_len длина mac
2066 state состояние
2067 err_t beltPBKDF2 (octet key[32], const octet pwd[], size_t pwd_len, size_t
2069 iter, const octet salt[], size_t salt_len)
2070 По паролю [pwd_len]pwd строится ключ key. Для усложнения словарных атак
2071 используется синхропосылка [salt_len]salt. Для усложнения перебора
2072 паролей ключ пересчитывается iter > 0 раз.
2073 Ожидается [ERR_BAD_INPUT]
2075 iter != 0.
2076 Возвращает
2078 ERR_OK, если ключ успешно построен, и код ошибки в противном
2079 случае.
2080 Прим.
2082 Рекомендуется использовать iter >= 10000 и salt_len >= 8.
2083 Реализована упрощенная редакция алгоритма PBKDF2 (Password-Based
2085 Key Derivation Function version 2), определенного в PKCS#5.
2086 Редакция описана в СТБ 34.101.45 (приложение E).
2087 Аргументы
2089 key ключ
2090 pwd пароль
2091 pwd_len длина пароля (в октетах)
2092 iter число итераций
2093 salt синхропосылка ('соль')
2094 salt_len длина синхропосылки (в октетах)
2095 size_t beltSDE_keep ()
2097 Возвращается длина состояния (в октетах) функций шифрования в режиме
2098 SDE.
2099 Возвращает
2101 Длина состояние.
2102 err_t beltSDEDecr (void * dest, const void * src, size_t count, const octet
2104 key[], size_t len, const octet iv[16])
2105 Сектор [count]src расшифровывается на ключе [len]key с использованием
2106 синхропосылки iv. Результат расшифрования размещается в буфере
2107 [count]dest.
2108 Ожидается [ERR_BAD_INPUT]
2110 • len == 16 || len == 24 || len == 32;
2113 • count % 16 == 0 && count >= 32.
2115 Возвращает
2117 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
2118 случае.
2119 Прим.
2121 Буферы могут пересекаться.
2122 Аргументы
2124 dest открытый текст
2125 src шифртекст
2126 count число октетов текста
2127 key ключ
2128 len длина ключа
2129 iv синхропосылка
2130 err_t beltSDEEncr (void * dest, const void * src, size_t count, const octet
2132 key[], size_t len, const octet iv[16])
2133 Сектор [count]src зашифровывается на ключе [len]key с использованием
2134 синхропосылки iv. Результат зашифрования размещается в буфере
2135 [count]dest.
2136 Ожидается [ERR_BAD_INPUT]
2138 • len == 16 || len == 24 || len == 32;
2141 • count % 16 == 0 && count >= 32.
2143 Возвращает
2145 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
2146 случае.
2147 Прим.
2149 Буферы могут пересекаться.
2150 Аргументы
2152 dest шифртекст
2153 src открытый текст
2154 count число октетов текста
2155 key ключ
2156 len длина ключа
2157 iv синхропосылка
2158 void beltSDEStart (void * state, const octet key[], size_t len)
2160 По ключу [len]key и синхропосылке iv в state формируются структуры
2161 данных, необходимые для шифрования в режиме SDE.
2162 Предусловие
2164 len == 16 || len == 24 || len == 32.
2165 По адресу state зарезервировано beltSDE_keep() октетов.
2167 Прим.
2169 Буферы key и state могут пересекаться.
2170 Аргументы
2172 state состояние
2173 key ключ
2174 len длина ключа в октетах
2175 void beltSDEStepD (void * buf, size_t count, const octet iv[16], void *
2177 state)
2178 Сектор [count]buf расшифровывается в режиме SDE на ключе, размещенном в
2179 state, и синхропосылке iv.
2180 Предусловие
2182 count % 16 == 0 && count >= 32.
2183 Ожидается
2185 beltSDEStart() < beltSDEStepD()*.
2186 Аргументы
2188 buf шифртекст / открытый текст
2189 count число октетов текста
2190 iv синхропосылка
2191 state состояние
2192 void beltSDEStepE (void * buf, size_t count, const octet iv[16], void *
2194 state)
2195 Сектор [count]buf зашифровывается в режиме SDE на ключе, размещенном в
2196 state, и синхропосылке iv.
2197 Предусловие
2199 count % 16 == 0 && count >= 32.
2200 Ожидается
2202 beltSDEStart() < beltSDEStepE()*.
2203 Аргументы
2205 buf открытый текст / шифртекст
2206 count число октетов текста
2207 iv синхропосылка
2208 state состояние
2209 size_t beltWBL_keep ()
2211 Возвращается длина состояния (в октетах) функций WBL.
2212 Возвращает
2214 Длина состояния.
2215 void beltWBLStart (void * state, const octet key[], size_t len)
2217 По ключу [len]key в state формируются структуры данных, необходимые для
2218 шифрования в режиме WBL.
2219 Предусловие
2221 len == 16 || len == 24 || len == 32.
2222 По адресу state зарезервировано beltWBL_keep() октетов.
2224 Прим.
2226 Буферы key и state могут пересекаться.
2227 Аргументы
2229 state состояние
2230 key ключ
2231 len длина ключа в октетах
2232 void beltWBLStepD (void * buf, size_t count, void * state)
2234 Буфер [count]buf расшифровывается на ключе, размещенном в state.
2235 Результат расшифрования сохраняется в buf.
2236 Предусловие
2238 count >= 32.
2239 Ожидается
2241 beltWBLStart() < beltWBLStepD()*.
2242 Аргументы
2244 buf шифртекст / открытый текст
2245 count число октетов данных
2246 state состояние
2247 void beltWBLStepD2 (void * buf1, void * buf2, size_t count, void * state)
2249 Буфер [count - 16]buf1 || [16]buf2 расшифровывается в режиме WBL на
2250 ключе, размещенном в state. Результат расшифрования сохраняется в buf1
2251 || buf2.
2252 Предусловие
2254 count >= 32.
2255 Буферы buf1 и buf2 не пересекаются.
2257 Ожидается
2259 beltWBLStart() < beltWBLStepD2()*.
2260 Прим.
2262 С помощью beltWBLStepD2() снятие защиты с ключа в механизме KWP
2263 может быть организовано по следующей схеме:
2264 • первая часть защищенного ключа помещается в buf1;
2266 • вторая часть защищенного ключа помещается в buf2;
2268 • применяется beltWBLStepD2();
2270 • если buf2 совпадает с заголовком ключа, то buf1 принимается как
2272 ключ.
2273 Аргументы
2275 buf1 первая часть шифртекста / открытого текста
2276 buf2 вторая часть шифртекста / открытого текста
2277 count длина текста
2278 state состояние
2279 void beltWBLStepE (void * buf, size_t count, void * state)
2281 Буфер [count]buf зашифровывается на ключе, размещенном в state.
2282 Результат зашифрования сохраняется в buf.
2283 Предусловие
2285 count >= 32.
2286 Ожидается
2288 beltWBLStart() < beltWBLStepE()*.
2289 Аргументы
2291 buf открытый текст / шифртекст
2292 count число октетов текста
2293 state состояние
2294 void beltWBLStepR (void * buf, size_t count, void * state)
2296 Буфер [count]buf зашифровывается на ключе, размещенном в state.
2297 Результат зашифрования сохраняется в buf. При первом обращении счетчик
2298 i меняется от 1 до 2n, при втором --- от 2n + 1 до 4n, и так далее.
2299 Предусловие
2301 count >= 32.
2302 Ожидается
2304 beltWBLStart() < beltWBLStepR()*.
2305 Прим.
2307 Многократное зашифрование в режиме WBL используется для генерации
2308 одноразового ключа в СТБ 34.101.45. Поэтому функции назначен
2309 суффикс R.
2310 Аргументы
2312 buf открытый текст / шифртекст
2313 count число октетов текста
2314 state состояние
2315
2317 Автоматически создано Doxygen для Библиотека Bee2 из исходного текста.
2318Библиотека Bee2 Ср 19 Июл 2023 00:00:00 belt.h(3)