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 #define beltKWP_keep beltWBL_keep
20 Низкоуровневые функции KWP.
21 Функции
23 const octet * beltH ()
24 Блок подстановки H.
25 void beltKeyExpand (octet key_[32], const octet key[], size_t len)
26 Расширение ключа
27 void beltKeyExpand2 (u32 key_[8], const octet key[], size_t len)
28 Расширение и форматирование ключа
29 void beltBlockEncr (octet block[16], const u32 key[8])
30 Зашифрование блока
31 void beltBlockEncr2 (u32 block[4], const u32 key[8])
32 Зашифрование форматированного блока
33 void beltBlockEncr3 (u32 *a, u32 *b, u32 *c, u32 *d, const u32 key[8])
34 Зашифрование блока из четверки слов
35 void beltBlockDecr (octet block[16], const u32 key[8])
36 Расшифрование блока
37 void beltBlockDecr2 (u32 block[4], const u32 key[8])
38 Расшифрование форматированного блока
39 void beltBlockDecr3 (u32 *a, u32 *b, u32 *c, u32 *d, const u32 key[8])
40 Расшифрование блока из четверки слов
41 size_t beltWBL_keep ()
42 Длина состояния функций WBL.
43 void beltWBLStart (void *state, const octet key[], size_t len)
44 Инициализация функций WBL.
45 void beltWBLStepE (void *buf, size_t count, void *state)
46 Зашифрование в режиме WBL.
47 void beltWBLStepD (void *buf, size_t count, void *state)
48 Расшифрование в режиме WBL.
49 void beltWBLStepD2 (void *buf1, void *buf2, size_t count, void *state)
50 Расшифрование в режиме WBL с двумя частями
51 void beltWBLStepR (void *buf, size_t count, void *state)
52 Продолженное зашифрование в режиме WBL.
53 size_t beltCompr_deep ()
54 Глубина стека функций сжатия
55 void beltCompr (u32 h[8], const u32 X[8], void *stack)
56 Сжатие форматированных данных
57 void beltCompr2 (u32 s[4], u32 h[8], const u32 X[8], void *stack)
58 Сжатие форматированных данных со сложением
59 size_t beltECB_keep ()
60 Длина состояния функций ECB.
61 void beltECBStart (void *state, const octet key[], size_t len)
62 Инициализация шифрования в режиме ECB.
63 void beltECBStepE (void *buf, size_t count, void *state)
64 Зашифрование фрагмента в режиме ECB.
65 void beltECBStepD (void *buf, size_t count, void *state)
66 Расшифрование в режиме ECB.
67 err_t beltECBEncr (void *dest, const void *src, size_t count, const
68 octet key[], size_t len)
69 Зашифрование в режиме ECB.
70 err_t beltECBDecr (void *dest, const void *src, size_t count, const
71 octet key[], size_t len)
72 Расшифрование в режиме ECB.
73 size_t beltCBC_keep ()
74 Длина состояния функций CBC.
75 void beltCBCStart (void *state, const octet key[], size_t len, const
76 octet iv[16])
77 Инициализация шифрования в режиме CBC.
78 void beltCBCStepE (void *buf, size_t count, void *state)
79 Зашифрование в режиме CBC.
80 void beltCBCStepD (void *buf, size_t count, void *state)
81 Расшифрование в режиме CBC.
82 err_t beltCBCEncr (void *dest, const void *src, size_t count, const
83 octet key[], size_t len, const octet iv[16])
84 Зашифрование в режиме CBC.
85 err_t beltCBCDecr (void *dest, const void *src, size_t count, const
86 octet key[], size_t len, const octet iv[16])
87 Расшифрование в режиме CBC.
88 size_t beltCFB_keep ()
89 Длина состояния функций CFB.
90 void beltCFBStart (void *state, const octet key[], size_t len, const
91 octet iv[16])
92 Инициализация шифрования в режиме CFB.
93 void beltCFBStepE (void *buf, size_t count, void *state)
94 Зашифрование в режиме CFB.
95 void beltCFBStepD (void *buf, size_t count, void *state)
96 Расшифрование в режиме CFB.
97 err_t beltCFBEncr (void *dest, const void *src, size_t count, const
98 octet key[], size_t len, const octet iv[16])
99 Зашифрование в режиме CFB.
100 err_t beltCFBDecr (void *dest, const void *src, size_t count, const
101 octet key[], size_t len, const octet iv[16])
102 Расшифрование в режиме CFB.
103 size_t beltCTR_keep ()
104 Длина состояния функций CTR.
105 void beltCTRStart (void *state, const octet key[], size_t len, const
106 octet iv[16])
107 Инициализация шифрования в режиме CTR.
108 void beltCTRStepE (void *buf, size_t count, void *state)
109 Зашифрование фрагмента в режиме CTR.
110 err_t beltCTR (void *dest, const void *src, size_t count, const octet
111 key[], size_t len, const octet iv[16])
112 Шифрование в режиме CTR.
113 size_t beltMAC_keep ()
114 Длина состояния функций MAC.
115 void beltMACStart (void *state, const octet key[], size_t len)
116 Инициализация функций MAC.
117 void beltMACStepA (const void *buf, size_t count, void *state)
118 Имитозащита фрагмента данных в режиме MAC.
119 void beltMACStepG (octet mac[8], void *state)
120 Определение имитовставки в режиме MAC.
121 void beltMACStepG2 (octet mac[], size_t mac_len, void *state)
122 Определение усеченной имитовставки в режиме MAC.
123 bool_t beltMACStepV (const octet mac[8], void *state)
124 Проверка имитовставки в режиме MAC.
125 bool_t beltMACStepV2 (const octet mac[], size_t mac_len, void *state)
126 Проверка усеченной имитовставки
127 err_t beltMAC (octet mac[8], const void *src, size_t count, const octet
128 key[], size_t len)
129 Имитозащита в режиме MAC.
130 size_t beltDWP_keep ()
131 Длина состояния функций DWP.
132 void beltDWPStart (void *state, const octet key[], size_t len, const
133 octet iv[16])
134 Инициализация функций DWP.
135 void beltDWPStepE (void *buf, size_t count, void *state)
136 Зашифрование критического фрагмента в режиме DWP.
137 void beltDWPStepI (const void *buf, size_t count, void *state)
138 Имитозащита открытого фрагмента в режиме DWP.
139 void beltDWPStepA (const void *buf, size_t count, void *state)
140 Имитозащита критического фрагмента в режиме DWP.
141 void beltDWPStepG (octet mac[8], void *state)
142 Определение имитовставки в режиме DWP.
143 bool_t beltDWPStepV (const octet mac[8], void *state)
144 Проверка имитовставки в режиме DWP.
145 void beltDWPStepD (void *buf, size_t count, void *state)
146 Расшифрование критического фрагмента в режиме DWP.
147 err_t beltDWPWrap (void *dest, octet mac[8], const void *src1, size_t
148 count1, const void *src2, size_t count2, const octet key[], size_t
149 len, const octet iv[16])
150 Установка защиты в режиме DWP.
151 err_t beltDWPUnwrap (void *dest, const void *src1, size_t count1, const
152 void *src2, size_t count2, const octet mac[8], const octet key[],
153 size_t len, const octet iv[16])
154 Снятие защиты в режиме DWP.
155 size_t beltCHE_keep ()
156 Длина состояния функций CHE.
157 void beltCHEStart (void *state, const octet key[], size_t len, const
158 octet iv[16])
159 Инициализация функций CHE.
160 void beltCHEStepE (void *buf, size_t count, void *state)
161 Зашифрование критического фрагмента в режиме CHE.
162 void beltCHEStepI (const void *buf, size_t count, void *state)
163 Имитозащита открытого фрагмента в режиме CHE.
164 void beltCHEStepA (const void *buf, size_t count, void *state)
165 Имитозащита критического фрагмента в режиме CHE.
166 void beltCHEStepG (octet mac[8], void *state)
167 Определение имитовставки в режиме CHE.
168 bool_t beltCHEStepV (const octet mac[8], void *state)
169 Проверка имитовставки в режиме CHE.
170 void beltCHEStepD (void *buf, size_t count, void *state)
171 Расшифрование критического фрагмента в режиме CHE.
172 err_t beltCHEWrap (void *dest, octet mac[8], const void *src1, size_t
173 count1, const void *src2, size_t count2, const octet key[], size_t
174 len, const octet iv[16])
175 Установка защиты в режиме CHE.
176 err_t beltCHEUnwrap (void *dest, const void *src1, size_t count1, const
177 void *src2, size_t count2, const octet mac[8], const octet key[],
178 size_t len, const octet iv[16])
179 Снятие защиты в режиме CHE.
180 err_t beltKWPWrap (octet dest[], const octet src[], size_t count, const
181 octet header[16], const octet key[], size_t len)
182 Установка защиты в режиме KWP.
183 err_t beltKWPUnwrap (octet dest[], const octet src[], size_t count,
184 const octet header[16], const octet key[], size_t len)
185 Снятие защиты в режиме KWP.
186 size_t beltHash_keep ()
187 Длина состояния функции хэширования
188 void beltHashStart (void *state)
189 Инициализация функции хэширования
190 void beltHashStepH (const void *buf, size_t count, void *state)
191 Хэширование фрагмента данных
192 void beltHashStepG (octet hash[32], void *state)
193 Определение хэш-значения
194 void beltHashStepG2 (octet hash[], size_t hash_len, void *state)
195 Определение усеченного хэш-значения
196 bool_t beltHashStepV (const octet hash[32], void *state)
197 Проверка хэш-значения
198 bool_t beltHashStepV2 (const octet hash[], size_t hash_len, void
199 *state)
200 Проверка усеченного хэш-значения
201 err_t beltHash (octet hash[32], const void *src, size_t count)
202 Хэширование
203 size_t beltBDE_keep ()
204 Длина состояния функций BDE.
205 void beltBDEStart (void *state, const octet key[], size_t len, const
206 octet iv[16])
207 Инициализация шифрования в режиме BDE.
208 void beltBDEStepE (void *buf, size_t count, void *state)
209 Шаг зашифрования в режиме BDE.
210 void beltBDEStepD (void *buf, size_t count, void *state)
211 Шаг расшифрования в режиме BDE.
212 err_t beltBDEEncr (void *dest, const void *src, size_t count, const
213 octet key[], size_t len, const octet iv[16])
214 Зашифрование в режиме BDE.
215 err_t beltBDEDecr (void *dest, const void *src, size_t count, const
216 octet key[], size_t len, const octet iv[16])
217 Расшифрование в режиме BDE.
218 size_t beltSDE_keep ()
219 Длина состояния функций SDE.
220 void beltSDEStart (void *state, const octet key[], size_t len)
221 Инициализация шифрования в режиме SDE.
222 void beltSDEStepE (void *buf, size_t count, const octet iv[16], void
223 *state)
224 Шаг зашифрования в режиме SDE.
225 void beltSDEStepD (void *buf, size_t count, const octet iv[16], void
226 *state)
227 Шаг расшифрования в режиме SDE.
228 err_t beltSDEEncr (void *dest, const void *src, size_t count, const
229 octet key[], size_t len, const octet iv[16])
230 Зашифрование в режиме SDE.
231 err_t beltSDEDecr (void *dest, const void *src, size_t count, const
232 octet key[], size_t len, const octet iv[16])
233 Расшифрование в режиме SDE.
234 size_t beltFMT_keep (u32 mod, size_t count)
235 Длина состояния функций FMT.
236 void beltFMTStart (void *state, u32 mod, size_t count, const octet
237 key[], size_t len)
238 Инициализация шифрования в режиме FMT.
239 void beltFMTStepE (u16 buf[], const octet iv[16], void *state)
240 Шаг зашифрования в режиме FMT.
241 void beltFMTStepD (u16 buf[], const octet iv[16], void *state)
242 Шаг расшифрования в режиме FMT.
243 err_t beltFMTEncr (u16 dest[], u32 mod, const u16 src[], size_t count,
244 const octet key[], size_t len, const octet iv[16])
245 Зашифрование в режиме FMT.
246 err_t beltFMTDecr (u16 dest[], u32 mod, const u16 src[], size_t count,
247 const octet key[], size_t len, const octet iv[16])
248 Расшифрование в режиме FMT.
249 size_t beltKRP_keep ()
250 Длина состояния функций преобразования ключа
251 void beltKRPStart (void *state, const octet key[], size_t len, const
252 octet level[12])
253 Инициализация функций преобразования ключа
254 void beltKRPStepG (octet key_[], size_t key_len, const octet
255 header[16], void *state)
256 Тиражирование ключа
257 err_t beltKRP (octet dest[], size_t m, const octet src[], size_t n,
258 const octet level[12], const octet header[16])
259 Преобразование ключа
260 size_t beltHMAC_keep ()
261 Длина состояния функций HMAC.
262 void beltHMACStart (void *state, const octet key[], size_t len)
263 Инициализация функций HMAC.
264 void beltHMACStepA (const void *buf, size_t count, void *state)
265 Имитозащита фрагмента данных в режиме HMAC.
266 void beltHMACStepG (octet mac[32], void *state)
267 Определение имитовставки в режиме HMAC.
268 void beltHMACStepG2 (octet mac[], size_t mac_len, void *state)
269 Определение усеченной имитовставки в режиме HMAC.
270 bool_t beltHMACStepV (const octet mac[32], void *state)
271 Проверка имитовставки в режиме HMAC.
272 bool_t beltHMACStepV2 (const octet mac[], size_t mac_len, void *state)
273 Проверка усеченной имитовставки
274 err_t beltHMAC (octet mac[32], const void *src, size_t count, const
275 octet key[], size_t len)
276 Имитозащита в режиме HMAC.
277 err_t beltPBKDF2 (octet key[32], const octet pwd[], size_t pwd_len,
278 size_t iter, const octet salt[], size_t salt_len)
279 Построение ключа по паролю
280
282 Реализованы алгоритмы СТБ 34.101.31 (belt). Дополнительно реализованы
283 алгоритм ключезависимого хэширования (HMAC), основанный на функции
284 хэширования belt-hash, и алгоритм построения ключа по паролю,
285 основанный на HMAC[belt-hash]. Эти алгоритмы определены соответственно
286 в СТБ 34.101.47 и в СТБ 34.101.45.
287 Основные алгоритмы объединяются в группы, которые определяют следующие
289 криптографические механизмы:
290 • ECB --- шифрование в режиме простой замены;
292 • CBC --- шифрование в режиме сцепления блоков;
294 • CFB --- шифрование в режиме гаммирования с обратной связью;
296 • CTR --- шифрование в режиме счетчика;
298 • MAC --- имитозащита на основе шифрования;
300 • DWP --- аутентифицированное шифрование данных, схема DWP;
302 • CHE --- аутентифицированное шифрование данных, схема CHE;
304 • KWP --- аутентифицированное шифрование ключей;
306 • Hash --- хэширование;
308 • BDE --- блоковое дисковое шифрование;
310 • SDE --- секторное дисковое шифрование;
312 • FMT --- шифрование с сохранением формата;
314 • KRP --- преобразование ключей;
316 • HMAC --- имитозащита на основе хэширования.
318 Механизмы построены на базовых криптографических алгоритмах шифрования
320 блока (Block), шифрования широкого блока (WBL) и сжатия (Compr).
321 Механизм WBL определен в новой редакции СТБ 34.101.31 и представляет
322 собой ядро KWP.
323 В механизмах ECB, CBC, CFB, CTR, MAC, DWP, CHE, KWP, BDE, SDE, FMT, KRP
325 используется ключ из 32 октетов. Ключ такой длины может быть построен
326 по ключу из 16 или 24 октетов с помощью функции beltExpand().
327 В механизме HMAC используется ключ произвольной длины. Рекомендуется
329 использовать ключ из 32 октетов.
330 В механизмах ECB, CBC, CFB, CTR, MAC, DWP, CHE, KWP, BDE данные
332 обрабатываются блоками по 16 октетов.
333 В механизмах Hash, HMAC данные обрабатываются блоками по 32 октета.
335 В механизме SDE обрабатываются секторы. Сектор состоит из двух или
337 более полных 16-октетных блоков.
338 В механизме FMT обрабатываются строки длины count в алфавите ZZ_mod =
340 {0, 1,..., mod - 1}. Здесь mod -- размер алфавита или модуль. Должны
341 выполняться следующие ограничения:
342 • 2 <= mod && mod <= 65536;
344 • 2 <= count && count <= 600. Последнее ограничение -- ограничение
346 реализации.
347 На вход основных и вспомогательных функций данные и ключи подаются либо
349 как void-массивы (неформатированные данные, по умолчанию), либо как
350 массивы u32 (форматированные данные). Внутри функций неформатированные
351 данные форматируются перед использованием. На платформах с соглашениями
352 BIG_ENDIAN форматирование требует дополнительного времени.
353 Каждый механизм реализуется связкой из нескольких функций. Эти функции
355 используют общее состояние, указатель на которое передается в функции
356 как дополнительный параметр. Имеются функция определения объема памяти
357 для состояния (_keep). Память для состояния готовит вызывающая
358 программа и она же отвечает за очистку памяти.
359 Состояние можно копировать как фрагмент памяти.
361 В связке обязательно имеется функция инициализации механизма (Start) и
363 одна или несколько функций обработки фрагментов данных и получения
364 результатов обработки (StepX).
365 Логика суффиксов функций StepX:
367 • E -- encrypt (зашифровать);
369 • D -- decrypt (расшифровать);
371 • A -- authenticate (имитозащита);
373 • I -- имитозащита открытых данных в режиме DWP;
375 • H -- hashing (хэширование);
377 • G -- get (получить имитовставку, хэш-значение или новый ключ);
379 • V -- verify (проверить хэш-значение, имитовставку);
381 • R -- random (псевдослучайная генерация).
383 Функции связки спроектированы как максимально простые и эффективные. В
385 частности, в этих функциях не проверяются входные данные.
386 Каждая связка покрывается высокоуровневой функцией, которая
388 обрабатывает все данные целиком. В высокоуровневых функциях есть
389 проверка входных данных.
390 Механизмы MAC, Hash, HMAC, DWP, CHE реализованы с поддержкой принципа
392 get-then-continue. Это означает, что после обработки определенной
393 порции данных можно вызвать функцию типа StepG, а затем продолжить
394 обработку.
395 Ожидается
397 Общее состояние связки функций не изменяется вне этих функций.
398 Ожидается [ERR_BAD_INPUT]
400 Все входные указатели высокоуровневых функций действительны.
401 Предусловие
403 Все входные указатели низкоуровневых функций действительны.
404 Если не оговорено противное, то входные буферы функций связки не
406 пересекаются.
407
409 #define beltCTRStepD beltCTRStepE
410 Прим.
411 Зашифрование в режиме CTR не отличается от расшифрования.
412 #define beltKWP_keep beltWBL_keep
414 Прим.
415 Повторяются функции механизма WBL.
416
418 size_t beltBDE_keep ()
419 Возвращается длина состояния (в октетах) функций шифрования в режиме
420 BDE.
421 Возвращает
423 Длина состояние.
424 err_t beltBDEDecr (void * dest, const void * src, size_t count, const octet
426 key[], size_t len, const octet iv[16])
427 Буфер [count]src расшифровывается на ключе [len]key с использованием
428 синхропосылки iv. Результат расшифрования размещается в буфере
429 [count]dest.
430 Ожидается [ERR_BAD_INPUT]
432 • len == 16 || len == 24 || len == 32;
435 • count % 16 == 0 && count >= 16.
437 Возвращает
439 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
440 случае.
441 Прим.
443 Буферы могут пересекаться.
444 Аргументы
446 dest открытый текст
447 src шифртекст
448 count число октетов текста
449 key ключ
450 len длина ключа
451 iv синхропосылка
452 err_t beltBDEEncr (void * dest, const void * src, size_t count, const octet
454 key[], size_t len, const octet iv[16])
455 Буфер [count]src зашифровывается на ключе [len]key с использованием
456 синхропосылки iv. Результат зашифрования размещается в буфере
457 [count]dest.
458 Ожидается [ERR_BAD_INPUT]
460 • len == 16 || len == 24 || len == 32;
463 • count % 16 == 0 && count >= 16.
465 Возвращает
467 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
468 случае.
469 Прим.
471 Буферы могут пересекаться.
472 Аргументы
474 dest шифртекст
475 src открытый текст
476 count число октетов текста
477 key ключ
478 len длина ключа
479 iv синхропосылка
480 void beltBDEStart (void * state, const octet key[], size_t len, const octet
482 iv[16])
483 По ключу [len]key и синхропосылке iv в state формируются структуры
484 данных, необходимые для шифрования в режиме BDE.
485 Предусловие
487 len == 16 || len == 24 || len == 32.
488 По адресу state зарезервировано beltBDE_keep() октетов.
490 Прим.
492 Буферы key и state могут пересекаться.
493 Аргументы
495 state состояние
496 key ключ
497 len длина ключа в октетах
498 iv синхропосылка
499 void beltBDEStepD (void * buf, size_t count, void * state)
501 Буфер [count]buf расшифровывается в режиме BDE на ключе, размещенном в
502 state.
503 Предусловие
505 count % 16 == 0.
506 Ожидается
508 beltBDEStart() < beltBDEStepD()*.
509 Аргументы
511 buf шифртекст / открытый текст
512 count число октетов текста
513 state состояние
514 void beltBDEStepE (void * buf, size_t count, void * state)
516 Буфер [count]buf зашифровывается в режиме BDE на ключе, размещенном в
517 state.
518 Предусловие
520 count % 16 == 0.
521 Ожидается
523 beltBDEStart() < beltBDEStepE()*.
524 Аргументы
526 buf открытый текст / шифртекст
527 count число октетов текста
528 state состояние
529 void beltBlockDecr (octet block[16], const u32 key[8])
531 Выполняется расшифрование блока данных block на форматированном ключе
532 key. Результат расшифрования возвращается по адресу block.
533 Аргументы
535 block блок
536 key ключ
537 void beltBlockDecr2 (u32 block[4], const u32 key[8])
539 Выполняется расшифрование форматированного блока данных block на
540 форматированном ключе key. Результат расшифрования возвращается по
541 адресу block.
542 Аргументы
544 block блок
545 key ключ
546 void beltBlockDecr3 (u32 * a, u32 * b, u32 * c, u32 * d, const u32 key[8])
548 Выполняется расшифрование форматированного блока (a, b, c, d),
549 заданного четверкой последовательных 32-разрядных слов, на
550 форматированном ключе key. Результат расшифрования возвращается через
551 входные слова.
552 Аргументы
554 a слово a
555 b слово b
556 c слово c
557 d слово d
558 key ключ
559 void beltBlockEncr (octet block[16], const u32 key[8])
561 Выполняется зашифрование блока данных block на форматированном ключе
562 key. Результат зашифрования возвращается по адресу block.
563 Аргументы
565 block блок
566 key ключ
567 void beltBlockEncr2 (u32 block[4], const u32 key[8])
569 Выполняется зашифрование форматированного блока данных block на
570 форматированном ключе key. Результат зашифрования возвращается по
571 адресу block.
572 Аргументы
574 block блок
575 key ключ
576 void beltBlockEncr3 (u32 * a, u32 * b, u32 * c, u32 * d, const u32 key[8])
578 Выполняется зашифрование форматированного блока (a, b, c, d), заданного
579 четверкой последовательных 32-разрядных слов, на форматированном ключе
580 key. Результат зашифрования возвращается через входные слова.
581 Аргументы
583 a слово a
584 b слово b
585 c слово c
586 d слово d
587 key ключ
588 size_t beltCBC_keep ()
590 Возвращается длина состояния (в октетах) функций шифрования в режиме
591 CBC.
592 Возвращает
594 Длина состояние.
595 err_t beltCBCDecr (void * dest, const void * src, size_t count, const octet
597 key[], size_t len, const octet iv[16])
598 Буфер [count]src расшифровывается на ключе [len]key с использованием
599 синхропосылки iv. Результат расшифрования размещается в буфере
600 [count]dest.
601 Ожидается [ERR_BAD_INPUT]
603 • len == 16 || len == 24 || len == 32;
606 • count >= 16.
608 Возвращает
610 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
611 случае.
612 Прим.
614 Буферы могут пересекаться.
615 Аргументы
617 dest открытый текст
618 src шифртекст
619 count число октетов текста
620 key ключ
621 len длина ключа
622 iv синхропосылка
623 err_t beltCBCEncr (void * dest, const void * src, size_t count, const octet
625 key[], size_t len, const octet iv[16])
626 Буфер [count]src зашифровывается на ключе [len]key с использованием
627 синхропосылки iv. Результат зашифрования размещается в буфере
628 [count]dest.
629 Ожидается [ERR_BAD_INPUT]
631 • len == 16 || len == 24 || len == 32;
634 • count >= 16.
636 Возвращает
638 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
639 случае.
640 Прим.
642 Буферы могут пересекаться.
643 Аргументы
645 dest шифртекст
646 src открытый текст
647 count число октетов текста
648 key ключ
649 len длина ключа
650 iv синхропосылка
651 void beltCBCStart (void * state, const octet key[], size_t len, const octet
653 iv[16])
654 По ключу [len]key и синхропосылке iv в state формируются структуры
655 данных, необходимые для шифрования в режиме CBC.
656 Предусловие
658 len == 16 || len == 24 || len == 32.
659 По адресу state зарезервировано beltCBC_keep() октетов.
661 Прим.
663 Буферы key и state могут пересекаться.
664 Аргументы
666 state состояние
667 key ключ
668 len длина ключа в октетах
669 iv синхропосылка
670 void beltCBCStepD (void * buf, size_t count, void * state)
672 Буфер [count]buf расшифровывается в режиме CBC на ключе, размещенном в
673 state.
674 Предусловие
676 count >= 16.
677 Ожидается
679 beltCBCStart() < beltCBCStepD()*.
680 Прим.
682 Сохраняются замечания по функции beltCBCStepE().
683 Аргументы
685 buf шифртекст / открытый текст
686 count число октетов текста
687 state состояние
688 void beltCBCStepE (void * buf, size_t count, void * state)
690 Буфер [count]buf зашифровывается в режиме CBC на ключе, размещенном в
691 state.
692 Предусловие
694 count >= 16.
695 Ожидается
697 beltCBCStart() < beltCBCStepE()*.
698 Прим.
700 К функции можно обратиться несколько раз, передавая buf из полных
701 блоков. Неполный блок можно передать только при последнем
702 обращении. В этом случае выполняется 'кража' блока (ciphertext
703 stealing, CTS).
704 При организации последовательных обращений к функции следует
706 учитывать, что буфер buf должен содержать не менее одного блока.
707 Например для зашифрования 33 октетов можно зашифровать сначала 16
708 октетов, а затем еще 17. Но нельзя зашифровать сначала 32 октета, а
709 затем еще 1.
710 Аргументы
712 buf открытый текст / шифртекст
713 count число октетов текста
714 state состояние
715 size_t beltCFB_keep ()
717 Возвращается длина состояния (в октетах) функций шифрования в режиме
718 CFB.
719 Возвращает
721 Длина состояния.
722 err_t beltCFBDecr (void * dest, const void * src, size_t count, const octet
724 key[], size_t len, const octet iv[16])
725 Буфер [count]src расшифровывается на ключе [len]key с использованием
726 синхропосылки iv. Результат расшифрования размещается в буфере
727 [count]dest.
728 Ожидается [ERR_BAD_INPUT]
730 len == 16 || len == 24 || len == 32.
731 Возвращает
733 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
734 случае.
735 Прим.
737 Буферы могут пересекаться.
738 Аргументы
740 dest открытый текст
741 src шифртекст
742 count число октетов текста
743 key ключ
744 len длина ключа
745 iv синхропосылка
746 err_t beltCFBEncr (void * dest, const void * src, size_t count, const octet
748 key[], size_t len, const octet iv[16])
749 Буфер [count]src зашифровывается на ключе [len]key с использованием
750 синхропосылки iv. Результат зашифрования размещается в буфере
751 [count]dest.
752 Ожидается [ERR_BAD_INPUT]
754 len == 16 || len == 24 || len == 32.
755 Возвращает
757 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
758 случае.
759 Прим.
761 Буферы могут пересекаться.
762 Аргументы
764 dest шифртекст
765 src открытый текст
766 count число октетов текста
767 key ключ
768 len длина ключа
769 iv синхропосылка
770 void beltCFBStart (void * state, const octet key[], size_t len, const octet
772 iv[16])
773 По ключу [len]key и синхропосылке iv в state формируются структуры
774 данных, необходимые для шифрования в режиме CFB.
775 Предусловие
777 len == 16 || len == 24 || len == 32.
778 По адресу state зарезервировано beltCFB_keep() октетов.
780 Прим.
782 Буферы key и state могут пересекаться.
783 Аргументы
785 state состояние
786 key ключ
787 len длина ключа в октетах
788 iv синхропосылка
789 void beltCFBStepD (void * buf, size_t count, void * state)
791 Буфер [count]buf расшифровывается в режиме CFB на ключе, размещенном в
792 state.
793 Ожидается
795 beltCFBStart() < beltCFBStepD()*.
796 Аргументы
798 buf шифртекст / открытый текст
799 count число октетов текста
800 state состояние
801 void beltCFBStepE (void * buf, size_t count, void * state)
803 Буфер [count]buf зашифровывается в режиме CFB на ключе, размещенном в
804 state.
805 Ожидается
807 beltCFBStart() < beltCFBStepE()*.
808 Аргументы
810 buf открытый текст / шифртекст
811 count число октетов текста
812 state состояние
813 size_t beltCHE_keep ()
815 Возвращается длина состояния (в октетах) функций CHE.
816 Возвращает
818 Длина состояния.
819 void beltCHEStart (void * state, const octet key[], size_t len, const octet
821 iv[16])
822 По ключу [len]key и синхропосылке iv в state формируются структуры
823 данных, необходимые для аутентифицированного шифрования в режиме CHE.
824 Предусловие
826 len == 16 || len == 24 || len == 32.
827 По адресу state зарезервировано beltCHE_keep() октетов.
829 Прим.
831 Буферы key и state могут пересекаться.
832 Аргументы
834 state состояние
835 key ключ
836 len длина ключа в октетах
837 iv синхропосылка
838 void beltCHEStepA (const void * buf, size_t count, void * state)
840 Текущая имитовставка, размещенная в state, пересчитывается с учетом
841 нового фрагмента зашифрованных критических данных [count]buf. Пересчет
842 выполняется на ключе, также размещенном в state.
843 Ожидается
845 По адресу state зарезервировано beltCHE_keep() октетов.
846 Ожидается
848 beltCHEStepI()* < beltCHEStepA()*.
849 Ожидается
851 beltCHEStepE()* < beltCHEStepA()*.
852 Аргументы
854 buf критические данные
855 count число октетов данных
856 state состояние
857 void beltCHEStepD (void * buf, size_t count, void * state)
859 Фрагмент зашифрованных критических данных [count]buf расшифровывается
860 на ключе, размещенном в state. Результат расшифрования сохраняется в
861 buf.
862 Ожидается
864 beltCHEStepG() < beltCHEStepD().
865 Ожидается
867 beltCHEStepA()* < beltCHEStepD().
868 Аргументы
870 buf критические данные
871 count число октетов данных
872 state состояние
873 void beltCHEStepE (void * buf, size_t count, void * state)
875 Фрагмент критических данных [count]buf зашифровывается на ключе,
876 размещенном в state. Результат зашифрования сохраняется в buf.
877 Ожидается
879 beltCHEStart() < beltCHEStepE()*.
880 Аргументы
882 buf критические данные
883 count число октетов данных
884 state состояние
885 void beltCHEStepG (octet mac[8], void * state)
887 Определяется окончательная имитовставка mac всех данных, обработанных
888 до этого функциями beltCHEStepI() и beltCHEStepA().
889 Ожидается
891 beltCHEStepI()* < beltCHEStepG().
892 Ожидается
894 beltCHEStepA()* < beltCHEStepG().
895 Предупреждения
897 При выполнении функции состояние state изменяется так, что
898 продолжение имитозащиты становится некорректным.
899 Аргументы
901 mac имитовставка
902 state состояние
903 void beltCHEStepI (const void * buf, size_t count, void * state)
905 Текущая имитовставка, размещенная в state, пересчитывается с учетом
906 нового фрагмента открытых данных [count]buf. Пересчет выполняется на
907 ключе, также размещенном в state.
908 Ожидается
910 beltCHEStart() < beltCHEStepI()*.
911 Аргументы
913 buf открытые данные
914 count число октетов данных
915 state состояние
916 bool_t beltCHEStepV (const octet mac[8], void * state)
918 Проверяется, что окончательная имитовставка всех данных, обработанных
919 до этого функциями beltCHEStepI() и beltCHEStepA(), совпадает с mac.
920 Ожидается
922 beltCHEStepI()* < beltCHEStepV().
923 Ожидается
925 beltCHEStepA()* < beltCHEStepV().
926 Возвращает
928 Признак успеха.
929 Предупреждения
931 При выполнении функции состояние state изменяется так, что
932 продолжение имитозащиты становится некорректным.
933 Аргументы
935 mac контрольная имитовставка
936 state состояние
937 err_t beltCHEUnwrap (void * dest, const void * src1, size_t count1, const
939 void * src2, size_t count2, const octet mac[8], const octet key[],
940 size_t len, const octet iv[16])
941 На ключе [len]key октетов с использованием имитовставки iv снимается
942 защита зашифрованных критических данных [count1]src1 и открытых данных
943 [count2]src2. При снятии защиты проверяется целостность пары (src1,
944 src2) с помощью имитовставки mac. Если целостность не нарушена, то
945 данные src1 расшифровываются в буфер [count1]dest.
946 Ожидается [ERR_BAD_INPUT]
948 len == 16 || len == 24 || len == 32.
949 Возвращает
951 ERR_OK, если защита успешно снята, и код ошибки в противном случае.
952 Прим.
954 Буферы могут пересекаться.
955 Аргументы
957 dest расшифрованные критические данные
958 src1 зашифрованные критические данные
959 count1 число октетов критических данных
960 src2 открытые данные
961 count2 число октетов открытых данных
962 mac имитовставка
963 key ключ
964 len длина ключа
965 iv синхропосылка
966 err_t beltCHEWrap (void * dest, octet mac[8], const void * src1, size_t
968 count1, const void * src2, size_t count2, const octet key[], size_t
969 len, const octet iv[16])
970 На ключе [len]key с использованием имитовставки iv устанавливается
971 защита критических данных [count1]src1 и открытых данных [count2]src2.
972 При установке защиты критические данные зашифровываются и сохраняются в
973 буфере [count1]dest. Кроме этого определяется имитовставка mac пары
974 (src1, src2).
975 Ожидается [ERR_BAD_INPUT]
977 • len == 16 || len == 24 || len == 32;
980 • буферы dest и mac не пересекаются.
982 Возвращает
984 ERR_OK, если защита успешно установлена, и код ошибки в противном
985 случае.
986 Прим.
988 Буферы могут пересекаться, за исключением пересечения dest и mac.
989 Аргументы
991 dest зашифрованные критические данные
992 mac имитовставка
993 src1 критические данные
994 count1 число октетов критических данных
995 src2 открытые данные
996 count2 число октетов открытых данных
997 key ключ
998 len длина ключа
999 iv синхропосылка
1000 void beltCompr (u32 h[8], const u32 X[8], void * stack)
1002 Форматированный буфер h || X сжимается до форматированного буфера h.
1003 Предусловие
1005 Буферы X и h не пересекаются.
1006 Схема расчета глубины stack
1008 beltCompr_deep().
1009 Аргументы
1011 h первая часть входа/выход
1012 X вторая часть входа
1013 stack стек
1014 void beltCompr2 (u32 s[4], u32 h[8], const u32 X[8], void * stack)
1016 Форматированный буфер h || X сжимается до форматированного буфера h.
1017 Внутренняя переменная S belt-compress добавдяется поразрядно по модулю
1018 2 к буферу s.
1019 Предусловие
1021 Буферы s и h, X и s, X и h не пересекаются.
1022 Схема расчета глубины stack
1024 beltCompr_deep().
1025 Аргументы
1027 s сумма
1028 h первая часть входа/выход
1029 X вторая часть входа
1030 stack стек
1031 size_t beltCompr_deep ()
1033 Возвращается глубина стека (в октетах) функций сжатия.
1034 Возвращает
1036 Глубина стека.
1037 err_t beltCTR (void * dest, const void * src, size_t count, const octet
1039 key[], size_t len, const octet iv[16])
1040 Буфер [count]src зашифровывается или расшифровывается на ключе [len]key
1041 с использованием синхропосылки iv. Результат шифрования размещается в
1042 буфере [count]dest.
1043 Ожидается [ERR_BAD_INPUT]
1045 len == 16 || len == 24 || len == 32.
1046 Возвращает
1048 ERR_OK, если шифрование завершено успешно, и код ошибки в противном
1049 случае.
1050 Прим.
1052 Буферы могут пересекаться.
1053 Аргументы
1055 dest шифртекст / открытый текст
1056 src открытый текст / шифртекст
1057 count число октетов текста
1058 key ключ
1059 len длина ключа
1060 iv синхропосылка
1061 size_t beltCTR_keep ()
1063 Возвращается длина состояния (в октетах) функций шифрования в режиме
1064 CTR.
1065 Возвращает
1067 Длина состояния.
1068 void beltCTRStart (void * state, const octet key[], size_t len, const octet
1070 iv[16])
1071 По ключу [len]key и синхропосылке iv в state формируются структуры
1072 данных, необходимые для шифрования в режиме CTR.
1073 Предусловие
1075 len == 16 || len == 24 || len == 32.
1076 По адресу state зарезервировано beltCTR_keep() октетов.
1078 Прим.
1080 Буферы key и state могут пересекаться.
1081 Аргументы
1083 state состояние
1084 key ключ
1085 len длина ключа в октетах
1086 iv синхропосылка
1087 void beltCTRStepE (void * buf, size_t count, void * state)
1089 Буфер [count]buf зашифровывается в режиме CTR на ключе, размещенном в
1090 state.
1091 Ожидается
1093 beltCTRStart() < beltCTRStepE()*.
1094 Аргументы
1096 buf открытый текст / шифртекст
1097 count число октетов текста
1098 state состояние
1099 size_t beltDWP_keep ()
1101 Возвращается длина состояния (в октетах) функций DWP.
1102 Возвращает
1104 Длина состояния.
1105 void beltDWPStart (void * state, const octet key[], size_t len, const octet
1107 iv[16])
1108 По ключу [len]key и синхропосылке iv в state формируются структуры
1109 данных, необходимые для аутентифицированного шифрования в режиме DWP.
1110 Предусловие
1112 len == 16 || len == 24 || len == 32.
1113 По адресу state зарезервировано beltDWP_keep() октетов.
1115 Прим.
1117 Буферы key и state могут пересекаться.
1118 Аргументы
1120 state состояние
1121 key ключ
1122 len длина ключа в октетах
1123 iv синхропосылка
1124 void beltDWPStepA (const void * buf, size_t count, void * state)
1126 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1127 нового фрагмента зашифрованных критических данных [count]buf. Пересчет
1128 выполняется на ключе, также размещенном в state.
1129 Ожидается
1131 По адресу state зарезервировано beltDWP_keep() октетов.
1132 Ожидается
1134 beltDWPStepI()* < beltDWPStepA()*.
1135 Ожидается
1137 beltDWPStepE()* < beltDWPStepA()*.
1138 Аргументы
1140 buf критические данные
1141 count число октетов данных
1142 state состояние
1143 void beltDWPStepD (void * buf, size_t count, void * state)
1145 Фрагмент зашифрованных критических данных [count]buf расшифровывается
1146 на ключе, размещенном в state. Результат расшифрования сохраняется в
1147 buf.
1148 Ожидается
1150 beltDWPStepG() < beltDWPStepD().
1151 Ожидается
1153 beltDWPStepA()* < beltDWPStepD().
1154 Аргументы
1156 buf критические данные
1157 count число октетов данных
1158 state состояние
1159 void beltDWPStepE (void * buf, size_t count, void * state)
1161 Фрагмент критических данных [count]buf зашифровывается на ключе,
1162 размещенном в state. Результат зашифрования сохраняется в buf.
1163 Ожидается
1165 beltDWPStart() < beltDWPStepE()*.
1166 Аргументы
1168 buf критические данные
1169 count число октетов данных
1170 state состояние
1171 void beltDWPStepG (octet mac[8], void * state)
1173 Определяется окончательная имитовставка mac всех данных, обработанных
1174 до этого функциями beltDWPStepI() и beltDWPStepA().
1175 Ожидается
1177 beltDWPStepI()* < beltDWPStepG().
1178 Ожидается
1180 beltDWPStepA()* < beltDWPStepG().
1181 Предупреждения
1183 При выполнении функции состояние state изменяется так, что
1184 продолжение имитозащиты становится некорректным.
1185 Аргументы
1187 mac имитовставка
1188 state состояние
1189 void beltDWPStepI (const void * buf, size_t count, void * state)
1191 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1192 нового фрагмента открытых данных [count]buf. Пересчет выполняется на
1193 ключе, также размещенном в state.
1194 Ожидается
1196 beltDWPStart() < beltDWPStepI()*.
1197 Аргументы
1199 buf открытые данные
1200 count число октетов данных
1201 state состояние
1202 bool_t beltDWPStepV (const octet mac[8], void * state)
1204 Проверяется, что окончательная имитовставка всех данных, обработанных
1205 до этого функциями beltDWPStepI() и beltDWPStepA(), совпадает с mac.
1206 Ожидается
1208 beltDWPStepI()* < beltDWPStepV().
1209 Ожидается
1211 beltDWPStepA()* < beltDWPStepV().
1212 Возвращает
1214 Признак успеха.
1215 Предупреждения
1217 При выполнении функции состояние state изменяется так, что
1218 продолжение имитозащиты становится некорректным.
1219 Аргументы
1221 mac контрольная имитовставка
1222 state состояние
1223 err_t beltDWPUnwrap (void * dest, const void * src1, size_t count1, const
1225 void * src2, size_t count2, const octet mac[8], const octet key[],
1226 size_t len, const octet iv[16])
1227 На ключе [len]key октетов с использованием имитовставки iv снимается
1228 защита зашифрованных критических данных [count1]src1 и открытых данных
1229 [count2]src2. При снятии защиты проверяется целостность пары (src1,
1230 src2) с помощью имитовставки mac. Если целостность не нарушена, то
1231 данные src1 расшифровываются в буфер [count1]dest.
1232 Ожидается [ERR_BAD_INPUT]
1234 len == 16 || len == 24 || len == 32.
1235 Возвращает
1237 ERR_OK, если защита успешно снята, и код ошибки в противном случае.
1238 Прим.
1240 Буферы могут пересекаться.
1241 Аргументы
1243 dest расшифрованные критические данные
1244 src1 зашифрованные критические данные
1245 count1 число октетов критических данных
1246 src2 открытые данные
1247 count2 число октетов открытых данных
1248 mac имитовставка
1249 key ключ
1250 len длина ключа
1251 iv синхропосылка
1252 err_t beltDWPWrap (void * dest, octet mac[8], const void * src1, size_t
1254 count1, const void * src2, size_t count2, const octet key[], size_t
1255 len, const octet iv[16])
1256 На ключе [len]key с использованием имитовставки iv устанавливается
1257 защита критических данных [count1]src1 и открытых данных [count2]src2.
1258 При установке защиты критические данные зашифровываются и сохраняются в
1259 буфере [count1]dest. Кроме этого определяется имитовставка mac пары
1260 (src1, src2).
1261 Ожидается [ERR_BAD_INPUT]
1263 • len == 16 || len == 24 || len == 32;
1266 • буферы dest и mac не пересекаются.
1268 Возвращает
1270 ERR_OK, если защита успешно установлена, и код ошибки в противном
1271 случае.
1272 Прим.
1274 Буферы могут пересекаться, за исключением пересечения dest и mac.
1275 Аргументы
1277 dest зашифрованные критические данные
1278 mac имитовставка
1279 src1 критические данные
1280 count1 число октетов критических данных
1281 src2 открытые данные
1282 count2 число октетов открытых данных
1283 key ключ
1284 len длина ключа
1285 iv синхропосылка
1286 size_t beltECB_keep ()
1288 Возвращается длина состояния (в октетах) функций шифрования в режиме
1289 ECB.
1290 Возвращает
1292 Длина состояния.
1293 err_t beltECBDecr (void * dest, const void * src, size_t count, const octet
1295 key[], size_t len)
1296 Буфер src из count октетов расшифровывается на ключе [len]key.
1297 Результат расшифрования размещается в буфере dest.
1298 Ожидается [ERR_BAD_INPUT]
1300 • len == 16 || len == 24 || len == 32;
1303 • count >= 16.
1305 Возвращает
1307 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
1308 случае.
1309 Аргументы
1311 dest открытый текст
1312 src шифртекст
1313 count число октетов текста
1314 key ключ
1315 len длина ключа
1316 err_t beltECBEncr (void * dest, const void * src, size_t count, const octet
1318 key[], size_t len)
1319 Буфер [count]src зашифровывается на ключе [len]key октетов. Результат
1320 зашифрования размещается в буфере [count]dest.
1321 Ожидается [ERR_BAD_INPUT]
1323 • len == 16 || len == 24 || len == 32;
1326 • count >= 16.
1328 Возвращает
1330 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
1331 случае.
1332 Аргументы
1334 dest шифртекст
1335 src открытый текст
1336 count число октетов текста
1337 key ключ
1338 len длина ключа
1339 void beltECBStart (void * state, const octet key[], size_t len)
1341 По ключу [len]key в state формируются структуры данных, необходимые для
1342 шифрования в режиме ECB.
1343 Предусловие
1345 len == 16 || len == 24 || len == 32.
1346 По адресу state зарезервировано beltECB_keep() октетов.
1348 Прим.
1350 Буферы key и state могут пересекаться.
1351 Аргументы
1353 state состояние
1354 key ключ
1355 len длина ключа в октетах
1356 void beltECBStepD (void * buf, size_t count, void * state)
1358 Буфер [count]buf расшифровывается в режиме ECB на ключе, размещенном в
1359 state.
1360 Предусловие
1362 count >= 16.
1363 Ожидается
1365 beltECBStart() < beltECBStepD()*.
1366 Прим.
1368 Сохраняются замечания по функции beltECBStepE().
1369 Аргументы
1371 buf шифртекст / открытый текст
1372 count число октетов текста
1373 state состояние
1374 void beltECBStepE (void * buf, size_t count, void * state)
1376 Буфер [count]buf зашифровывается в режиме ECB на ключе, размещенном в
1377 state.
1378 Предусловие
1380 count >= 16.
1381 Ожидается
1383 beltECBStart() < beltECBStepE()*.
1384 Прим.
1386 К функции можно обратиться несколько раз, передавая buf из полных
1387 блоков. Неполный блок можно передать только при последнем
1388 обращении. В этом случае выполняется 'кража' блока (ciphertext
1389 stealing, CTS).
1390 При организации последовательных обращений к функции следует
1392 учитывать, что буфер buf должен содержать не менее одного блока.
1393 Например для зашифрования 33 октетов можно зашифровать сначала 16
1394 октетов, а затем еще 17. Но нельзя зашифровать сначала 32 октета, а
1395 затем еще 1.
1396 Аргументы
1398 buf открытый текст / шифртекст
1399 count число октетов текста
1400 state состояние
1401 size_t beltFMT_keep (u32 mod, size_t count)
1403 Возвращается длина состояния (в октетах) функций шифрования при
1404 обработке слов длины count в алфавите {0, 1,..., mod - 1}.
1405 Предусловие
1407 2 <= mod && mod <= 65536.
1408 2 <= count && count <= 600.
1410 Возвращает
1412 Длина состояния.
1413 Аргументы
1415 mod размер алфавита
1416 count длина слов
1417 err_t beltFMTDecr (u16 dest[], u32 mod, const u16 src[], size_t count,
1419 const octet key[], size_t len, const octet iv[16])
1420 Строка [count]src в алфавите {0, 1,..., mod - 1} расшифровывается на
1421 ключе [len]key и синхропосылке iv. Результат расшифрования размещается
1422 в буфере [count]dest. При нулевом указателе iv используется нулевая
1423 синхропосылка.
1424 Ожидается [ERR_BAD_INPUT]
1426 • 2 <= mod && mod <= 65536;
1429 • 2 <= count;
1431 • len == 16 || len == 24 || len == 32;
1433 • если iv ненулевой, то буферы iv и [count]dest не пересекаются.
1435 Ожидается [ERR_NOT_IMPLEMENTED]
1437 count <= 600.
1438 Ожидается
1440 Символы src принадлежат алфавиту {0, 1,..., mod - 1}.
1441 Возвращает
1443 ERR_OK, если расшифрование успешно выполнено, и код ошибки в
1444 противном случае.
1445 Прим.
1447 Все буферы, кроме iv и [count]dest, могут пересекаться.
1448 Аргументы
1450 dest открытый текст
1451 mod размер алфавита
1452 src шифртекст
1453 count длина шифртекста / открытого текста
1454 key ключ
1455 len длина key в октетах
1456 iv синхропосылка
1457 err_t beltFMTEncr (u16 dest[], u32 mod, const u16 src[], size_t count,
1459 const octet key[], size_t len, const octet iv[16])
1460 Строка [count]src в алфавите {0, 1,..., mod - 1} зашифровывается на
1461 ключе [len]key и синхропосылке iv. Результат зашифрования размещается в
1462 буфере [count]dest. При нулевом указателе iv используется нулевая
1463 синхропосылка.
1464 Ожидается [ERR_BAD_INPUT]
1466 • 2 <= mod && mod <= 65536;
1469 • 2 <= count;
1471 • len == 16 || len == 24 || len == 32;
1473 • если iv ненулевой, то буферы iv и [count]dest не пересекаются.
1475 Ожидается [ERR_NOT_IMPLEMENTED]
1477 count <= 600.
1478 Ожидается
1480 Символы src принадлежат алфавиту {0, 1,..., mod - 1}.
1481 Возвращает
1483 ERR_OK, если зашифрование успешно выполнено, и код ошибки в
1484 противном случае.
1485 Прим.
1487 Все буферы, кроме iv и [count]dest, могут пересекаться.
1488 Аргументы
1490 dest шифртекст
1491 mod размер алфавита
1492 src открытый текст
1493 count длина открытого текста / шифртекста
1494 key ключ
1495 len длина key в октетах
1496 iv синхропосылка
1497 void beltFMTStart (void * state, u32 mod, size_t count, const octet key[],
1499 size_t len)
1500 По размеру алфавита mod, длине слов count и ключу [len]key в state
1501 формируются структуры данных, необходимые для шифрования в режиме FMT.
1502 Предусловие
1504 2 <= mod && mod <= 65536.
1505 2 <= count && count <= 600.
1507 len == 16 || len == 24 || len == 32.
1509 По адресу state зарезервировано beltFMT_keep() октетов.
1511 Прим.
1513 Буферы key и state могут пересекаться.
1514 Аргументы
1516 state состояние
1517 mod размер алфавита
1518 count длина слов
1519 key ключ
1520 len длина key в октетах
1521 void beltFMTStepD (u16 buf[], const octet iv[16], void * state)
1523 Строка [count]buf расшифровывается на ключе, размещенном в state, и
1524 синхропосылке iv. Здесь count -- длина строки, предварительно
1525 установленная в state функцией beltFMTStart(). Результат расшифрования
1526 сохраняется в buf.
1527 Ожидается
1529 beltFMTStart() < beltFMTStepD()*.
1530 Ожидается
1532 Символы строки принадлежат алфавиту {0,1,..., mod - 1}, размер mod
1533 которого предварительно установлен в state функцией beltFMTStart().
1534 Прим.
1536 При нулевом указателе iv используется нулевая синхропосылка.
1537 Аргументы
1539 buf шифртекст / открытый текст
1540 iv синхропосылка
1541 state состояние
1542 void beltFMTStepE (u16 buf[], const octet iv[16], void * state)
1544 Строка [count]buf зашифровывается на ключе, размещенном в state, и
1545 синхропосылке iv. Здесь count -- длина строки, предварительно
1546 установленная в state функцией beltFMTStart(). Результат зашифрования
1547 сохраняется в buf.
1548 Ожидается
1550 beltFMTStart() < beltFMTStepE()*.
1551 Ожидается
1553 Символы строки принадлежат алфавиту {0,1,..., mod - 1}, размер mod
1554 которого предварительно установлен в state функцией beltFMTStart().
1555 Прим.
1557 При нулевом указателе iv используется нулевая синхропосылка.
1558 Аргументы
1560 buf открытый текст / шифртекст
1561 iv синхропосылка
1562 state состояние
1563 const octet * beltH ()
1565 Возвращается таблица значений блока подстановки H.
1566 Возвращает
1568 Указатель на таблицу H.
1569 Прим.
1571 Таблица используется для формирования начальных значений переменных
1572 некоторых алгоритмов, а также в тестовых примерах.
1573 err_t beltHash (octet hash[32], const void * src, size_t count)
1575 Определяется хэш-значение hash буфера [count]src.
1576 Возвращает
1578 ERR_OK, если хэширование успешно завершено, и код ошибки в
1579 противном случае.
1580 Прим.
1582 Буферы могут пересекаться.
1583 Аргументы
1585 hash хэш-значение
1586 src данные
1587 count число октетов данных
1588 size_t beltHash_keep ()
1590 Возвращается длина состояния (в октетах) функции хэширования.
1591 Возвращает
1593 Длина состояния.
1594 void beltHashStart (void * state)
1596 В state формируются структуры данных, необходимые для хэширования.
1597 Предусловие
1599 По адресу state зарезервировано beltHash_keep() октетов.
1600 Аргументы
1602 state состояние
1603 void beltHashStepG (octet hash[32], void * state)
1605 Определяется окончательное хэш-значение hash всех данных, обработанных
1606 до этого функцией beltHashStepH().
1607 Ожидается
1609 (beltHashStepH()* < beltHashStepG())*.
1610 Прим.
1612 Если продолжение хэширования не предполагается, то буферы hash и
1613 state могут пересекаться.
1614 Аргументы
1616 hash хэш-значение
1617 state состояние
1618 void beltHashStepG2 (octet hash[], size_t hash_len, void * state)
1620 Определяется окончательное хэш-значение [hash_len]hash всех данных,
1621 обработанных до этого функцией beltHashStepH(). Возвращаемое
1622 хэш-значение состоит из первых hash_len октетов полного хэш-значения.
1623 Предусловие
1625 hash_len <= 32.
1626 Ожидается
1628 (beltHashStepH()* < beltHashStepG2())*.
1629 Прим.
1631 Если продолжение хэширования не предполагается, то буферы hash и
1632 state могут пересекаться.
1633 Аргументы
1635 hash хэш-значение
1636 hash_len длина hash
1637 state состояние
1638 void beltHashStepH (const void * buf, size_t count, void * state)
1640 Текущее хэш-значение, размещенное в state, пересчитывается с учетом
1641 нового фрагмента данных [count]buf.
1642 Ожидается
1644 beltHashStart() < beltHashStepH()*.
1645 Аргументы
1647 buf данные
1648 count число октетов данных
1649 state состояние
1650 bool_t beltHashStepV (const octet hash[32], void * state)
1652 Проверяется, что окончательное хэш-значение всех данных, обработанных
1653 до этого функцией beltHashStepH(), совпадает с hash.
1654 Ожидается
1656 (beltHashStepH()* < beltHashStepV())*.
1657 Аргументы
1659 hash контрольные хэш-значение
1660 state состояние
1661 bool_t beltHashStepV2 (const octet hash[], size_t hash_len, void * state)
1663 Проверяется, что первые hash_len октетов окончательного хэш-значения
1664 всех данных, обработанных до этого функцией beltHashStepH(), совпадают
1665 с [hash_len]hash.
1666 Предусловие
1668 hash_len <= 32.
1669 Ожидается
1671 (beltHashStepH()* < beltHashStepV2())*.
1672 Аргументы
1674 hash контрольное хэш-значение
1675 hash_len длина hash
1676 state состояние
1677 err_t beltHMAC (octet mac[32], const void * src, size_t count, const octet
1679 key[], size_t len)
1680 На ключе [len]key определяется имитовставка mac буфера [count]src.
1681 Возвращает
1683 ERR_OK, если имитовставка успешно вычислена, и код ошибки в
1684 противном случае.
1685 Прим.
1687 Буферы могут пересекаться.
1688 Аргументы
1690 mac имитовставка
1691 src данные
1692 count число октетов данных
1693 key ключ
1694 len длина ключа
1695 size_t beltHMAC_keep ()
1697 Возвращается длина состояния (в октетах) функций имитозащиты в режиме
1698 MAC.
1699 Возвращает
1701 Длина состояния.
1702 void beltHMACStart (void * state, const octet key[], size_t len)
1704 По ключу [len]key в state формируются структуры данных, необходимые для
1705 имитозащиты в режиме HMAC.
1706 Предусловие
1708 По адресу state зарезервировано beltHMAC_keep() октетов.
1709 Прим.
1711 Рекомендуется использовать ключ из 32 октетов.
1712 Аргументы
1714 state состояние
1715 key ключ
1716 len длина ключа в октетах
1717 void beltHMACStepA (const void * buf, size_t count, void * state)
1719 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1720 нового фрагмента данных [count]buf. Пересчет выполняется на ключе,
1721 также размещенном в state.
1722 Ожидается
1724 beltHMACStart() < beltHMACStepA()*.
1725 Аргументы
1727 buf данные
1728 count число октетов данных
1729 state состояние
1730 void beltHMACStepG (octet mac[32], void * state)
1732 Определяется окончательная имитовставка mac всех данных, обработанных
1733 до этого функцией beltHMACStepA().
1734 Ожидается
1736 (beltHMACStepA()* < beltHMACStepG())*.
1737 Аргументы
1739 mac имитовставка
1740 state состояние
1741 void beltHMACStepG2 (octet mac[], size_t mac_len, void * state)
1743 Определяется окончательная имитовставка [mac_len]mac всех данных,
1744 обработанных до этого функцией beltHMACStepA(). Возвращаемая
1745 имитовставка состоит из первых mac_len октетов полной имитовставки.
1746 Предусловие
1748 mac_len <= 32.
1749 Ожидается
1751 (beltHMACStepA()* < beltHMACStepG2())*.
1752 Прим.
1754 Если продолжение имитозащиты не предполагается, то буферы mac и
1755 state могут пересекаться.
1756 Аргументы
1758 mac имитовставка
1759 mac_len длина имитовставки
1760 state состояние
1761 bool_t beltHMACStepV (const octet mac[32], void * state)
1763 Проверяется, что окончательная имитовставка всех данных, обработанных
1764 до этого функцией beltHMACStepA(), совпадает с mac.
1765 Ожидается
1767 (beltHMACStepA()* < beltHMACStepV())*.
1768 Аргументы
1770 mac контрольная имитовставка
1771 state состояние
1772 bool_t beltHMACStepV2 (const octet mac[], size_t mac_len, void * state)
1774 Проверяется, что первые mac_len октетов окончательной имитовставки всех
1775 данных, обработанных до этого функцией beltHMACStepA(), совпадают с
1776 [mac_len]mac.
1777 Предусловие
1779 mac_len <= 32.
1780 Ожидается
1782 (beltHMACStepA()* < beltHMACStepV2())*.
1783 Аргументы
1785 mac контрольная имитовставка
1786 mac_len длина mac
1787 state состояние
1788 void beltKeyExpand (octet key_[32], const octet key[], size_t len)
1790 Ключ [len]key расширяется до ключа key_.
1791 Предусловие
1793 len == 16 || len == 24 || len == 32.
1794 Прим.
1796 Буферы key и key_ могут пересекаться.
1797 Аргументы
1799 key_ расширенный ключ
1800 key первоначальный ключ
1801 len длина key в октетах
1802 void beltKeyExpand2 (u32 key_[8], const octet key[], size_t len)
1804 Ключ [len]key форматируется и расширяется до ключа key_.
1805 Предусловие
1807 len == 16 || len == 24 || len == 32.
1808 Прим.
1810 Буферы key и key_ могут пересекаться.
1811 Аргументы
1813 key_ расширенный форматированный ключ
1814 key первоначальный ключ
1815 len длина ключа в октетах
1816 err_t beltKRP (octet dest[], size_t m, const octet src[], size_t n, const
1818 octet level[12], const octet header[16])
1819 По ключу [n]src, который имеет уровень level, строится ключ [m]dest,
1820 который имеет заголовок header.
1821 Ожидается [ERR_BAD_INPUT]
1823 • n == 16 || n == 24 || n == 32;
1826 • m == 16 || m == 24 || m == 32;
1828 • m <= n.
1830 Возвращает
1832 ERR_OK, если преобразование успешно завершено, и код ошибки в
1833 противном случае.
1834 Прим.
1836 Буферы могут пересекаться.
1837 Аргументы
1839 dest преобразованный ключ
1840 m длина dest в октетах
1841 src исходный ключ
1842 n длина src в октетах
1843 level уровень ключа src
1844 header заголовок ключа dest
1845 size_t beltKRP_keep ()
1847 Возвращается длина состояния (в октетах) функций преобразования ключа.
1848 Возвращает
1850 Длина состояния.
1851 void beltKRPStart (void * state, const octet key[], size_t len, const octet
1853 level[12])
1854 По ключу [len]key, который принадлежит уровню level, в state
1855 формируются структуры данных, необходимые для преобразования этого
1856 ключа.
1857 Предусловие
1859 len == 16 || len == 24 || len == 32.
1860 По адресу state зарезервировано beltKRP_keep() октетов.
1862 Прим.
1864 Буферы key и state могут пересекаться.
1865 Аргументы
1867 state состояние
1868 key ключ
1869 len длина ключа в октетах
1870 level уровень
1871 void beltKRPStepG (octet key_[], size_t key_len, const octet header[16],
1873 void * state)
1874 Ключ [len]key, размещенный в state функцией beltKRPStart(),
1875 преобразуется в ключ [key_len]key_, который имеет заголовок header.
1876 Предусловие
1878 (key_len == 16 || key_len == 24 || key_len == 32) && key_len <=
1879 len.
1880 Ожидается
1882 beltKRPStart() < beltKRPStepG()*.
1883 Аргументы
1885 key_ преобразованный ключ
1886 key_len длина key в октетах
1887 header заголовок key_
1888 state состояние
1889 err_t beltKWPUnwrap (octet dest[], const octet src[], size_t count, const
1891 octet header[16], const octet key[], size_t len)
1892 На ключе [len]key снимается защита с ключа [count]src. В результате
1893 определяется первоначальный ключ [count - 16]dest с заголовком header.
1894 Ожидается [ERR_BAD_INPUT]
1896 • len == 16 || len == 24 || len == 32;
1899 • count >= 32.
1901 Возвращает
1903 ERR_OK, если защита успешно снята, и код ошибки в противном случае.
1904 Прим.
1906 При нулевом указателе header используется нулевой заголовок.
1907 Буферы могут пересекаться.
1909 Аргументы
1911 dest ключ
1912 src защищенный ключ
1913 count длина src в октетах
1914 header заголовок ключа
1915 key ключ защиты
1916 len длина key в октетах
1917 err_t beltKWPWrap (octet dest[], const octet src[], size_t count, const
1919 octet header[16], const octet key[], size_t len)
1920 На ключе [len]key устанавливается защита ключа [count]src с заголовком
1921 header. В результате определяется защищенный ключ [count + 16]dest.
1922 Ожидается [ERR_BAD_INPUT]
1924 • len == 16 || len == 24 || len == 32;
1927 • count >= 16.
1929 Возвращает
1931 ERR_OK, если защита успешно установлена, и код ошибки в противном
1932 случае.
1933 Прим.
1935 При нулевом указателе header используется нулевой заголовок.
1936 Буферы могут пересекаться.
1938 Аргументы
1940 dest защищенный ключ
1941 src защищаемый ключ
1942 count длина src в октетах
1943 header заголовок ключа
1944 key ключ защиты
1945 len длина key в октетах
1946 err_t beltMAC (octet mac[8], const void * src, size_t count, const octet
1948 key[], size_t len)
1949 На ключе [len]key определяется имитовставка mac буфера [count]src.
1950 Ожидается [ERR_BAD_INPUT]
1952 len == 16 || len == 24 || len == 32.
1953 Возвращает
1955 ERR_OK, если имитовставка успешно вычислена, и код ошибки в
1956 противном случае.
1957 Прим.
1959 Буферы могут пересекаться.
1960 Аргументы
1962 mac имитовставка
1963 src данные
1964 count число октетов данных
1965 key ключ
1966 len длина ключа
1967 size_t beltMAC_keep ()
1969 Возвращается длина состояния (в октетах) функций имитозащиты в режиме
1970 MAC.
1971 Возвращает
1973 Длина состояния.
1974 void beltMACStart (void * state, const octet key[], size_t len)
1976 По ключу [len]key в state формируются структуры данных, необходимые для
1977 имитозащиты в режиме MAC.
1978 Предусловие
1980 len == 16 || len == 24 || len == 32.
1981 По адресу state зарезервировано beltMAC_keep() октетов.
1983 Прим.
1985 Буферы key и state могут пересекаться.
1986 Аргументы
1988 state состояние
1989 key ключ
1990 len длина ключа в октетах
1991 void beltMACStepA (const void * buf, size_t count, void * state)
1993 Текущая имитовставка, размещенная в state, пересчитывается с учетом
1994 нового фрагмента данных [count]buf. Пересчет выполняется на ключе,
1995 также размещенном в state.
1996 Ожидается
1998 beltMACStart() < beltMACStepA()*.
1999 Аргументы
2001 buf данные
2002 count число октетов данных
2003 state состояние
2004 void beltMACStepG (octet mac[8], void * state)
2006 Определяется окончательная имитовставка mac всех данных, обработанных
2007 до этого функцией beltMACStepA().
2008 Ожидается
2010 (beltMACStepA()* < beltMACStepG())*.
2011 Прим.
2013 Если продолжение имитозащиты не предполагается, то буферы mac и
2014 state могут пересекаться.
2015 Аргументы
2017 mac имитовставка
2018 state состояние
2019 void beltMACStepG2 (octet mac[], size_t mac_len, void * state)
2021 Определяется окончательная имитовставка [mac_len]mac всех данных,
2022 обработанных до этого функцией beltMACStepA(). Возвращаемая
2023 имитовставка состоит из первых mac_len октетов полной имитовставки.
2024 Предусловие
2026 mac_len <= 8.
2027 Ожидается
2029 (beltMACStepA()* < beltMACStepG2())*.
2030 Прим.
2032 Если продолжение имитозащиты не предполагается, то буферы mac и
2033 state могут пересекаться.
2034 Аргументы
2036 mac имитовставка
2037 mac_len длина имитовставки
2038 state состояние
2039 bool_t beltMACStepV (const octet mac[8], void * state)
2041 Проверяется, что окончательная имитовставка всех данных, обработанных
2042 до этого функцией beltMACStepA(), совпадает с mac.
2043 Ожидается
2045 (beltMACStepA()* < beltMACStepV())*.
2046 Возвращает
2048 Признак успеха.
2049 Аргументы
2051 mac контрольная имитовставка
2052 state состояние
2053 bool_t beltMACStepV2 (const octet mac[], size_t mac_len, void * state)
2055 Проверяется, что первые mac_len октетов окончательной имитовставки всех
2056 данных, обработанных до этого функцией beltMACStepA(), совпадают с
2057 [mac_len]mac.
2058 Предусловие
2060 mac_len <= 8.
2061 Ожидается
2063 (beltMACStepA()* < beltMACStepV2())*.
2064 Аргументы
2066 mac контрольная имитовставка
2067 mac_len длина mac
2068 state состояние
2069 err_t beltPBKDF2 (octet key[32], const octet pwd[], size_t pwd_len, size_t
2071 iter, const octet salt[], size_t salt_len)
2072 По паролю [pwd_len]pwd строится ключ key. Для усложнения словарных атак
2073 используется синхропосылка [salt_len]salt. Для усложнения перебора
2074 паролей ключ пересчитывается iter > 0 раз.
2075 Ожидается [ERR_BAD_INPUT]
2077 iter != 0.
2078 Возвращает
2080 ERR_OK, если ключ успешно построен, и код ошибки в противном
2081 случае.
2082 Прим.
2084 Рекомендуется использовать iter >= 10000 и salt_len >= 8.
2085 Реализована упрощенная редакция алгоритма PBKDF2 (Password-Based
2087 Key Derivation Function version 2), определенного в PKCS#5.
2088 Редакция описана в СТБ 34.101.45 (приложение E).
2089 Аргументы
2091 key ключ
2092 pwd пароль
2093 pwd_len длина пароля (в октетах)
2094 iter число итераций
2095 salt синхропосылка ('соль')
2096 salt_len длина синхропосылки (в октетах)
2097 size_t beltSDE_keep ()
2099 Возвращается длина состояния (в октетах) функций шифрования в режиме
2100 SDE.
2101 Возвращает
2103 Длина состояние.
2104 err_t beltSDEDecr (void * dest, const void * src, size_t count, const octet
2106 key[], size_t len, const octet iv[16])
2107 Сектор [count]src расшифровывается на ключе [len]key с использованием
2108 синхропосылки iv. Результат расшифрования размещается в буфере
2109 [count]dest.
2110 Ожидается [ERR_BAD_INPUT]
2112 • len == 16 || len == 24 || len == 32;
2115 • count % 16 == 0 && count >= 32.
2117 Возвращает
2119 ERR_OK, если данные успешно расшифрованы, и код ошибки в противном
2120 случае.
2121 Прим.
2123 Буферы могут пересекаться.
2124 Аргументы
2126 dest открытый текст
2127 src шифртекст
2128 count число октетов текста
2129 key ключ
2130 len длина ключа
2131 iv синхропосылка
2132 err_t beltSDEEncr (void * dest, const void * src, size_t count, const octet
2134 key[], size_t len, const octet iv[16])
2135 Сектор [count]src зашифровывается на ключе [len]key с использованием
2136 синхропосылки iv. Результат зашифрования размещается в буфере
2137 [count]dest.
2138 Ожидается [ERR_BAD_INPUT]
2140 • len == 16 || len == 24 || len == 32;
2143 • count % 16 == 0 && count >= 32.
2145 Возвращает
2147 ERR_OK, если данные успешно зашифрованы, и код ошибки в противном
2148 случае.
2149 Прим.
2151 Буферы могут пересекаться.
2152 Аргументы
2154 dest шифртекст
2155 src открытый текст
2156 count число октетов текста
2157 key ключ
2158 len длина ключа
2159 iv синхропосылка
2160 void beltSDEStart (void * state, const octet key[], size_t len)
2162 По ключу [len]key и синхропосылке iv в state формируются структуры
2163 данных, необходимые для шифрования в режиме SDE.
2164 Предусловие
2166 len == 16 || len == 24 || len == 32.
2167 По адресу state зарезервировано beltSDE_keep() октетов.
2169 Прим.
2171 Буферы key и state могут пересекаться.
2172 Аргументы
2174 state состояние
2175 key ключ
2176 len длина ключа в октетах
2177 void beltSDEStepD (void * buf, size_t count, const octet iv[16], void *
2179 state)
2180 Сектор [count]buf расшифровывается в режиме SDE на ключе, размещенном в
2181 state, и синхропосылке iv.
2182 Предусловие
2184 count % 16 == 0 && count >= 32.
2185 Ожидается
2187 beltSDEStart() < beltSDEStepD()*.
2188 Аргументы
2190 buf шифртекст / открытый текст
2191 count число октетов текста
2192 iv синхропосылка
2193 state состояние
2194 void beltSDEStepE (void * buf, size_t count, const octet iv[16], void *
2196 state)
2197 Сектор [count]buf зашифровывается в режиме SDE на ключе, размещенном в
2198 state, и синхропосылке iv.
2199 Предусловие
2201 count % 16 == 0 && count >= 32.
2202 Ожидается
2204 beltSDEStart() < beltSDEStepE()*.
2205 Аргументы
2207 buf открытый текст / шифртекст
2208 count число октетов текста
2209 iv синхропосылка
2210 state состояние
2211 size_t beltWBL_keep ()
2213 Возвращается длина состояния (в октетах) функций WBL.
2214 Возвращает
2216 Длина состояния.
2217 void beltWBLStart (void * state, const octet key[], size_t len)
2219 По ключу [len]key в state формируются структуры данных, необходимые для
2220 шифрования в режиме WBL.
2221 Предусловие
2223 len == 16 || len == 24 || len == 32.
2224 По адресу state зарезервировано beltWBL_keep() октетов.
2226 Прим.
2228 Буферы key и state могут пересекаться.
2229 Аргументы
2231 state состояние
2232 key ключ
2233 len длина ключа в октетах
2234 void beltWBLStepD (void * buf, size_t count, void * state)
2236 Буфер [count]buf расшифровывается на ключе, размещенном в state.
2237 Результат расшифрования сохраняется в buf.
2238 Предусловие
2240 count >= 32.
2241 Ожидается
2243 beltWBLStart() < beltWBLStepD()*.
2244 Аргументы
2246 buf шифртекст / открытый текст
2247 count число октетов данных
2248 state состояние
2249 void beltWBLStepD2 (void * buf1, void * buf2, size_t count, void * state)
2251 Буфер [count - 16]buf1 || [16]buf2 расшифровывается в режиме WBL на
2252 ключе, размещенном в state. Результат расшифрования сохраняется в buf1
2253 || buf2.
2254 Предусловие
2256 count >= 32.
2257 Буферы buf1 и buf2 не пересекаются.
2259 Ожидается
2261 beltWBLStart() < beltWBLStepD2()*.
2262 Прим.
2264 С помощью beltWBLStepD2() снятие защиты с ключа в механизме KWP
2265 может быть организовано по следующей схеме:
2266 • первая часть защищенного ключа помещается в buf1;
2268 • вторая часть защищенного ключа помещается в buf2;
2270 • применяется beltWBLStepD2();
2272 • если buf2 совпадает с заголовком ключа, то buf1 принимается как
2274 ключ.
2275 Аргументы
2277 buf1 первая часть шифртекста / открытого текста
2278 buf2 вторая часть шифртекста / открытого текста
2279 count длина текста
2280 state состояние
2281 void beltWBLStepE (void * buf, size_t count, void * state)
2283 Буфер [count]buf зашифровывается на ключе, размещенном в state.
2284 Результат зашифрования сохраняется в buf.
2285 Предусловие
2287 count >= 32.
2288 Ожидается
2290 beltWBLStart() < beltWBLStepE()*.
2291 Аргументы
2293 buf открытый текст / шифртекст
2294 count число октетов текста
2295 state состояние
2296 void beltWBLStepR (void * buf, size_t count, void * state)
2298 Буфер [count]buf зашифровывается на ключе, размещенном в state.
2299 Результат зашифрования сохраняется в buf. При первом обращении счетчик
2300 i меняется от 1 до 2n, при втором --- от 2n + 1 до 4n, и так далее.
2301 Предусловие
2303 count >= 32.
2304 Ожидается
2306 beltWBLStart() < beltWBLStepR()*.
2307 Прим.
2309 Многократное зашифрование в режиме WBL используется для генерации
2310 одноразового ключа в СТБ 34.101.45. Поэтому функции назначен
2311 суффикс R.
2312 Аргументы
2314 buf открытый текст / шифртекст
2315 count число октетов текста
2316 state состояние
2317
2319 Автоматически создано Doxygen для Библиотека Bee2 из исходного текста.
2320Библиотека Bee2 Пт 23 Июн 2023 belt.h(3)