GostCrypto  0.2.0
Криптография, реализованная в соответствии с ГОСТ
 Указатель Структуры данных Файлы Функции Определения типов Перечисления Элементы перечислений Друзья Макросы
gostcrypto.hpp
См. документацию.
1 
5 #ifndef GOSTCRYPTO_HPP
6 #define GOSTCRYPTO_HPP
7 
8 #include "gostcrypto.h"
9 #include <type_traits>
10 #include <array>
11 #include <vector>
12 
13 #if __cplusplus < 201402L
14 template <std::size_t Len, std::size_t Align>
15 using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
16 #else
17 template <std::size_t Len, std::size_t Align>
18 using aligned_storage_t = std::aligned_storage_t<Len, Align>;
19 #endif
20 
28 {
29 public:
30  KuznyechikMgm_t(const KuznyechikMgm_t &) = default;
31  KuznyechikMgm_t &operator=(const KuznyechikMgm_t &) = default;
32  KuznyechikMgm_t(KuznyechikMgm_t &&) = default;
34 
42  explicit KuznyechikMgm_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
43  : data_{}
44  {
45  kuznyechik_mgm_new(*ptr(), key.data());
46  }
47 
66  intptr_t encrypt(const uint8_t nonce[KUZNYECHIK_MGM_NONCE_SIZE],
67  const uint8_t *aad,
68  uintptr_t aad_len,
69  uint8_t *buf,
70  uintptr_t buf_len,
71  uint8_t tag[KUZNYECHIK_MGM_TAG_SIZE]) const noexcept
72  {
73  return kuznyechik_mgm_encrypt(*ptr(), nonce, aad, aad_len, buf, buf_len, tag);
74  }
88  intptr_t encrypt(const std::array<uint8_t, KUZNYECHIK_MGM_NONCE_SIZE> &nonce,
89  const std::vector<uint8_t> &aad,
90  std::vector<uint8_t> &buf,
91  std::array<uint8_t, KUZNYECHIK_MGM_TAG_SIZE> &tag) const noexcept
92  {
93  return kuznyechik_mgm_encrypt(*ptr(), nonce.data(), aad.data(), aad.size(), buf.data(), buf.size(), tag.data());
94  }
95 
114  intptr_t decrypt(const uint8_t nonce[KUZNYECHIK_MGM_NONCE_SIZE],
115  const uint8_t *aad,
116  uintptr_t aad_len,
117  uint8_t *buf,
118  uintptr_t buf_len,
119  const uint8_t tag[KUZNYECHIK_MGM_TAG_SIZE]) const noexcept
120  {
121  return kuznyechik_mgm_decrypt(*ptr(), nonce, aad, aad_len, buf, buf_len, tag);
122  }
123 
138  intptr_t decrypt(const std::array<uint8_t, KUZNYECHIK_MGM_NONCE_SIZE> &nonce,
139  const std::vector<uint8_t> &aad,
140  std::vector<uint8_t> &buf,
141  const std::array<uint8_t, KUZNYECHIK_MGM_TAG_SIZE> &tag) const noexcept
142  {
143  return kuznyechik_mgm_decrypt(*ptr(), nonce.data(), aad.data(), aad.size(), buf.data(), buf.size(), tag.data());
144  }
145 
147  {
148  kuznyechik_mgm_drop(*ptr());
149  }
150 
151 private:
152  KuznyechikMgm *ptr() noexcept
153  {
154  return reinterpret_cast<KuznyechikMgm *>(&data_);
155  }
156 
157  KuznyechikMgm *ptr() const noexcept
158  {
159  return const_cast<KuznyechikMgm *>(reinterpret_cast<const KuznyechikMgm *>(&data_));
160  }
161 
163 };
164 
172 {
173 public:
174  KuznyechikCbc_t(const KuznyechikCbc_t &) = default;
175  KuznyechikCbc_t &operator=(const KuznyechikCbc_t &) = default;
176  KuznyechikCbc_t(KuznyechikCbc_t &&) = default;
178 
190  explicit KuznyechikCbc_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CBC_NONCE_SIZE]) noexcept
191  : data_{}
192  {
193  kuznyechik_cbc_new(*ptr(), reinterpret_cast<const uint8_t *>(key), reinterpret_cast<const uint8_t *>(nonce));
194  }
195 
205  explicit KuznyechikCbc_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, KUZNYECHIK_CBC_NONCE_SIZE> &nonce) noexcept
206  : data_{}
207  {
208  kuznyechik_cbc_new(*ptr(), key.data(), nonce.data());
209  }
210 
211  ~KuznyechikCbc_t() noexcept
212  {
213  kuznyechik_cbc_drop(*ptr());
214  }
215 
227  void encrypt_blocks(uint8_t (*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len) noexcept
228  {
229  kuznyechik_cbc_encrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), blocks_len);
230  }
231 
243  void decrypt_blocks(uint8_t (*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len) noexcept
244  {
245  kuznyechik_cbc_decrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), blocks_len);
246  }
247 
266  intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
267  {
268  auto copy = *this;
269  return kuznyechik_cbc_encrypt_pad(*copy.ptr(), buf, buf_len, pos);
270  }
271 
287  intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
288  {
289  auto copy = *this;
290  return kuznyechik_cbc_decrypt_pad(*copy.ptr(), buf, buf_len);
291  }
292 
293 private:
294  KuznyechikCbc *ptr() noexcept
295  {
296  return reinterpret_cast<KuznyechikCbc *>(&data_);
297  }
298 
299  KuznyechikCbc *ptr() const noexcept
300  {
301  return const_cast<KuznyechikCbc *>(reinterpret_cast<const KuznyechikCbc *>(&data_));
302  }
303 
305 };
306 
314 {
315 public:
316  MagmaCbc_t(const MagmaCbc_t &) = default;
317  MagmaCbc_t &operator=(const MagmaCbc_t &) = default;
318  MagmaCbc_t(MagmaCbc_t &&) = default;
319  MagmaCbc_t &operator=(MagmaCbc_t &&) = default;
320 
332  explicit MagmaCbc_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CBC_NONCE_SIZE]) noexcept
333  : data_{}
334  {
335  magma_cbc_new(*ptr(), reinterpret_cast<const uint8_t *>(key), reinterpret_cast<const uint8_t *>(nonce));
336  }
337 
347  explicit MagmaCbc_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, MAGMA_CBC_NONCE_SIZE> &nonce) noexcept
348  : data_{}
349  {
350  magma_cbc_new(*ptr(), key.data(), nonce.data());
351  }
352 
353  ~MagmaCbc_t() noexcept
354  {
355  magma_cbc_drop(*ptr());
356  }
357 
369  void encrypt_blocks(uint8_t (*blocks)[MAGMA_BLOCK_SIZE], uintptr_t blocks_len) noexcept
370  {
371  magma_cbc_encrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), blocks_len);
372  }
373 
385  void decrypt_blocks(uint8_t (*blocks)[MAGMA_BLOCK_SIZE], uintptr_t blocks_len) noexcept
386  {
387  magma_cbc_decrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), blocks_len);
388  }
389 
408  intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
409  {
410  auto copy = *this;
411  return magma_cbc_encrypt_pad(*copy.ptr(), buf, buf_len, pos);
412  }
413 
429  intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
430  {
431  auto copy = *this;
432  return magma_cbc_decrypt_pad(*copy.ptr(), buf, buf_len);
433  }
434 
435 private:
436  MagmaCbc *ptr() noexcept
437  {
438  return reinterpret_cast<MagmaCbc *>(&data_);
439  }
440 
441  MagmaCbc *ptr() const noexcept
442  {
443  return const_cast<MagmaCbc *>(reinterpret_cast<const MagmaCbc *>(&data_));
444  }
445 
447 };
448 
456 {
457 public:
458  KuznyechikCfb_t(const KuznyechikCfb_t &) = default;
459  KuznyechikCfb_t &operator=(const KuznyechikCfb_t &) = default;
460  KuznyechikCfb_t(KuznyechikCfb_t &&) = default;
462 
474  explicit KuznyechikCfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CFB_NONCE_SIZE]) noexcept
475  : data_{}
476  {
477  kuznyechik_cfb_new(*ptr(), reinterpret_cast<const uint8_t *>(key), reinterpret_cast<const uint8_t *>(nonce));
478  }
479 
489  KuznyechikCfb_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, KUZNYECHIK_CFB_NONCE_SIZE> &nonce) noexcept
490  : data_{}
491  {
492  kuznyechik_cfb_new(*ptr(), key.data(), nonce.data());
493  }
494 
495  ~KuznyechikCfb_t() noexcept
496  {
497  kuznyechik_cfb_drop(*ptr());
498  }
499 
510  void encrypt(uint8_t *buf, uintptr_t buf_len) noexcept
511  {
512  kuznyechik_cfb_encrypt(*ptr(), buf, buf_len);
513  }
514 
522  void encrypt(std::vector<uint8_t> &buf) noexcept
523  {
524  encrypt(buf.data(), buf.size());
525  }
526 
537  void decrypt(uint8_t *buf, uintptr_t buf_len) noexcept
538  {
539  kuznyechik_cfb_decrypt(*ptr(), buf, buf_len);
540  }
541 
549  void decrypt(std::vector<uint8_t> &buf) noexcept
550  {
551  decrypt(buf.data(), buf.size());
552  }
553 
554 private:
555  KuznyechikCfb *ptr() noexcept
556  {
557  return reinterpret_cast<KuznyechikCfb *>(&data_);
558  }
559 
561 };
562 
570 {
571 public:
572  MagmaCfb_t(const MagmaCfb_t &) = default;
573  MagmaCfb_t &operator=(const MagmaCfb_t &) = default;
574  MagmaCfb_t(MagmaCfb_t &&) = default;
575  MagmaCfb_t &operator=(MagmaCfb_t &&) = default;
576 
588  explicit MagmaCfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CFB_NONCE_SIZE]) noexcept
589  : data_{}
590  {
591  magma_cfb_new(*ptr(), reinterpret_cast<const uint8_t *>(key), reinterpret_cast<const uint8_t *>(nonce));
592  }
593 
603  MagmaCfb_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, MAGMA_CFB_NONCE_SIZE> &nonce) noexcept
604  : data_{}
605  {
606  magma_cfb_new(*ptr(), key.data(), nonce.data());
607  }
608 
609  ~MagmaCfb_t() noexcept
610  {
611  magma_cfb_drop(*ptr());
612  }
613 
624  void encrypt(uint8_t *buf, uintptr_t buf_len) noexcept
625  {
626  magma_cfb_encrypt(*ptr(), buf, buf_len);
627  }
628 
636  void encrypt(std::vector<uint8_t> &buf) noexcept
637  {
638  encrypt(buf.data(), buf.size());
639  }
640 
651  void decrypt(uint8_t *buf, uintptr_t buf_len) noexcept
652  {
653  magma_cfb_decrypt(*ptr(), buf, buf_len);
654  }
655 
663  void decrypt(std::vector<uint8_t> &buf) noexcept
664  {
665  decrypt(buf.data(), buf.size());
666  }
667 
668 private:
669  MagmaCfb *ptr() noexcept
670  {
671  return reinterpret_cast<MagmaCfb *>(&data_);
672  }
673 
675 };
676 
683 {
684 public:
685  Kuznyechik_t(const Kuznyechik_t &) = default;
686  Kuznyechik_t &operator=(const Kuznyechik_t &) = default;
687  Kuznyechik_t(Kuznyechik_t &&) = default;
688  Kuznyechik_t &operator=(Kuznyechik_t &&) = default;
689 
699  explicit Kuznyechik_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
700  : data_{}
701  {
702  kuznyechik_new(*ptr(), reinterpret_cast<const uint8_t *>(key));
703  }
704 
712  explicit Kuznyechik_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
713  : data_{}
714  {
715  kuznyechik_new(*ptr(), key.data());
716  }
717 
718  ~Kuznyechik_t() noexcept
719  {
720  kuznyechik_drop(*ptr());
721  }
722 
732  void encrypt_block(uint8_t block[KUZNYECHIK_BLOCK_SIZE]) noexcept
733  {
734  kuznyechik_encrypt_block(*ptr(), block);
735  }
736 
746  void decrypt_block(uint8_t block[KUZNYECHIK_BLOCK_SIZE]) noexcept
747  {
748  kuznyechik_decrypt_block(*ptr(), block);
749  }
750 
761  void encrypt_blocks(uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
762  {
763  kuznyechik_encrypt_blocks(*ptr(), blocks, len);
764  }
765 
776  void decrypt_blocks(uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
777  {
778  kuznyechik_decrypt_blocks(*ptr(), blocks, len);
779  }
780 
781 private:
782  Kuznyechik *ptr() noexcept
783  {
784  return reinterpret_cast<Kuznyechik *>(&data_);
785  }
786 
788 };
789 
795 class Magma_t
796 {
797 public:
798  Magma_t(const Magma_t &) = default;
799  Magma_t &operator=(const Magma_t &) = default;
800  Magma_t(Magma_t &&) = default;
801  Magma_t &operator=(Magma_t &&) = default;
802 
812  explicit Magma_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
813  : data_{}
814  {
815  magma_new(*ptr(), reinterpret_cast<const uint8_t *>(key));
816  }
817 
825  explicit Magma_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
826  : data_{}
827  {
828  magma_new(*ptr(), key.data());
829  }
830 
831  ~Magma_t() noexcept
832  {
833  magma_drop(*ptr());
834  }
835 
845  void encrypt_block(uint8_t block[MAGMA_BLOCK_SIZE]) noexcept
846  {
847  magma_encrypt_block(*ptr(), block);
848  }
849 
859  void decrypt_block(uint8_t block[MAGMA_BLOCK_SIZE]) noexcept
860  {
861  magma_decrypt_block(*ptr(), block);
862  }
863 
874  void encrypt_blocks(uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
875  {
876  magma_encrypt_blocks(*ptr(), blocks, len);
877  }
878 
889  void decrypt_blocks(uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
890  {
891  magma_decrypt_blocks(*ptr(), blocks, len);
892  }
893 
894 private:
895  Magma *ptr() noexcept
896  {
897  return reinterpret_cast<Magma *>(&data_);
898  }
899 
901 };
902 
909 {
910 public:
911  KuznyechikCtr_t(const KuznyechikCtr_t &) = default;
912  KuznyechikCtr_t &operator=(const KuznyechikCtr_t &) = default;
913  KuznyechikCtr_t(KuznyechikCtr_t &&) = default;
915 
927  explicit KuznyechikCtr_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CTR_NONCE_SIZE]) noexcept
928  : data_{}
929  {
930  kuznyechik_ctr_new(*ptr(), reinterpret_cast<const uint8_t *>(key), reinterpret_cast<const uint8_t *>(nonce));
931  }
932 
942  KuznyechikCtr_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, KUZNYECHIK_CTR_NONCE_SIZE> &nonce) noexcept
943  : data_{}
944  {
945  kuznyechik_ctr_new(*ptr(), key.data(), nonce.data());
946  }
947 
948  ~KuznyechikCtr_t() noexcept
949  {
950  kuznyechik_ctr_drop(*ptr());
951  }
952 
966  intptr_t apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
967  {
968  return kuznyechik_ctr_apply_keystream(*ptr(), buf, buf_len);
969  }
970 
981  intptr_t apply_keystream(std::vector<uint8_t> &buf) noexcept
982  {
983  return apply_keystream(buf.data(), buf.size());
984  }
985 
996  intptr_t seek(uint64_t pos) noexcept
997  {
998  return kuznyechik_ctr_seek(*ptr(), pos);
999  }
1000 
1008  uint64_t get_pos() const noexcept
1009  {
1010  return kuznyechik_ctr_get_pos(*ptr());
1011  }
1012 
1013 private:
1014  KuznyechikCtr *ptr() noexcept
1015  {
1016  return reinterpret_cast<KuznyechikCtr *>(&data_);
1017  }
1018 
1019  KuznyechikCtr *ptr() const noexcept
1020  {
1021  return const_cast<KuznyechikCtr *>(reinterpret_cast<const KuznyechikCtr *>(&data_));
1022  }
1023 
1025 };
1026 
1033 {
1034 public:
1035  MagmaCtr_t(const MagmaCtr_t &) = default;
1036  MagmaCtr_t &operator=(const MagmaCtr_t &) = default;
1037  MagmaCtr_t(MagmaCtr_t &&) = default;
1038  MagmaCtr_t &operator=(MagmaCtr_t &&) = default;
1039 
1051  explicit MagmaCtr_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CTR_NONCE_SIZE]) noexcept
1052  : data_{}
1053  {
1054  magma_ctr_new(*ptr(), reinterpret_cast<const uint8_t *>(key), reinterpret_cast<const uint8_t *>(nonce));
1055  }
1056 
1066  MagmaCtr_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, MAGMA_CTR_NONCE_SIZE> &nonce) noexcept
1067  : data_{}
1068  {
1069  magma_ctr_new(*ptr(), key.data(), nonce.data());
1070  }
1071 
1072  ~MagmaCtr_t() noexcept
1073  {
1074  magma_ctr_drop(*ptr());
1075  }
1076 
1090  intptr_t apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
1091  {
1092  return magma_ctr_apply_keystream(*ptr(), buf, buf_len);
1093  }
1094 
1105  intptr_t apply_keystream(std::vector<uint8_t> &buf) noexcept
1106  {
1107  return apply_keystream(buf.data(), buf.size());
1108  }
1109 
1120  intptr_t seek(uint64_t pos) noexcept
1121  {
1122  return magma_ctr_seek(*ptr(), pos);
1123  }
1124 
1132  uint64_t get_pos() const noexcept
1133  {
1134  return magma_ctr_get_pos(*ptr());
1135  }
1136 
1137 private:
1138  MagmaCtr *ptr() noexcept
1139  {
1140  return reinterpret_cast<MagmaCtr *>(&data_);
1141  }
1142 
1143  MagmaCtr *ptr() const noexcept
1144  {
1145  return const_cast<MagmaCtr *>(reinterpret_cast<const MagmaCtr *>(&data_));
1146  }
1147 
1149 };
1150 
1157 {
1158 public:
1159  KuznyechikEcb_t(const KuznyechikEcb_t &) = default;
1160  KuznyechikEcb_t &operator=(const KuznyechikEcb_t &) = default;
1161  KuznyechikEcb_t(KuznyechikEcb_t &&) = default;
1162  KuznyechikEcb_t &operator=(KuznyechikEcb_t &&) = default;
1163 
1174  explicit KuznyechikEcb_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
1175  : data_{}
1176  {
1177  kuznyechik_ecb_new(*ptr(), reinterpret_cast<const uint8_t *>(key));
1178  }
1179 
1188  explicit KuznyechikEcb_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
1189  : data_{}
1190  {
1191  kuznyechik_ecb_new(*ptr(), key.data());
1192  }
1193 
1194  ~KuznyechikEcb_t() noexcept
1195  {
1196  kuznyechik_ecb_drop(*ptr());
1197  }
1198 
1210  void encrypt_blocks(uint8_t (*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
1211  {
1212  kuznyechik_ecb_encrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), len);
1213  }
1214 
1226  void decrypt_blocks(uint8_t (*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
1227  {
1228  kuznyechik_ecb_decrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), len);
1229  }
1230 
1249  intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
1250  {
1251  auto copy = *this;
1252  return kuznyechik_ecb_encrypt_pad(*copy.ptr(), buf, buf_len, pos);
1253  }
1254 
1270  intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
1271  {
1272  auto copy = *this;
1273  return kuznyechik_ecb_decrypt_pad(*copy.ptr(), buf, buf_len);
1274  }
1275 
1276 private:
1277  KuznyechikEcb *ptr() noexcept
1278  {
1279  return reinterpret_cast<KuznyechikEcb *>(&data_);
1280  }
1281 
1282  KuznyechikEcb *ptr() const noexcept
1283  {
1284  return const_cast<KuznyechikEcb *>(reinterpret_cast<const KuznyechikEcb *>(&data_));
1285  }
1286 
1288 };
1289 
1296 {
1297 public:
1298  MagmaEcb_t(const MagmaEcb_t &) = default;
1299  MagmaEcb_t &operator=(const MagmaEcb_t &) = default;
1300  MagmaEcb_t(MagmaEcb_t &&) = default;
1301  MagmaEcb_t &operator=(MagmaEcb_t &&) = default;
1302 
1313  explicit MagmaEcb_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
1314  : data_{}
1315  {
1316  magma_ecb_new(*ptr(), reinterpret_cast<const uint8_t *>(key));
1317  }
1318 
1327  explicit MagmaEcb_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
1328  : data_{}
1329  {
1330  magma_ecb_new(*ptr(), key.data());
1331  }
1332 
1333  ~MagmaEcb_t() noexcept
1334  {
1335  magma_ecb_drop(*ptr());
1336  }
1337 
1349  void encrypt_blocks(uint8_t (*blocks)[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
1350  {
1351  magma_ecb_encrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), len);
1352  }
1353 
1365  void decrypt_blocks(uint8_t (*blocks)[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
1366  {
1367  magma_ecb_decrypt_blocks(*ptr(), reinterpret_cast<uint8_t *>(blocks), len);
1368  }
1369 
1388  intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
1389  {
1390  auto copy = *this;
1391  return magma_ecb_encrypt_pad(*copy.ptr(), buf, buf_len, pos);
1392  }
1393 
1409  intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
1410  {
1411  auto copy = *this;
1412  return magma_ecb_decrypt_pad(*copy.ptr(), buf, buf_len);
1413  }
1414 
1415 private:
1416  MagmaEcb *ptr() noexcept
1417  {
1418  return reinterpret_cast<MagmaEcb *>(&data_);
1419  }
1420 
1421  MagmaEcb *ptr() const noexcept
1422  {
1423  return const_cast<MagmaEcb *>(reinterpret_cast<const MagmaEcb *>(&data_));
1424  }
1425 
1427 };
1428 
1433 {
1434 public:
1435  Streebog256_t(const Streebog256_t &) = default;
1436  Streebog256_t &operator=(const Streebog256_t &) = default;
1437  Streebog256_t(Streebog256_t &&) = default;
1438  Streebog256_t &operator=(Streebog256_t &&) = default;
1439 
1445  Streebog256_t() noexcept
1446  : data_{}
1447  {
1448  streebog256_new(*ptr());
1449  }
1450 
1451  ~Streebog256_t() noexcept
1452  {
1453  streebog256_drop(*ptr());
1454  }
1455 
1467  static void digest(const uint8_t *msg, uintptr_t len, uint8_t res[STREEBOG256_RESULT_SIZE]) noexcept
1468  {
1469  streebog256_digest(msg, len, reinterpret_cast<uint8_t *>(res));
1470  }
1471 
1484  static std::array<uint8_t, STREEBOG256_RESULT_SIZE> digest(const uint8_t *msg, uintptr_t len) noexcept
1485  {
1486  std::array<uint8_t, STREEBOG256_RESULT_SIZE> result {};
1487  digest(msg, len, result.data());
1488  return result;
1489  }
1490 
1501  void update(const uint8_t *msg, uintptr_t len) noexcept
1502  {
1503  streebog256_update(*ptr(), msg, len);
1504  }
1505 
1513  void update(const std::vector<uint8_t> &message) noexcept
1514  {
1515  streebog256_update(*ptr(), message.data(), message.size());
1516  }
1517 
1527  void finalize(uint8_t res[STREEBOG256_RESULT_SIZE]) const noexcept
1528  {
1529  auto copy = *this;
1530  streebog256_finalize(*copy.ptr(), reinterpret_cast<uint8_t *>(res));
1531  }
1532 
1540  std::array<uint8_t, STREEBOG256_RESULT_SIZE> finalize() const noexcept
1541  {
1542  std::array<uint8_t, STREEBOG256_RESULT_SIZE> result {};
1543  auto copy = *this;
1544  streebog256_finalize(*copy.ptr(), result.data());
1545  return result;
1546  }
1547 
1558  void finalize_reset(uint8_t res[STREEBOG256_RESULT_SIZE]) noexcept
1559  {
1560  streebog256_finalize_reset(*ptr(), reinterpret_cast<uint8_t *>(res));
1561  }
1562 
1571  std::array<uint8_t, STREEBOG256_RESULT_SIZE> finalize_reset() noexcept
1572  {
1573  std::array<uint8_t, STREEBOG256_RESULT_SIZE> result {};
1574  streebog256_finalize_reset(*ptr(), result.data());
1575  return result;
1576  }
1577 
1583  void reset() noexcept
1584  {
1585  streebog256_reset(*ptr());
1586  }
1587 
1588 private:
1589  Streebog256 *ptr() const noexcept
1590  {
1591  return const_cast<Streebog256 *>(reinterpret_cast<const Streebog256 *>(&data_));
1592  }
1593 
1594  Streebog256 *ptr() noexcept
1595  {
1596  return reinterpret_cast<Streebog256 *>(&data_);
1597  }
1598 
1600 };
1601 
1606 {
1607 public:
1608  Streebog512_t(const Streebog512_t &) = default;
1609  Streebog512_t &operator=(const Streebog512_t &) = default;
1610  Streebog512_t(Streebog512_t &&) = default;
1611  Streebog512_t &operator=(Streebog512_t &&) = default;
1612 
1618  Streebog512_t() noexcept
1619  : data_{}
1620  {
1621  streebog512_new(*ptr());
1622  }
1623 
1624  ~Streebog512_t() noexcept
1625  {
1626  streebog512_drop(*ptr());
1627  }
1628 
1640  static void digest(const uint8_t *msg, uintptr_t len, uint8_t res[STREEBOG512_RESULT_SIZE]) noexcept
1641  {
1642  streebog512_digest(msg, len, reinterpret_cast<uint8_t *>(res));
1643  }
1644 
1657  static std::array<uint8_t, STREEBOG512_RESULT_SIZE> digest(const uint8_t *msg, uintptr_t len) noexcept
1658  {
1659  std::array<uint8_t, STREEBOG512_RESULT_SIZE> result {};
1660  digest(msg, len, result.data());
1661  return result;
1662  }
1663 
1674  void update(const uint8_t *msg, uintptr_t len) noexcept
1675  {
1676  streebog512_update(*ptr(), msg, len);
1677  }
1678 
1686  void update(const std::vector<uint8_t> &message) noexcept
1687  {
1688  streebog512_update(*ptr(), message.data(), message.size());
1689  }
1690 
1700  void finalize(uint8_t res[STREEBOG512_RESULT_SIZE]) const noexcept
1701  {
1702  auto copy = *this;
1703  streebog512_finalize(*copy.ptr(), reinterpret_cast<uint8_t *>(res));
1704  }
1705 
1713  std::array<uint8_t, STREEBOG512_RESULT_SIZE> finalize() const noexcept
1714  {
1715  std::array<uint8_t, STREEBOG512_RESULT_SIZE> result {};
1716  auto copy = *this;
1717  streebog512_finalize(*copy.ptr(), result.data());
1718  return result;
1719  }
1720 
1731  void finalize_reset(uint8_t res[STREEBOG512_RESULT_SIZE]) noexcept
1732  {
1733  streebog512_finalize_reset(*ptr(), reinterpret_cast<uint8_t *>(res));
1734  }
1735 
1744  std::array<uint8_t, STREEBOG512_RESULT_SIZE> finalize_reset() noexcept
1745  {
1746  std::array<uint8_t, STREEBOG512_RESULT_SIZE> result {};
1747  streebog512_finalize_reset(*ptr(), result.data());
1748  return result;
1749  }
1750 
1756  void reset() noexcept
1757  {
1758  streebog512_reset(*ptr());
1759  }
1760 
1761 private:
1762  Streebog512 *ptr() const noexcept
1763  {
1764  return const_cast<Streebog512 *>(reinterpret_cast<const Streebog512 *>(&data_));
1765  }
1766 
1767  Streebog512 *ptr() noexcept
1768  {
1769  return reinterpret_cast<Streebog512 *>(&data_);
1770  }
1771 
1773 };
1774 
1781 {
1782 public:
1783  KuznyechikMac_t(const KuznyechikMac_t &) = default;
1784  KuznyechikMac_t &operator=(const KuznyechikMac_t &) = default;
1785  KuznyechikMac_t(KuznyechikMac_t &&) = default;
1786  KuznyechikMac_t &operator=(KuznyechikMac_t &&) = default;
1787 
1795  explicit KuznyechikMac_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
1796  : data_{}
1797  {
1798  kuznyechik_mac_new(*ptr(), key);
1799  }
1800 
1808  explicit KuznyechikMac_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
1809  : data_{}
1810  {
1811  kuznyechik_mac_new(*ptr(), key.data());
1812  }
1813 
1814  ~KuznyechikMac_t() noexcept
1815  {
1816  kuznyechik_mac_drop(*ptr());
1817  }
1818 
1829  void update(const uint8_t *msg, uintptr_t len) noexcept
1830  {
1831  kuznyechik_mac_update(*ptr(), msg, len);
1832  }
1833 
1841  void update(const std::vector<uint8_t> &message) noexcept
1842  {
1843  kuznyechik_mac_update(*ptr(), message.data(), message.size());
1844  }
1845 
1856  void finalize(uint8_t res[KUZNYECHIK_MAC_RESULT_SIZE]) const noexcept
1857  {
1858  auto copy = *this;
1859  kuznyechik_mac_finalize(*copy.ptr(), reinterpret_cast<uint8_t *>(res));
1860  }
1861 
1869  std::array<uint8_t, KUZNYECHIK_MAC_RESULT_SIZE> finalize() const noexcept
1870  {
1871  std::array<uint8_t, KUZNYECHIK_MAC_RESULT_SIZE> result {};
1872  auto copy = *this;
1873  kuznyechik_mac_finalize(*copy.ptr(), result.data());
1874  return result;
1875  }
1876 
1887  void finalize_reset(uint8_t res[KUZNYECHIK_MAC_RESULT_SIZE]) noexcept
1888  {
1889  kuznyechik_mac_finalize_reset(*ptr(), reinterpret_cast<uint8_t *>(res));
1890  }
1891 
1900  std::array<uint8_t, KUZNYECHIK_MAC_RESULT_SIZE> finalize_reset() noexcept
1901  {
1902  std::array<uint8_t, KUZNYECHIK_MAC_RESULT_SIZE> result {};
1903  kuznyechik_mac_finalize_reset(*ptr(), result.data());
1904  return result;
1905  }
1906 
1918  bool verify(const uint8_t code[KUZNYECHIK_MAC_RESULT_SIZE]) const noexcept
1919  {
1920  return kuznyechik_mac_verify(*ptr(), reinterpret_cast<const uint8_t *>(code));
1921  }
1922 
1932  bool verify(const std::array<uint8_t, KUZNYECHIK_MAC_RESULT_SIZE> &code) const noexcept
1933  {
1934  return kuznyechik_mac_verify(*ptr(), code.data());
1935  }
1936 
1942  void reset() noexcept
1943  {
1944  kuznyechik_mac_reset(*ptr());
1945  }
1946 
1947 private:
1948  KuznyechikMac *ptr() const noexcept
1949  {
1950  return const_cast<KuznyechikMac *>(reinterpret_cast<const KuznyechikMac *>(&data_));
1951  }
1952 
1953  KuznyechikMac *ptr() noexcept
1954  {
1955  return reinterpret_cast<KuznyechikMac *>(&data_);
1956  }
1957 
1959 };
1960 
1967 {
1968 public:
1969  MagmaMac_t(const MagmaMac_t &) = default;
1970  MagmaMac_t &operator=(const MagmaMac_t &) = default;
1971  MagmaMac_t(MagmaMac_t &&) = default;
1972  MagmaMac_t &operator=(MagmaMac_t &&) = default;
1973 
1981  explicit MagmaMac_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
1982  : data_{}
1983  {
1984  magma_mac_new(*ptr(), key);
1985  }
1986 
1994  explicit MagmaMac_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key) noexcept
1995  : data_{}
1996  {
1997  magma_mac_new(*ptr(), key.data());
1998  }
1999 
2000  ~MagmaMac_t() noexcept
2001  {
2002  magma_mac_drop(*ptr());
2003  }
2004 
2015  void update(const uint8_t *msg, uintptr_t len) noexcept
2016  {
2017  magma_mac_update(*ptr(), msg, len);
2018  }
2019 
2027  void update(const std::vector<uint8_t> &message) noexcept
2028  {
2029  magma_mac_update(*ptr(), message.data(), message.size());
2030  }
2031 
2042  void finalize(uint8_t res[MAGMA_MAC_RESULT_SIZE]) const noexcept
2043  {
2044  auto copy = *this;
2045  magma_mac_finalize(*copy.ptr(), reinterpret_cast<uint8_t *>(res));
2046  }
2047 
2055  std::array<uint8_t, MAGMA_MAC_RESULT_SIZE> finalize() const noexcept
2056  {
2057  std::array<uint8_t, MAGMA_MAC_RESULT_SIZE> result {};
2058  auto copy = *this;
2059  magma_mac_finalize(*copy.ptr(), result.data());
2060  return result;
2061  }
2062 
2073  void finalize_reset(uint8_t res[MAGMA_MAC_RESULT_SIZE]) noexcept
2074  {
2075  magma_mac_finalize_reset(*ptr(), reinterpret_cast<uint8_t *>(res));
2076  }
2077 
2086  std::array<uint8_t, MAGMA_MAC_RESULT_SIZE> finalize_reset() noexcept
2087  {
2088  std::array<uint8_t, MAGMA_MAC_RESULT_SIZE> result {};
2089  magma_mac_finalize_reset(*ptr(), result.data());
2090  return result;
2091  }
2092 
2104  bool verify(const uint8_t code[MAGMA_MAC_RESULT_SIZE]) const noexcept
2105  {
2106  return magma_mac_verify(*ptr(), reinterpret_cast<const uint8_t *>(code));
2107  }
2108 
2118  bool verify(const std::array<uint8_t, MAGMA_MAC_RESULT_SIZE> &code) const noexcept
2119  {
2120  return magma_mac_verify(*ptr(), code.data());
2121  }
2122 
2128  void reset() noexcept
2129  {
2130  magma_mac_reset(*ptr());
2131  }
2132 
2133 private:
2134  MagmaMac *ptr() const noexcept
2135  {
2136  return const_cast<MagmaMac *>(reinterpret_cast<const MagmaMac *>(&data_));
2137  }
2138 
2139  MagmaMac *ptr() noexcept
2140  {
2141  return reinterpret_cast<MagmaMac *>(&data_);
2142  }
2143 
2145 };
2146 
2154 {
2155 public:
2156  KuznyechikOfb_t(const KuznyechikOfb_t &) = default;
2157  KuznyechikOfb_t &operator=(const KuznyechikOfb_t &) = default;
2158  KuznyechikOfb_t(KuznyechikOfb_t &&) = default;
2159  KuznyechikOfb_t &operator=(KuznyechikOfb_t &&) = default;
2160 
2172  KuznyechikOfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_OFB_NONCE_SIZE]) noexcept
2173  : data_{}
2174  {
2175  kuznyechik_ofb_new(*ptr(), key, nonce);
2176  }
2177 
2187  KuznyechikOfb_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, KUZNYECHIK_OFB_NONCE_SIZE> &nonce) noexcept
2188  : data_{}
2189  {
2190  kuznyechik_ofb_new(*ptr(), key.data(), nonce.data());
2191  }
2192 
2193  ~KuznyechikOfb_t() noexcept
2194  {
2195  kuznyechik_ofb_drop(*ptr());
2196  }
2197 
2209  void apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
2210  {
2211  kuznyechik_ofb_apply_keystream(*ptr(), buf, buf_len);
2212  }
2213 
2222  void apply_keystream(std::vector<uint8_t> &buf) noexcept
2223  {
2224  apply_keystream(buf.data(), buf.size());
2225  }
2226 
2227 private:
2228  KuznyechikOfb *ptr() noexcept
2229  {
2230  return reinterpret_cast<KuznyechikOfb *>(&data_);
2231  }
2232 
2234 };
2235 
2243 {
2244 public:
2245  MagmaOfb_t(const MagmaOfb_t &) = default;
2246  MagmaOfb_t &operator=(const MagmaOfb_t &) = default;
2247  MagmaOfb_t(MagmaOfb_t &&) = default;
2248  MagmaOfb_t &operator=(MagmaOfb_t &&) = default;
2249 
2261  MagmaOfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_OFB_NONCE_SIZE]) noexcept
2262  : data_{}
2263  {
2264  magma_ofb_new(*ptr(), key, nonce);
2265  }
2266 
2276  MagmaOfb_t(const std::array<uint8_t, SYMMETRIC_KEY_SIZE> &key, const std::array<uint8_t, MAGMA_OFB_NONCE_SIZE> &nonce) noexcept
2277  : data_{}
2278  {
2279  magma_ofb_new(*ptr(), key.data(), nonce.data());
2280  }
2281 
2282  ~MagmaOfb_t() noexcept
2283  {
2284  magma_ofb_drop(*ptr());
2285  }
2286 
2298  void apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
2299  {
2300  magma_ofb_apply_keystream(*ptr(), buf, buf_len);
2301  }
2302 
2311  void apply_keystream(std::vector<uint8_t> &buf) noexcept
2312  {
2313  apply_keystream(buf.data(), buf.size());
2314  }
2315 
2316 private:
2317  MagmaOfb *ptr() noexcept
2318  {
2319  return reinterpret_cast<MagmaOfb *>(&data_);
2320  }
2321 
2323 };
2324 
2329 enum class Gost3410_2012_512 : uintptr_t
2330 {
2335 
2340 
2345 };
2346 
2347 template <Gost3410_2012_512 CurveID>
2349 
2356 template <Gost3410_2012_512 CurveID>
2358 {
2359  friend class Ec512PrivateKey_t<CurveID>;
2360  const static Ec512 cid = static_cast<Ec512>(CurveID);
2361  Ec512PublicKey_t<CurveID>() = default;
2362 
2363 public:
2364 
2369  ~Ec512PublicKey_t<CurveID>() = default;
2370 
2381  static Ec512PublicKey_t<CurveID> from_bytes(const uint8_t bytes[EC_512_DOUBLE_WIDTH], intptr_t &error_code) noexcept
2382  {
2384  error_code = ec512_public_key_from_bytes(cid, bytes, *result.ptr());
2385  return result;
2386  }
2387 
2400  static Ec512PublicKey_t<CurveID> from_bytes(const std::array<uint8_t, EC_512_DOUBLE_WIDTH> &bytes, intptr_t &error_code) noexcept
2401  {
2402  return from_bytes(bytes.data(), error_code);
2403  }
2404 
2412  std::array<uint8_t, EC_512_DOUBLE_WIDTH> to_bytes() const noexcept
2413  {
2414  std::array<uint8_t, EC_512_DOUBLE_WIDTH> bytes {};
2415  ec512_public_key_to_bytes(cid, *ptr(), bytes.data());
2416  return bytes;
2417  }
2418 
2432  intptr_t verify_hash(const uint8_t hash[STREEBOG512_RESULT_SIZE],
2433  const uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
2434  {
2435  return ec512_dsa_verify_hash(cid, *ptr(), hash, signature);
2436  }
2437 
2449  intptr_t verify_hash(const std::array<uint8_t, STREEBOG512_RESULT_SIZE> &hash,
2450  const std::array<uint8_t, EC_512_DOUBLE_WIDTH> &signature) const noexcept
2451  {
2452  return verify_hash(hash.data(), signature.data());
2453  }
2454 
2468  intptr_t verify(
2469  const uint8_t *msg,
2470  uintptr_t msg_len,
2471  const uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
2472  {
2473  return ec512_dsa_verify(cid, *ptr(), msg, msg_len, signature);
2474  }
2475 
2486  intptr_t verify(const std::vector<uint8_t> &msg, const std::array<uint8_t, EC_512_DOUBLE_WIDTH> &signature) const noexcept
2487  {
2488  return verify(msg.data(), msg.size(), signature.data());
2489  }
2490 
2491 private:
2492  Ec512PublicKey *ptr() const noexcept
2493  {
2494  return const_cast<Ec512PublicKey *>(reinterpret_cast<const Ec512PublicKey *>(&data_));
2495  }
2496 
2498 };
2499 
2506 template <Gost3410_2012_512 CurveID>
2507 class Ec512PrivateKey_t
2508 {
2509  const static Ec512 cid = static_cast<Ec512>(CurveID);
2510  Ec512PrivateKey_t<CurveID>() = default;
2511 
2512 public:
2513 
2518 
2519  ~Ec512PrivateKey_t<CurveID>()
2520  {
2521  ec512_private_key_drop(*ptr());
2522  }
2523 
2534  Ec512PrivateKey_t<CurveID>(const uint8_t rand_bytes[EC_512_WIDTH], intptr_t &error_code) noexcept
2535  : data_{}
2536  {
2537  error_code = ec512_gen_private_key(cid, *ptr(), rand_bytes);
2538  }
2539 
2548  explicit Ec512PrivateKey_t<CurveID>(const std::array<uint8_t, EC_512_WIDTH> &rand_bytes, intptr_t &error_code) noexcept
2549  : data_{}
2550  {
2551  error_code = ec512_gen_private_key(cid, *ptr(), rand_bytes.data());
2552  }
2553 
2562  {
2563  Ec512PublicKey_t<CurveID> public_key;
2564  ec512_get_public_key(cid, *ptr(), *public_key.ptr());
2565  return public_key;
2566  }
2567 
2580  static Ec512PrivateKey_t<CurveID> from_bytes(const uint8_t bytes[EC_512_WIDTH], intptr_t &error_code) noexcept
2581  {
2583  error_code = ec512_private_key_from_bytes(cid, bytes, *result.ptr());
2584  return result;
2585  }
2586 
2597  static Ec512PrivateKey_t<CurveID> from_bytes(const std::array<uint8_t, EC_512_WIDTH> &rand_bytes, intptr_t &error_code) noexcept
2598  {
2599  return from_bytes(rand_bytes.data(), error_code);
2600  }
2601 
2609  std::array<uint8_t, EC_512_WIDTH> to_bytes() const noexcept
2610  {
2611  std::array<uint8_t, EC_512_WIDTH> bytes {};
2612  ec512_private_key_to_bytes(cid, *ptr(), bytes.data());
2613  return bytes;
2614  }
2615 
2630  intptr_t sign_hash(const uint8_t hash[STREEBOG512_RESULT_SIZE],
2631  const uint8_t rand_bytes[EC_512_WIDTH],
2632  uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
2633  {
2634  return ec512_dsa_sign_hash(cid, *ptr(), hash, rand_bytes, signature);
2635  }
2636 
2649  std::array<uint8_t, EC_512_DOUBLE_WIDTH> sign_hash(
2650  const std::array<uint8_t, STREEBOG512_RESULT_SIZE> &hash,
2651  const std::array<uint8_t, EC_512_WIDTH> &rand_bytes,
2652  intptr_t &error_code) const noexcept
2653  {
2654  std::array<uint8_t, EC_512_DOUBLE_WIDTH> signature {};
2655  error_code = sign_hash(hash.data(), rand_bytes.data(), signature.data());
2656  return signature;
2657  }
2658 
2673  intptr_t sign(
2674  const uint8_t *msg,
2675  uintptr_t msg_len,
2676  const uint8_t rand_bytes[EC_512_WIDTH],
2677  uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
2678  {
2679  return ec512_dsa_sign(cid, *ptr(), msg, msg_len, rand_bytes, signature);
2680  }
2681 
2693  intptr_t sign(const std::vector<uint8_t> &msg, const std::array<uint8_t, EC_512_WIDTH> &rand_bytes, std::array<uint8_t, EC_512_DOUBLE_WIDTH> &signature) const noexcept
2694  {
2695  return sign(msg.data(), msg.size(), rand_bytes.data(), signature.data());
2696  }
2697 
2709  std::array<uint8_t, EC_512_DOUBLE_WIDTH> sign(const std::vector<uint8_t> &msg, const std::array<uint8_t, EC_512_WIDTH> &rand_bytes, intptr_t &error_code) const noexcept
2710  {
2711  std::array<uint8_t, EC_512_DOUBLE_WIDTH> signature {};
2712  error_code = sign(msg, rand_bytes, signature);
2713  return signature;
2714  }
2715 
2727  std::array<uint8_t, EC_256_WIDTH> vko256(
2728  const Ec512PublicKey_t<CurveID> &other_pk,
2729  intptr_t &error_code) const noexcept
2730  {
2731  std::array<uint8_t, EC_256_WIDTH> out {};
2732  error_code = ec512_vko256(cid, *ptr(), *other_pk.ptr(), nullptr, out.data());
2733  return out;
2734  }
2735 
2758  std::array<uint8_t, EC_256_WIDTH> vko256(
2759  const Ec512PublicKey_t<CurveID> &other_pk,
2760  intptr_t &error_code,
2761  const uint8_t ukm[EC_512_WIDTH]) const noexcept
2762  {
2763  std::array<uint8_t, EC_256_WIDTH> out {};
2764  error_code = ec512_vko256(cid, *ptr(), *other_pk.ptr(), ukm, out.data());
2765  return out;
2766  }
2767 
2779  std::array<uint8_t, EC_512_WIDTH> vko512(
2780  const Ec512PublicKey_t<CurveID> &other_pk,
2781  intptr_t &error_code) const noexcept
2782  {
2783  std::array<uint8_t, EC_512_WIDTH> out {};
2784  error_code = ec512_vko512(cid, *ptr(), *other_pk.ptr(), nullptr, out.data());
2785  return out;
2786  }
2787 
2810  std::array<uint8_t, EC_512_WIDTH> vko512(
2811  const Ec512PublicKey_t<CurveID> &other_pk,
2812  intptr_t &error_code,
2813  const uint8_t ukm[EC_512_WIDTH]) const noexcept
2814  {
2815  std::array<uint8_t, EC_512_WIDTH> out {};
2816  error_code = ec512_vko512(cid, *ptr(), *other_pk.ptr(), ukm, out.data());
2817  return out;
2818  }
2819 
2820 private:
2821  Ec512PrivateKey *ptr() const noexcept
2822  {
2823  return const_cast<Ec512PrivateKey *>(reinterpret_cast<const Ec512PrivateKey *>(&data_));
2824  }
2825 
2827 };
2828 
2833 enum class Gost3410_2012_256 : uintptr_t
2834 {
2839 
2844 
2849 
2854 };
2855 
2856 template <Gost3410_2012_256 CurveID>
2858 
2865 template <Gost3410_2012_256 CurveID>
2867 {
2868  friend class Ec256PrivateKey_t<CurveID>;
2869  const static Ec256 cid = static_cast<Ec256>(CurveID);
2870  Ec256PublicKey_t<CurveID>() = default;
2871 
2872 public:
2873 
2878  ~Ec256PublicKey_t<CurveID>() = default;
2879 
2890  static Ec256PublicKey_t<CurveID> from_bytes(const uint8_t bytes[EC_256_DOUBLE_WIDTH], intptr_t &error_code) noexcept
2891  {
2893  error_code = ec256_public_key_from_bytes(cid, bytes, *result.ptr());
2894  return result;
2895  }
2896 
2909  static Ec256PublicKey_t<CurveID> from_bytes(const std::array<uint8_t, EC_256_DOUBLE_WIDTH> &bytes, intptr_t &error_code) noexcept
2910  {
2911  return from_bytes(bytes.data(), error_code);
2912  }
2913 
2921  std::array<uint8_t, EC_256_DOUBLE_WIDTH> to_bytes() const noexcept
2922  {
2923  std::array<uint8_t, EC_256_DOUBLE_WIDTH> bytes {};
2924  ec256_public_key_to_bytes(cid, *ptr(), bytes.data());
2925  return bytes;
2926  }
2927 
2941  intptr_t verify_hash(const uint8_t hash[STREEBOG256_RESULT_SIZE],
2942  const uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
2943  {
2944  return ec256_dsa_verify_hash(cid, *ptr(), hash, signature);
2945  }
2946 
2958  intptr_t verify_hash(const std::array<uint8_t, STREEBOG256_RESULT_SIZE> &hash,
2959  const std::array<uint8_t, EC_256_DOUBLE_WIDTH> &signature) const noexcept
2960  {
2961  return verify_hash(hash.data(), signature.data());
2962  }
2963 
2977  intptr_t verify(
2978  const uint8_t *msg,
2979  uintptr_t msg_len,
2980  const uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
2981  {
2982  return ec256_dsa_verify(cid, *ptr(), msg, msg_len, signature);
2983  }
2984 
2995  intptr_t verify(const std::vector<uint8_t> &msg, const std::array<uint8_t, EC_256_DOUBLE_WIDTH> &signature) const noexcept
2996  {
2997  return verify(msg.data(), msg.size(), signature.data());
2998  }
2999 
3000 private:
3001  Ec256PublicKey *ptr() const noexcept
3002  {
3003  return const_cast<Ec256PublicKey *>(reinterpret_cast<const Ec256PublicKey *>(&data_));
3004  }
3005 
3007 };
3008 
3015 template <Gost3410_2012_256 CurveID>
3016 class Ec256PrivateKey_t
3017 {
3018  const static Ec256 cid = static_cast<Ec256>(CurveID);
3019  Ec256PrivateKey_t<CurveID>() = default;
3020 
3021 public:
3022 
3027 
3028  ~Ec256PrivateKey_t<CurveID>()
3029  {
3030  ec256_private_key_drop(*ptr());
3031  }
3032 
3043  Ec256PrivateKey_t<CurveID>(const uint8_t rand_bytes[EC_256_WIDTH], intptr_t &error_code) noexcept
3044  : data_{}
3045  {
3046  error_code = ec256_gen_private_key(cid, *ptr(), rand_bytes);
3047  }
3048 
3057  explicit Ec256PrivateKey_t<CurveID>(const std::array<uint8_t, EC_256_WIDTH> &rand_bytes, intptr_t &error_code) noexcept
3058  : data_{}
3059  {
3060  error_code = ec256_gen_private_key(cid, *ptr(), rand_bytes.data());
3061  }
3062 
3071  {
3072  Ec256PublicKey_t<CurveID> public_key;
3073  ec256_get_public_key(cid, *ptr(), *public_key.ptr());
3074  return public_key;
3075  }
3076 
3089  static Ec256PrivateKey_t<CurveID> from_bytes(const uint8_t bytes[EC_256_WIDTH], intptr_t &error_code) noexcept
3090  {
3092  error_code = ec256_private_key_from_bytes(cid, bytes, *result.ptr());
3093  return result;
3094  }
3095 
3106  static Ec256PrivateKey_t<CurveID> from_bytes(const std::array<uint8_t, EC_256_WIDTH> &rand_bytes, intptr_t &error_code) noexcept
3107  {
3108  return from_bytes(rand_bytes.data(), error_code);
3109  }
3110 
3118  std::array<uint8_t, EC_256_WIDTH> to_bytes() const noexcept
3119  {
3120  std::array<uint8_t, EC_256_WIDTH> bytes {};
3121  ec256_private_key_to_bytes(cid, *ptr(), bytes.data());
3122  return bytes;
3123  }
3124 
3139  intptr_t sign_hash(const uint8_t hash[STREEBOG256_RESULT_SIZE],
3140  const uint8_t rand_bytes[EC_256_WIDTH],
3141  uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
3142  {
3143  return ec256_dsa_sign_hash(cid, *ptr(), hash, rand_bytes, signature);
3144  }
3145 
3158  std::array<uint8_t, EC_256_DOUBLE_WIDTH> sign_hash(
3159  const std::array<uint8_t, STREEBOG256_RESULT_SIZE> &hash,
3160  const std::array<uint8_t, EC_256_WIDTH> &rand_bytes,
3161  intptr_t &error_code) const noexcept
3162  {
3163  std::array<uint8_t, EC_256_DOUBLE_WIDTH> signature {};
3164  error_code = sign_hash(hash.data(), rand_bytes.data(), signature.data());
3165  return signature;
3166  }
3167 
3182  intptr_t sign(
3183  const uint8_t *msg,
3184  uintptr_t msg_len,
3185  const uint8_t rand_bytes[EC_256_WIDTH],
3186  uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
3187  {
3188  return ec256_dsa_sign(cid, *ptr(), msg, msg_len, rand_bytes, signature);
3189  }
3190 
3202  intptr_t sign(const std::vector<uint8_t> &msg, const std::array<uint8_t, EC_256_WIDTH> &rand_bytes, std::array<uint8_t, EC_256_DOUBLE_WIDTH> &signature) const noexcept
3203  {
3204  return sign(msg.data(), msg.size(), rand_bytes.data(), signature.data());
3205  }
3206 
3218  std::array<uint8_t, EC_256_DOUBLE_WIDTH> sign(const std::vector<uint8_t> &msg, const std::array<uint8_t, EC_256_WIDTH> &rand_bytes, intptr_t &error_code) const noexcept
3219  {
3220  std::array<uint8_t, EC_256_DOUBLE_WIDTH> signature {};
3221  error_code = sign(msg, rand_bytes, signature);
3222  return signature;
3223  }
3224 
3236  std::array<uint8_t, EC_256_WIDTH> vko256(
3237  const Ec256PublicKey_t<CurveID> &other_pk,
3238  intptr_t &error_code) const noexcept
3239  {
3240  std::array<uint8_t, EC_256_WIDTH> out {};
3241  error_code = ec256_vko256(cid, *ptr(), *other_pk.ptr(), nullptr, out.data());
3242  return out;
3243  }
3244 
3267  std::array<uint8_t, EC_256_WIDTH> vko256(
3268  const Ec256PublicKey_t<CurveID> &other_pk,
3269  intptr_t &error_code,
3270  const uint8_t ukm[EC_256_WIDTH]) const noexcept
3271  {
3272  std::array<uint8_t, EC_256_WIDTH> out {};
3273  error_code = ec256_vko256(cid, *ptr(), *other_pk.ptr(), ukm, out.data());
3274  return out;
3275  }
3276 
3277 private:
3278  Ec256PrivateKey *ptr() const noexcept
3279  {
3280  return const_cast<Ec256PrivateKey *>(reinterpret_cast<const Ec256PrivateKey *>(&data_));
3281  }
3282 
3284 };
3285 
3286 #endif /* GOSTCRYPTO_HPP */
void reset() noexcept
Сбросить состояние функции хэширования.
Ec512PrivateKey_t< CurveID > & operator=(const Ec512PrivateKey_t< CurveID > &)=default
Magma_t & operator=(const Magma_t &)=default
void apply_keystream(std::vector< uint8_t > &buf) noexcept
Гаммировать сообщение ключевым потоком шифра.
KuznyechikMac_t & operator=(const KuznyechikMac_t &)=default
intptr_t sign(const uint8_t *msg, uintptr_t msg_len, const uint8_t rand_bytes[EC_256_WIDTH], uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
Подписать сообщение.
void magma_drop(Magma cipher)
Уничтожить контекст.
KuznyechikMac_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
Создать состояние режима выработки имитовставки.
void magma_mac_update(MagmaMac state, const uint8_t *msg, uintptr_t len)
Обновить состояние режиму выработки имитовставки.
void encrypt_blocks(uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
Зашифровать массив блоков.
Definition: gostcrypto.hpp:761
typename std::aligned_storage< Len, Align >::type aligned_storage_t
Definition: gostcrypto.hpp:15
void streebog512_reset(Streebog512 state)
Сбросить состояние функции хэширования.
intptr_t ec512_public_key_from_bytes(Ec512 cid, const uint8_t bytes[EC_512_DOUBLE_WIDTH], Ec512PublicKey pk)
Десериалировать открытый ключ.
void magma_encrypt_block(Magma cipher, uint8_t block[MAGMA_BLOCK_SIZE])
Зашифровать блок данных.
#define STREEBOG256_RESULT_SIZE
Длина хэш-кода Streebog256 (в байтах)
Definition: gostcrypto.h:276
void kuznyechik_cfb_drop(KuznyechikCfb cipher)
Уничтожить контекст шифра.
KuznyechikCtr_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CTR_NONCE_SIZE]) noexcept
Создать контекст потокового шифра.
Definition: gostcrypto.hpp:927
#define GOST3410_2012_512C
Идентификатор кривой id-tc26-gost-3410-12-512-paramSetC, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:214
void magma_ecb_new(MagmaEcb dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать контекст блочного шифра.
void streebog512_new(Streebog512 dst)
Создать состояние функции хэширования.
intptr_t sign(const uint8_t *msg, uintptr_t msg_len, const uint8_t rand_bytes[EC_512_WIDTH], uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
Подписать сообщение.
KuznyechikCbc_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CBC_NONCE_SIZE]) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:190
void magma_mac_finalize_reset(MagmaMac state, uint8_t res[MAGMA_MAC_RESULT_SIZE])
Финализировать состояние режима выработки имитовставки и заменить его новым.
#define MAGMA_CBC_NONCE_SIZE
Размер синхропосылки MagmaCbc (в байтах)
Definition: gostcrypto.h:54
MagmaCfb_t & operator=(const MagmaCfb_t &)=default
KuznyechikCtr_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, KUZNYECHIK_CTR_NONCE_SIZE > &nonce) noexcept
Создать контекст потокового шифра.
Definition: gostcrypto.hpp:942
#define KUZNYECHIK_MGM_NONCE_SIZE
Размер синхропосылки KuznyechikMgm (в байтах)
Definition: gostcrypto.h:19
Блочный шифр с длиной блока 128 бит в режиме простой замены с зацеплением с размером синхропосылки 16...
Definition: gostcrypto.hpp:171
void encrypt_blocks(uint8_t(*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
Зашифровать массив блоков.
void update(const uint8_t *msg, uintptr_t len) noexcept
Обновить состояние функции хэширования.
uint8_t KuznyechikCtr[KUZNYECHIK_CTR_SIZE]
Потоковый шифр с длиной блока 128 бит в режиме гаммирования.
Definition: gostcrypto.h:530
static std::array< uint8_t, STREEBOG256_RESULT_SIZE > digest(const uint8_t *msg, uintptr_t len) noexcept
Хэшировать сообщение.
#define MAGMA_CFB_NONCE_SIZE
Размер синхропосылки MagmaCfb (в байтах)
Definition: gostcrypto.h:84
std::array< uint8_t, EC_256_WIDTH > to_bytes() const noexcept
Сериализовать закрытый ключ.
Блочный шифр с длиной блока 64 бит в режиме простой замены с зацеплением с размером синхропосылки 8 б...
Definition: gostcrypto.hpp:313
Идентификатор кривой id-tc26-gost-3410-12-512-paramSetB, заданной в Р 1323565.1.024-2019.
Streebog256_t & operator=(const Streebog256_t &)=default
Kuznyechik_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:712
void encrypt(std::vector< uint8_t > &buf) noexcept
Зашифровать сообщение.
Definition: gostcrypto.hpp:636
MagmaCbc_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CBC_NONCE_SIZE]) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:332
void kuznyechik_ecb_encrypt_blocks(KuznyechikEcb cipher, uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len)
Зашифровать массив блоков
intptr_t ec256_public_key_from_bytes(Ec256 cid, const uint8_t bytes[EC_256_DOUBLE_WIDTH], Ec256PublicKey pk)
Десериалировать открытый ключ.
std::array< uint8_t, MAGMA_MAC_RESULT_SIZE > finalize() const noexcept
Финализировать состояние режима выработки имитовставки.
uint8_t MagmaOfb[MAGMA_OFB_SIZE]
Потоковый шифр с длиной блока 64 бит в режиме гаммирования с обратной связью по выходу с размером син...
Definition: gostcrypto.h:826
void finalize(uint8_t res[STREEBOG256_RESULT_SIZE]) const noexcept
Финализировать состояние функции хэширования.
static Ec256PublicKey_t< CurveID > from_bytes(const std::array< uint8_t, EC_256_DOUBLE_WIDTH > &bytes, intptr_t &error_code) noexcept
Десериалировать открытый ключ.
uint8_t MagmaEcb[MAGMA_ECB_SIZE]
Блочный шифр с длиной блока 64 бит в режиме простой замены.
Definition: gostcrypto.h:592
Streebog512_t() noexcept
Создать состояние функции хэширования.
uint64_t get_pos() const noexcept
Получить позицию ключевого потока шифра.
MagmaCbc_t & operator=(const MagmaCbc_t &)=default
intptr_t ec256_private_key_from_bytes(Ec256 cid, const uint8_t bytes[EC_256_WIDTH], Ec256PrivateKey sk)
Десериалировать закрытый ключ.
KuznyechikCfb_t & operator=(const KuznyechikCfb_t &)=default
intptr_t apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
Гаммировать сообщение ключевым потоком шифра.
intptr_t sign(const std::vector< uint8_t > &msg, const std::array< uint8_t, EC_512_WIDTH > &rand_bytes, std::array< uint8_t, EC_512_DOUBLE_WIDTH > &signature) const noexcept
Подписать сообщение.
KuznyechikCtr_t(const KuznyechikCtr_t &)=default
intptr_t magma_ctr_seek(MagmaCtr cipher, uint64_t pos)
Установить позицию ключевого потока шифра.
intptr_t magma_cbc_decrypt_pad(MagmaCbc cipher, uint8_t *buf, uintptr_t buf_len)
Расшифровать сообщение.
void magma_mac_finalize(MagmaMac state, uint8_t res[MAGMA_MAC_RESULT_SIZE])
Финализировать состояние режима выработки имитовставки.
MagmaEcb_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать контекст блочного шифра.
void magma_ecb_drop(MagmaEcb cipher)
Уничтожить контекст шифра.
MagmaOfb_t & operator=(const MagmaOfb_t &)=default
intptr_t kuznyechik_ctr_apply_keystream(KuznyechikCtr cipher, uint8_t *buf, uintptr_t buf_len)
Гаммировать сообщение ключевым потоком шифра.
void magma_ofb_apply_keystream(MagmaOfb cipher, uint8_t *buf, uintptr_t buf_len)
Гаммировать сообщение ключевым потоком шифра.
KuznyechikOfb_t & operator=(const KuznyechikOfb_t &)=default
KuznyechikOfb_t(const KuznyechikOfb_t &)=default
MagmaCtr_t & operator=(const MagmaCtr_t &)=default
#define EC_256_DOUBLE_WIDTH
Длина сериализованного открытого ключа и подписи кривых Ec256 (в байтах)
Definition: gostcrypto.h:184
KuznyechikCbc_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, KUZNYECHIK_CBC_NONCE_SIZE > &nonce) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:205
intptr_t kuznyechik_mgm_decrypt(KuznyechikMgm cipher, const uint8_t nonce[KUZNYECHIK_MGM_NONCE_SIZE], const uint8_t *aad, uintptr_t aad_len, uint8_t *buf, uintptr_t buf_len, const uint8_t tag[KUZNYECHIK_MGM_TAG_SIZE])
Расшифровать сообщение с присоединёнными данными.
void kuznyechik_ofb_drop(KuznyechikOfb cipher)
Уничтожить контекст шифра.
MagmaMac_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать состояние режима выработки имитовставки.
intptr_t ec256_get_public_key(Ec256 cid, Ec256PrivateKey sk, Ec256PublicKey pk)
Получить открытый ключ.
intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
Расшифровать сообщение.
void kuznyechik_decrypt_block(Kuznyechik cipher, uint8_t block[KUZNYECHIK_BLOCK_SIZE])
Расшифровать блок данных.
void magma_ofb_new(MagmaOfb dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_OFB_NONCE_SIZE])
Создать контекст потокового шифра.
void kuznyechik_encrypt_block(Kuznyechik cipher, uint8_t block[KUZNYECHIK_BLOCK_SIZE])
Зашифровать блок данных.
void encrypt_blocks(uint8_t(*blocks)[MAGMA_BLOCK_SIZE], uintptr_t blocks_len) noexcept
Зашифровать массив блоков.
Definition: gostcrypto.hpp:369
void magma_ecb_decrypt_blocks(MagmaEcb cipher, uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t blocks_len)
Расшифровать массив блоков.
void streebog512_digest(const uint8_t *msg, uintptr_t len, uint8_t res[STREEBOG512_RESULT_SIZE])
Хэшировать сообщение.
~MagmaOfb_t() noexcept
void kuznyechik_mac_reset(KuznyechikMac state)
Сбросить состояние режима выработки имитовставки.
Kuznyechik_t(const Kuznyechik_t &)=default
void kuznyechik_encrypt_blocks(Kuznyechik cipher, uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t len)
Зашифровать массив блоков.
Streebog512_t & operator=(const Streebog512_t &)=default
intptr_t ec512_dsa_verify_hash(Ec512 cid, Ec512PublicKey pk, const uint8_t hash[EC_512_WIDTH], const uint8_t signature[EC_512_DOUBLE_WIDTH])
Проверить подпись хэша сообщения.
KuznyechikCfb_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, KUZNYECHIK_CFB_NONCE_SIZE > &nonce) noexcept
Создать контекст потокового шифра.
Definition: gostcrypto.hpp:489
intptr_t ec512_gen_private_key(Ec512 cid, Ec512PrivateKey sk, const uint8_t rand_bytes[EC_512_WIDTH])
Создать закрытый ключ.
void magma_ctr_drop(MagmaCtr cipher)
Уничтожить контекст шифра.
Ec256PrivateKey_t< CurveID > & operator=(const Ec256PrivateKey_t< CurveID > &)=default
void magma_new(Magma dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать контекст блочного шифра.
std::array< uint8_t, STREEBOG512_RESULT_SIZE > finalize_reset() noexcept
Финализировать состояние функции хэширования и заменить его новым.
uintptr_t Ec256
Алгоритмы формирования, проверки электронной цифровой подписи и выработки общих ключей.
Definition: gostcrypto.h:633
uint64_t kuznyechik_ctr_get_pos(KuznyechikCtr cipher)
Получить позицию ключевого потока шифра.
~MagmaMac_t() noexcept
uint8_t KuznyechikCfb[KUZNYECHIK_CFB_SIZE]
Потоковый шифр с длиной блока 128 бит в режиме гаммирования с обратной связью по шифртексту с размеро...
Definition: gostcrypto.h:448
uint8_t Streebog512[STREEBOG512_SIZE]
Функция хэширования с длиной хэш-кода 512 бит.
Definition: gostcrypto.h:744
intptr_t ec512_private_key_to_bytes(Ec512 cid, Ec512PrivateKey sk, uint8_t bytes[EC_512_WIDTH])
Сериализовать закрытый ключ.
void decrypt_block(uint8_t block[KUZNYECHIK_BLOCK_SIZE]) noexcept
Расшифровать блок данных.
Definition: gostcrypto.hpp:746
#define GOST3410_2012_512A
Идентификатор кривой id-tc26-gost-3410-12-512-paramSetA, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:204
MagmaMac_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
Создать состояние режима выработки имитовставки.
intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
Расшифровать сообщение.
Ec256PublicKey_t< CurveID > get_public_key() const noexcept
Получить открытый ключ.
MagmaCtr_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CTR_NONCE_SIZE]) noexcept
Создать контекст потокового шифра.
intptr_t apply_keystream(std::vector< uint8_t > &buf) noexcept
Гаммировать сообщение ключевым потоком шифра.
Definition: gostcrypto.hpp:981
std::array< uint8_t, EC_256_WIDTH > vko256(const Ec256PublicKey_t< CurveID > &other_pk, intptr_t &error_code, const uint8_t ukm[EC_256_WIDTH]) const noexcept
Выработать общий ключ.
void reset() noexcept
Сбросить состояние функции хэширования.
intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
Расшифровать сообщение.
Definition: gostcrypto.hpp:287
void kuznyechik_cbc_drop(KuznyechikCbc cipher)
Уничтожить контекст шифра.
void decrypt(uint8_t *buf, uintptr_t buf_len) noexcept
Расшифровать сообщение.
Definition: gostcrypto.hpp:537
intptr_t ec512_dsa_sign(Ec512 cid, Ec512PrivateKey sk, const uint8_t *msg, uintptr_t msg_len, const uint8_t rand_bytes[EC_512_WIDTH], uint8_t signature[EC_512_DOUBLE_WIDTH])
Подписать сообщение.
Потокововый шифр с длиной блока 64 бит в режиме гаммирования.
std::array< uint8_t, EC_512_DOUBLE_WIDTH > to_bytes() const noexcept
Сериализовать открытый ключ.
intptr_t ec512_private_key_from_bytes(Ec512 cid, const uint8_t bytes[EC_512_WIDTH], Ec512PrivateKey sk)
Десериалировать закрытый ключ.
uintptr_t Ec512
Алгоритмы формирования, проверки электронной цифровой подписи и выработки общих ключей.
Definition: gostcrypto.h:688
#define KUZNYECHIK_BLOCK_SIZE
Размер блока шифра Kuznyechik (в байтах)
Definition: gostcrypto.h:99
void decrypt_block(uint8_t block[MAGMA_BLOCK_SIZE]) noexcept
Расшифровать блок данных.
Definition: gostcrypto.hpp:859
void reset() noexcept
Сбросить состояние режима выработки имитовставки.
intptr_t ec512_get_public_key(Ec512 cid, Ec512PrivateKey sk, Ec512PublicKey pk)
Получить открытый ключ.
~MagmaCtr_t() noexcept
KuznyechikEcb_t(const KuznyechikEcb_t &)=default
~Kuznyechik_t() noexcept
Definition: gostcrypto.hpp:718
Блочный шифр с длиной блока 128 бит.
Definition: gostcrypto.hpp:682
MagmaCfb_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, MAGMA_CFB_NONCE_SIZE > &nonce) noexcept
Создать контекст потокового шифра.
Definition: gostcrypto.hpp:603
intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
Зашифровать сообщение.
Definition: gostcrypto.hpp:408
Потоковый шифр с длиной блока 128 бит в режиме гаммирования.
Definition: gostcrypto.hpp:908
void streebog256_finalize(Streebog256 state, uint8_t res[STREEBOG256_RESULT_SIZE])
Финализировать состояние функции хэширования.
intptr_t ec256_dsa_verify(Ec256 cid, Ec256PublicKey pk, const uint8_t *msg, uintptr_t msg_len, const uint8_t signature[EC_256_DOUBLE_WIDTH])
Проверить подпись сообщения.
uint8_t MagmaCtr[MAGMA_CTR_SIZE]
Потоковый шифр с длиной блока 64 бит в режиме гаммирования.
Definition: gostcrypto.h:550
Потоковый шифр с длиной блока 64 бит в режиме гаммирования с обратной связью по выходу с размером син...
Идентификатор кривой id-tc26-gost-3410-12-512-paramSetC, заданной в Р 1323565.1.024-2019.
#define KUZNYECHIK_MAC_RESULT_SIZE
Длина имитовставки KuznyechikMac (в байтах)
Definition: gostcrypto.h:306
intptr_t magma_ecb_decrypt_pad(MagmaEcb cipher, uint8_t *buf, uintptr_t buf_len)
Расшифровать сообщение.
intptr_t verify(const std::vector< uint8_t > &msg, const std::array< uint8_t, EC_512_DOUBLE_WIDTH > &signature) const noexcept
Проверить подпись сообщения.
void encrypt(uint8_t *buf, uintptr_t buf_len) noexcept
Зашифровать сообщение.
Definition: gostcrypto.hpp:624
static Ec512PublicKey_t< CurveID > from_bytes(const uint8_t bytes[EC_512_DOUBLE_WIDTH], intptr_t &error_code) noexcept
Десериалировать открытый ключ.
uint8_t MagmaMac[MAGMA_MAC_SIZE]
Режим выработки имитовставки с использованием шифра с длиной блока 64 бит.
Definition: gostcrypto.h:788
#define EC_512_DOUBLE_WIDTH
Длина сериализованного открытого ключа и подписи кривых Ec512 (в байтах)
Definition: gostcrypto.h:224
void kuznyechik_ofb_new(KuznyechikOfb dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_OFB_NONCE_SIZE])
Создать контекст потокового шифра.
#define EC_512_WIDTH
Длина закрытого ключа и хэша сообщения кривых Ec512 (в байтах)
Definition: gostcrypto.h:219
std::array< uint8_t, EC_512_DOUBLE_WIDTH > sign_hash(const std::array< uint8_t, STREEBOG512_RESULT_SIZE > &hash, const std::array< uint8_t, EC_512_WIDTH > &rand_bytes, intptr_t &error_code) const noexcept
Подписать хэш сообщения.
void streebog512_finalize_reset(Streebog512 state, uint8_t res[STREEBOG512_RESULT_SIZE])
Финализировать состояние функции хэширования и заменить его новым.
void finalize_reset(uint8_t res[KUZNYECHIK_MAC_RESULT_SIZE]) noexcept
Финализировать состояние режима выработки имитовставки и заменить его новым.
intptr_t kuznyechik_cbc_encrypt_pad(KuznyechikCbc cipher, uint8_t *buf, uintptr_t buf_len, uintptr_t pos)
Зашифровать сообщение.
KuznyechikCbc_t & operator=(const KuznyechikCbc_t &)=default
std::array< uint8_t, EC_256_DOUBLE_WIDTH > to_bytes() const noexcept
Сериализовать открытый ключ.
uint8_t Magma[MAGMA_SIZE]
Блочный шифр с длиной блока 64 бит.
Definition: gostcrypto.h:510
Блочный шифр с длиной блока 64 бит.
Definition: gostcrypto.hpp:795
uint8_t Kuznyechik[KUZNYECHIK_SIZE]
Блочный шифр с длиной блока 128 бит.
Definition: gostcrypto.h:489
void kuznyechik_mgm_drop(KuznyechikMgm cipher)
Уничтожить контекст шифра
void streebog512_finalize(Streebog512 state, uint8_t res[STREEBOG512_RESULT_SIZE])
Финализировать состояние функции хэширования.
void kuznyechik_cfb_encrypt(KuznyechikCfb cipher, uint8_t *buf, uintptr_t buf_len)
Зашифровать сообщение.
MagmaEcb_t(const MagmaEcb_t &)=default
intptr_t decrypt_pad(uint8_t *buf, uintptr_t buf_len) const noexcept
Расшифровать сообщение.
Definition: gostcrypto.hpp:429
bool kuznyechik_mac_verify(KuznyechikMac state, const uint8_t code[KUZNYECHIK_MAC_RESULT_SIZE])
Проверить целостность данных.
static Ec256PrivateKey_t< CurveID > from_bytes(const uint8_t bytes[EC_256_WIDTH], intptr_t &error_code) noexcept
Десериалировать закрытый ключ.
void encrypt_blocks(uint8_t(*blocks)[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
Зашифровать массив блоков.
intptr_t kuznyechik_cbc_decrypt_pad(KuznyechikCbc cipher, uint8_t *buf, uintptr_t buf_len)
Расшифровать сообщение.
~MagmaCfb_t() noexcept
Definition: gostcrypto.hpp:609
KuznyechikOfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_OFB_NONCE_SIZE]) noexcept
Создать контекст потокового шифра.
void kuznyechik_ctr_new(KuznyechikCtr dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CTR_NONCE_SIZE])
Создать контекст потокового шифра.
std::array< uint8_t, EC_256_DOUBLE_WIDTH > sign(const std::vector< uint8_t > &msg, const std::array< uint8_t, EC_256_WIDTH > &rand_bytes, intptr_t &error_code) const noexcept
Подписать сообщение.
~KuznyechikCbc_t() noexcept
Definition: gostcrypto.hpp:211
static Ec512PrivateKey_t< CurveID > from_bytes(const std::array< uint8_t, EC_512_WIDTH > &rand_bytes, intptr_t &error_code) noexcept
Десериалировать закрытый ключ.
uint8_t Ec256PublicKey[EC_256_PUBLIC_KEY_SIZE]
Несериализованный открытый ключ кривых Ec256 длиной EC_256_PUBLIC_KEY_SIZE и выравниванием EC_256_PUB...
Definition: gostcrypto.h:647
intptr_t sign_hash(const uint8_t hash[STREEBOG512_RESULT_SIZE], const uint8_t rand_bytes[EC_512_WIDTH], uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
Подписать хэш сообщения.
~Streebog256_t() noexcept
Режим выработки имитовставки с использованием шифра с длиной блока 64 бит.
Закрытый ключ эллиптических кривых.
intptr_t verify(const std::vector< uint8_t > &msg, const std::array< uint8_t, EC_256_DOUBLE_WIDTH > &signature) const noexcept
Проверить подпись сообщения.
Блочный шифр с длиной блока 128 бит в режиме работы блочных шифров, реализующим аутентифицирующее шиф...
Definition: gostcrypto.hpp:27
intptr_t apply_keystream(std::vector< uint8_t > &buf) noexcept
Гаммировать сообщение ключевым потоком шифра.
#define GOST3410_2012_512B
Идентификатор кривой id-tc26-gost-3410-12-512-paramSetB, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:209
void decrypt_blocks(uint8_t(*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len) noexcept
Расшифровать массив блоков.
Definition: gostcrypto.hpp:243
intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
Зашифровать сообщение.
intptr_t ec256_dsa_verify_hash(Ec256 cid, Ec256PublicKey pk, const uint8_t hash[EC_256_WIDTH], const uint8_t signature[EC_256_DOUBLE_WIDTH])
Проверить подпись хэша сообщения.
Ec256PublicKey_t< CurveID > & operator=(const Ec256PublicKey_t< CurveID > &)=default
void kuznyechik_ecb_drop(KuznyechikEcb cipher)
Уничтожить контекст шифра.
intptr_t verify_hash(const uint8_t hash[STREEBOG512_RESULT_SIZE], const uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
Проверить подпись хэша сообщения.
void decrypt_blocks(uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
Расшифровать массив блоков.
Definition: gostcrypto.hpp:889
void magma_decrypt_block(Magma cipher, uint8_t block[MAGMA_BLOCK_SIZE])
Расшифровать блок данных.
intptr_t magma_cbc_encrypt_pad(MagmaCbc cipher, uint8_t *buf, uintptr_t buf_len, uintptr_t pos)
Зашифровать сообщение.
std::array< uint8_t, EC_256_WIDTH > vko256(const Ec512PublicKey_t< CurveID > &other_pk, intptr_t &error_code, const uint8_t ukm[EC_512_WIDTH]) const noexcept
Выработать общий ключ.
void encrypt(uint8_t *buf, uintptr_t buf_len) noexcept
Зашифровать сообщение.
Definition: gostcrypto.hpp:510
#define KUZNYECHIK_CBC_NONCE_SIZE
Размер синхропосылки KuznyechikCbc (в байтах)
Definition: gostcrypto.h:39
void magma_cfb_drop(MagmaCfb cipher)
Уничтожить контекст шифра.
intptr_t kuznyechik_mgm_encrypt(KuznyechikMgm cipher, const uint8_t nonce[KUZNYECHIK_MGM_NONCE_SIZE], const uint8_t *aad, uintptr_t aad_len, uint8_t *buf, uintptr_t buf_len, uint8_t tag[KUZNYECHIK_MGM_TAG_SIZE])
Зашифровать сообщение с присоединёнными данными.
intptr_t verify(const uint8_t *msg, uintptr_t msg_len, const uint8_t signature[EC_512_DOUBLE_WIDTH]) const noexcept
Проверить подпись сообщения.
#define KUZNYECHIK_CTR_NONCE_SIZE
Размер синхропосылки KuznyechikCtr (в байтах)
Definition: gostcrypto.h:129
void kuznyechik_drop(Kuznyechik cipher)
Уничтожить контекст.
Закрытый ключ эллиптических кривых.
void kuznyechik_mac_drop(KuznyechikMac state)
Уничтожить состояние режима выработки имитовставки.
std::array< uint8_t, EC_256_DOUBLE_WIDTH > sign_hash(const std::array< uint8_t, STREEBOG256_RESULT_SIZE > &hash, const std::array< uint8_t, EC_256_WIDTH > &rand_bytes, intptr_t &error_code) const noexcept
Подписать хэш сообщения.
~KuznyechikEcb_t() noexcept
intptr_t verify_hash(const uint8_t hash[STREEBOG256_RESULT_SIZE], const uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
Проверить подпись хэша сообщения.
uint8_t MagmaCbc[MAGMA_CBC_SIZE]
Блочный шифр с длиной блока 64 бит в режиме простой замены с зацеплением с размером синхропосылки 8 б...
Definition: gostcrypto.h:428
~MagmaCbc_t() noexcept
Definition: gostcrypto.hpp:353
~KuznyechikOfb_t() noexcept
void kuznyechik_ofb_apply_keystream(KuznyechikOfb cipher, uint8_t *buf, uintptr_t buf_len)
Гаммировать сообщение ключевым потоком шифра.
#define MAGMA_CTR_NONCE_SIZE
Размер синхропосылки MagmaCtr (в байтах)
Definition: gostcrypto.h:144
MagmaEcb_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
Создать контекст блочного шифра.
~Streebog512_t() noexcept
MagmaMac_t(const MagmaMac_t &)=default
KuznyechikMgm_t(const KuznyechikMgm_t &)=default
intptr_t magma_ctr_apply_keystream(MagmaCtr cipher, uint8_t *buf, uintptr_t buf_len)
Гаммировать сообщение ключевым потоком шифра.
intptr_t kuznyechik_ctr_seek(KuznyechikCtr cipher, uint64_t pos)
Установить позицию ключевого потока шифра.
void encrypt_block(uint8_t block[KUZNYECHIK_BLOCK_SIZE]) noexcept
Зашифровать блок данных.
Definition: gostcrypto.hpp:732
uint8_t Streebog256[STREEBOG256_SIZE]
Функция хэширования с длиной хэш-кода 256 бит.
Definition: gostcrypto.h:723
uint8_t KuznyechikCbc[KUZNYECHIK_CBC_SIZE]
Блочный шифр с длиной блока 128 бит в режиме простой замены с зацеплением с размером синхропосылки 16...
Definition: gostcrypto.h:405
intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
Зашифровать сообщение.
void magma_mac_new(MagmaMac dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать состояние режима выработки имитовставки.
static Ec512PublicKey_t< CurveID > from_bytes(const std::array< uint8_t, EC_512_DOUBLE_WIDTH > &bytes, intptr_t &error_code) noexcept
Десериалировать открытый ключ.
void magma_decrypt_blocks(Magma cipher, uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t len)
Расшифровать массив блоков.
uint8_t KuznyechikEcb[KUZNYECHIK_ECB_SIZE]
Блочный шифр с длиной блока 128 бит в режиме простой замены.
Definition: gostcrypto.h:571
#define KUZNYECHIK_MGM_TAG_SIZE
Размер имитовставки KuznyechikMgm (в байтах)
Definition: gostcrypto.h:24
MagmaEcb_t & operator=(const MagmaEcb_t &)=default
#define GOST3410_2012_256A
Идентификатор кривой id-tc26-gost-3410-2012-256-paramSetA, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:831
Gost3410_2012_256
Идентификатор эллиптических кривых, для алгоритмов формирования, проверки электронной цифровой подпис...
#define STREEBOG512_RESULT_SIZE
Длина хэш-кода Streebog512 (в байтах)
Definition: gostcrypto.h:291
void kuznyechik_mac_new(KuznyechikMac dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать состояние режима выработки имитовставки.
KuznyechikCfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CFB_NONCE_SIZE]) noexcept
Создать контекст потокового шифра.
Definition: gostcrypto.hpp:474
void reset() noexcept
Сбросить состояние режима выработки имитовставки.
void kuznyechik_cfb_decrypt(KuznyechikCfb cipher, uint8_t *buf, uintptr_t buf_len)
Расшифровать сообщение.
~KuznyechikMac_t() noexcept
intptr_t ec256_dsa_sign_hash(Ec256 cid, Ec256PrivateKey sk, const uint8_t hash[EC_256_WIDTH], const uint8_t rand_bytes[EC_256_WIDTH], uint8_t signature[EC_256_DOUBLE_WIDTH])
Подписать хэш сообщения.
void finalize_reset(uint8_t res[STREEBOG512_RESULT_SIZE]) noexcept
Финализировать состояние функции хэширования и заменить его новым.
intptr_t decrypt(const std::array< uint8_t, KUZNYECHIK_MGM_NONCE_SIZE > &nonce, const std::vector< uint8_t > &aad, std::vector< uint8_t > &buf, const std::array< uint8_t, KUZNYECHIK_MGM_TAG_SIZE > &tag) const noexcept
Расшифровать сообщение с присоединёнными данными.
Definition: gostcrypto.hpp:138
uint8_t Ec512PublicKey[EC_512_PUBLIC_KEY_SIZE]
Несериализованный открытый ключ кривых Ec512 длиной EC_512_PUBLIC_KEY_SIZE и выравниванием EC_512_PUB...
Definition: gostcrypto.h:702
void decrypt_blocks(uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
Расшифровать массив блоков.
Definition: gostcrypto.hpp:776
void kuznyechik_cbc_encrypt_blocks(KuznyechikCbc cipher, uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len)
Зашифровать массив блоков.
intptr_t ec256_gen_private_key(Ec256 cid, Ec256PrivateKey sk, const uint8_t rand_bytes[EC_256_WIDTH])
Создать закрытый ключ.
void streebog512_update(Streebog512 state, const uint8_t *msg, uintptr_t len)
Обновить состояние функции хэширования.
void update(const std::vector< uint8_t > &message) noexcept
Обновить состояние функции хэширования.
intptr_t encrypt(const uint8_t nonce[KUZNYECHIK_MGM_NONCE_SIZE], const uint8_t *aad, uintptr_t aad_len, uint8_t *buf, uintptr_t buf_len, uint8_t tag[KUZNYECHIK_MGM_TAG_SIZE]) const noexcept
Зашифровать сообщение с присоединёнными данными.
Definition: gostcrypto.hpp:66
KuznyechikEcb_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать контекст блочного шифра.
KuznyechikCbc_t(const KuznyechikCbc_t &)=default
void kuznyechik_mac_finalize_reset(KuznyechikMac state, uint8_t res[KUZNYECHIK_MAC_RESULT_SIZE])
Финализировать состояние режима выработки имитовставки и заменить его новым.
void decrypt(uint8_t *buf, uintptr_t buf_len) noexcept
Расшифровать сообщение.
Definition: gostcrypto.hpp:651
KuznyechikMgm_t & operator=(const KuznyechikMgm_t &)=default
void encrypt_blocks(uint8_t(*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len) noexcept
Зашифровать массив блоков.
Definition: gostcrypto.hpp:227
bool verify(const std::array< uint8_t, MAGMA_MAC_RESULT_SIZE > &code) const noexcept
Проверить целостность данных.
std::array< uint8_t, STREEBOG512_RESULT_SIZE > finalize() const noexcept
Финализировать состояние функции хэширования.
static Ec256PublicKey_t< CurveID > from_bytes(const uint8_t bytes[EC_256_DOUBLE_WIDTH], intptr_t &error_code) noexcept
Десериалировать открытый ключ.
void encrypt(std::vector< uint8_t > &buf) noexcept
Зашифровать сообщение.
Definition: gostcrypto.hpp:522
#define SYMMETRIC_KEY_SIZE
Размер ключа симметричного шифра (в байтах)
Definition: gostcrypto.h:14
intptr_t magma_ecb_encrypt_pad(MagmaEcb cipher, uint8_t *buf, uintptr_t buf_len, uintptr_t pos)
Зашифровать сообщение.
intptr_t verify(const uint8_t *msg, uintptr_t msg_len, const uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
Проверить подпись сообщения.
void streebog256_finalize_reset(Streebog256 state, uint8_t res[STREEBOG256_RESULT_SIZE])
Финализировать состояние функции хэширования и заменить его новым.
Gost3410_2012_512
Идентификатор эллиптических кривых, для алгоритмов формирования, проверки электронной цифровой подпис...
void magma_ctr_new(MagmaCtr dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CTR_NONCE_SIZE])
Создать контекст потокового шифра.
void magma_cbc_drop(MagmaCbc cipher)
Уничтожить контекст шифра.
MagmaCbc_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, MAGMA_CBC_NONCE_SIZE > &nonce) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:347
bool magma_mac_verify(MagmaMac state, const uint8_t code[MAGMA_MAC_RESULT_SIZE])
Проверить целостность данных.
void decrypt(std::vector< uint8_t > &buf) noexcept
Расшифровать сообщение.
Definition: gostcrypto.hpp:663
void streebog256_update(Streebog256 state, const uint8_t *msg, uintptr_t len)
Обновить состояние функции хэширования.
Открытый ключ эллиптических кривых.
intptr_t ec512_vko256(Ec512 cid, Ec512PrivateKey sk, Ec512PublicKey pk, const uint8_t ukm[EC_512_WIDTH], uint8_t out[EC_256_WIDTH])
Выработать общий ключ.
bool verify(const uint8_t code[KUZNYECHIK_MAC_RESULT_SIZE]) const noexcept
Проверить целостность данных.
uint64_t magma_ctr_get_pos(MagmaCtr cipher)
Получить позицию ключевого потока шифра.
void update(const uint8_t *msg, uintptr_t len) noexcept
Обновить состояние режиму выработки имитовставки.
void kuznyechik_cbc_new(KuznyechikCbc dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CBC_NONCE_SIZE])
Создать контекст блочного шифра.
void kuznyechik_mac_finalize(KuznyechikMac state, uint8_t res[KUZNYECHIK_MAC_RESULT_SIZE])
Финализировать состояние режима выработки имитовставки.
std::array< uint8_t, STREEBOG256_RESULT_SIZE > finalize() const noexcept
Финализировать состояние функции хэширования.
void update(const std::vector< uint8_t > &message) noexcept
Обновить состояние функции хэширования.
intptr_t apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
Гаммировать сообщение ключевым потоком шифра.
Definition: gostcrypto.hpp:966
void kuznyechik_mgm_new(KuznyechikMgm dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать контекст AEAD.
void streebog256_digest(const uint8_t *msg, uintptr_t len, uint8_t res[STREEBOG256_RESULT_SIZE])
Хэшировать сообщение.
void ec512_private_key_drop(Ec512PrivateKey sk)
Уничтожить закрытый ключ.
MagmaOfb_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, MAGMA_OFB_NONCE_SIZE > &nonce) noexcept
Создать контекст потокового шифра.
intptr_t seek(uint64_t pos) noexcept
Установить позицию ключевого потока шифра.
Definition: gostcrypto.hpp:996
intptr_t sign(const std::vector< uint8_t > &msg, const std::array< uint8_t, EC_256_WIDTH > &rand_bytes, std::array< uint8_t, EC_256_DOUBLE_WIDTH > &signature) const noexcept
Подписать сообщение.
MagmaMac_t & operator=(const MagmaMac_t &)=default
void kuznyechik_ecb_new(KuznyechikEcb dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать контекст блочного шифра.
static Ec512PrivateKey_t< CurveID > from_bytes(const uint8_t bytes[EC_512_WIDTH], intptr_t &error_code) noexcept
Десериалировать закрытый ключ.
void finalize_reset(uint8_t res[STREEBOG256_RESULT_SIZE]) noexcept
Финализировать состояние функции хэширования и заменить его новым.
Идентификатор кривой id-tc26-gost-3410-12-512-paramSetA, заданной в Р 1323565.1.024-2019.
intptr_t ec512_dsa_sign_hash(Ec512 cid, Ec512PrivateKey sk, const uint8_t hash[EC_512_WIDTH], const uint8_t rand_bytes[EC_512_WIDTH], uint8_t signature[EC_512_DOUBLE_WIDTH])
Подписать хэш сообщения.
void kuznyechik_cfb_new(KuznyechikCfb dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[KUZNYECHIK_CFB_NONCE_SIZE])
Создать контекст потокового шифра.
void magma_cbc_new(MagmaCbc dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CBC_NONCE_SIZE])
Создать контекст блочного шифра.
Блочный шифр с длиной блока 64 бит в режиме простой замены.
void decrypt_blocks(uint8_t(*blocks)[KUZNYECHIK_BLOCK_SIZE], uintptr_t len) noexcept
Расшифровать массив блоков.
intptr_t ec256_private_key_to_bytes(Ec256 cid, Ec256PrivateKey sk, uint8_t bytes[EC_256_WIDTH])
Сериализовать закрытый ключ.
KuznyechikOfb_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, KUZNYECHIK_OFB_NONCE_SIZE > &nonce) noexcept
Создать контекст потокового шифра.
#define MAGMA_MAC_RESULT_SIZE
Длина имитовставки MagmaMac (в байтах)
Definition: gostcrypto.h:321
#define KUZNYECHIK_OFB_NONCE_SIZE
Размер синхропосылки KuznyechikOfb (в байтах)
Definition: gostcrypto.h:336
std::array< uint8_t, MAGMA_MAC_RESULT_SIZE > finalize_reset() noexcept
Финализировать состояние режима выработки имитовставки и заменить его новым.
KuznyechikCtr_t & operator=(const KuznyechikCtr_t &)=default
void streebog256_reset(Streebog256 state)
Сбросить состояние функции хэширования.
static Ec256PrivateKey_t< CurveID > from_bytes(const std::array< uint8_t, EC_256_WIDTH > &rand_bytes, intptr_t &error_code) noexcept
Десериалировать закрытый ключ.
Потоковый шифр с длиной блока 128 бит в режиме гаммирования с обратной связью по выходу с размером си...
void encrypt_block(uint8_t block[MAGMA_BLOCK_SIZE]) noexcept
Зашифровать блок данных.
Definition: gostcrypto.hpp:845
std::array< uint8_t, EC_512_WIDTH > to_bytes() const noexcept
Сериализовать закрытый ключ.
Блочный шифр с длиной блока 128 бит в режиме простой замены.
static void digest(const uint8_t *msg, uintptr_t len, uint8_t res[STREEBOG512_RESULT_SIZE]) noexcept
Хэшировать сообщение.
MagmaOfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_OFB_NONCE_SIZE]) noexcept
Создать контекст потокового шифра.
void update(const uint8_t *msg, uintptr_t len) noexcept
Обновить состояние функции хэширования.
void update(const std::vector< uint8_t > &message) noexcept
Обновить состояние режиму выработки имитовставки.
void magma_cfb_encrypt(MagmaCfb cipher, uint8_t *buf, uintptr_t buf_len)
Зашифровать сообщение.
std::array< uint8_t, EC_256_WIDTH > vko256(const Ec512PublicKey_t< CurveID > &other_pk, intptr_t &error_code) const noexcept
Выработать общий ключ.
#define MAGMA_OFB_NONCE_SIZE
Размер синхропосылки MagmaOfb (в байтах)
Definition: gostcrypto.h:351
#define GOST3410_2012_256B
Идентификатор кривой id-tc26-gost-3410-2012-256-paramSetB, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:836
MagmaCtr_t(const MagmaCtr_t &)=default
intptr_t sign_hash(const uint8_t hash[STREEBOG256_RESULT_SIZE], const uint8_t rand_bytes[EC_256_WIDTH], uint8_t signature[EC_256_DOUBLE_WIDTH]) const noexcept
Подписать хэш сообщения.
intptr_t verify_hash(const std::array< uint8_t, STREEBOG256_RESULT_SIZE > &hash, const std::array< uint8_t, EC_256_DOUBLE_WIDTH > &signature) const noexcept
Проверить подпись хэша сообщения.
#define KUZNYECHIK_CFB_NONCE_SIZE
Размер синхропосылки KuznyechikCfb (в байтах)
Definition: gostcrypto.h:69
intptr_t kuznyechik_ecb_encrypt_pad(KuznyechikEcb cipher, uint8_t *buf, uintptr_t buf_len, uintptr_t pos)
Зашифровать сообщение.
void finalize_reset(uint8_t res[MAGMA_MAC_RESULT_SIZE]) noexcept
Финализировать состояние режима выработки имитовставки и заменить его новым.
intptr_t ec512_public_key_to_bytes(Ec512 cid, Ec512PublicKey pk, uint8_t bytes[EC_512_DOUBLE_WIDTH])
Сериализовать открытый ключ.
std::array< uint8_t, EC_512_DOUBLE_WIDTH > sign(const std::vector< uint8_t > &msg, const std::array< uint8_t, EC_512_WIDTH > &rand_bytes, intptr_t &error_code) const noexcept
Подписать сообщение.
Streebog256_t() noexcept
Создать состояние функции хэширования.
void streebog512_drop(Streebog512 state)
Уничтожить состояние функции хэширования.
std::array< uint8_t, EC_512_WIDTH > vko512(const Ec512PublicKey_t< CurveID > &other_pk, intptr_t &error_code, const uint8_t ukm[EC_512_WIDTH]) const noexcept
Выработать общий ключ.
void magma_cfb_new(MagmaCfb dst, const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CFB_NONCE_SIZE])
Создать контекст потокового шифра.
MagmaCtr_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key, const std::array< uint8_t, MAGMA_CTR_NONCE_SIZE > &nonce) noexcept
Создать контекст потокового шифра.
Потоковый шифр с длиной блока 128 бит в режиме гаммирования с обратной связью по шифртексту с размеро...
Definition: gostcrypto.hpp:455
Открытый ключ эллиптических кривых.
void decrypt_blocks(uint8_t(*blocks)[MAGMA_BLOCK_SIZE], uintptr_t blocks_len) noexcept
Расшифровать массив блоков.
Definition: gostcrypto.hpp:385
~KuznyechikCfb_t() noexcept
Definition: gostcrypto.hpp:495
KuznyechikEcb_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
Создать контекст блочного шифра.
Функция хэширования с длиной хэш-кода 256 бит.
uint64_t get_pos() const noexcept
Получить позицию ключевого потока шифра.
Kuznyechik_t & operator=(const Kuznyechik_t &)=default
KuznyechikMac_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать состояние режима выработки имитовставки.
void decrypt(std::vector< uint8_t > &buf) noexcept
Расшифровать сообщение.
Definition: gostcrypto.hpp:549
intptr_t kuznyechik_ecb_decrypt_pad(KuznyechikEcb cipher, uint8_t *buf, uintptr_t buf_len)
Расшифровать сообщение.
void kuznyechik_mac_update(KuznyechikMac state, const uint8_t *msg, uintptr_t len)
Обновить состояние режиму выработки имитовставки.
Потоковый шифр с длиной блока 64 бит в режиме гаммирования с обратной связью по шифртексту с размером...
Definition: gostcrypto.hpp:569
#define MAGMA_BLOCK_SIZE
Размер блока Magma (в байтах)
Definition: gostcrypto.h:114
void magma_encrypt_blocks(Magma cipher, uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t len)
Зашифровать массив блоков.
void apply_keystream(std::vector< uint8_t > &buf) noexcept
Гаммировать сообщение ключевым потоком шифра.
MagmaOfb_t(const MagmaOfb_t &)=default
uint8_t KuznyechikMac[KUZNYECHIK_MAC_SIZE]
Режим выработки имитовставки с использованием шифра с длиной блока 128 бит.
Definition: gostcrypto.h:766
std::array< uint8_t, STREEBOG256_RESULT_SIZE > finalize_reset() noexcept
Финализировать состояние функции хэширования и заменить его новым.
void update(const std::vector< uint8_t > &message) noexcept
Обновить состояние режиму выработки имитовставки.
void apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
Гаммировать сообщение ключевым потоком шифра.
Magma_t(const Magma_t &)=default
void decrypt_blocks(uint8_t(*blocks)[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
Расшифровать массив блоков.
void streebog256_new(Streebog256 dst)
Создать состояние функции хэширования.
void apply_keystream(uint8_t *buf, uintptr_t buf_len) noexcept
Гаммировать сообщение ключевым потоком шифра.
~KuznyechikCtr_t() noexcept
Definition: gostcrypto.hpp:948
Идентификатор кривой id-tc26-gost-3410-2012-256-paramSetD, заданной в Р 1323565.1.024-2019.
void magma_mac_reset(MagmaMac state)
Сбросить состояние режима выработки имитовставки.
void magma_ecb_encrypt_blocks(MagmaEcb cipher, uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t blocks_len)
Зашифровать массив блоков.
intptr_t ec512_dsa_verify(Ec512 cid, Ec512PublicKey pk, const uint8_t *msg, uintptr_t msg_len, const uint8_t signature[EC_512_DOUBLE_WIDTH])
Проверить подпись сообщения.
void magma_mac_drop(MagmaMac state)
Уничтожить состояние режима выработки имитовставки.
intptr_t encrypt_pad(uint8_t *buf, uintptr_t buf_len, uintptr_t pos) const noexcept
Зашифровать сообщение.
Definition: gostcrypto.hpp:266
void kuznyechik_ctr_drop(KuznyechikCtr cipher)
Уничтожить контекст шифра.
void streebog256_drop(Streebog256 state)
Уничтожить состояние функции хэширования.
void magma_ofb_drop(MagmaOfb cipher)
Уничтожить контекст шифра.
#define GOST3410_2012_256D
Идентификатор кривой id-tc26-gost-3410-2012-256-paramSetD, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:846
Функция хэширования с длиной хэш-кода 512 бит.
void kuznyechik_new(Kuznyechik dst, const uint8_t key[SYMMETRIC_KEY_SIZE])
Создать контекст блочного шифра.
KuznyechikCfb_t(const KuznyechikCfb_t &)=default
MagmaCfb_t(const MagmaCfb_t &)=default
uint8_t Ec512PrivateKey[EC_512_WIDTH]
Несериализованный закрытый ключ кривых Ec512 длиной EC_512_WIDTH и выравниванием EC_512_PRIVATE_KEY_A...
Definition: gostcrypto.h:695
void finalize(uint8_t res[KUZNYECHIK_MAC_RESULT_SIZE]) const noexcept
Финализировать состояние режима выработки имитовставки.
void magma_cbc_decrypt_blocks(MagmaCbc cipher, uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t blocks_len)
Расшифровать массив блоков.
bool verify(const std::array< uint8_t, KUZNYECHIK_MAC_RESULT_SIZE > &code) const noexcept
Проверить целостность данных.
intptr_t ec256_dsa_sign(Ec256 cid, Ec256PrivateKey sk, const uint8_t *msg, uintptr_t msg_len, const uint8_t rand_bytes[EC_256_WIDTH], uint8_t signature[EC_256_DOUBLE_WIDTH])
Подписать сообщение.
intptr_t ec256_public_key_to_bytes(Ec256 cid, Ec256PublicKey pk, uint8_t bytes[EC_256_DOUBLE_WIDTH])
Сериализовать открытый ключ.
void kuznyechik_ecb_decrypt_blocks(KuznyechikEcb cipher, uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len)
Расшифровать массив блоков.
intptr_t decrypt(const uint8_t nonce[KUZNYECHIK_MGM_NONCE_SIZE], const uint8_t *aad, uintptr_t aad_len, uint8_t *buf, uintptr_t buf_len, const uint8_t tag[KUZNYECHIK_MGM_TAG_SIZE]) const noexcept
Расшифровать сообщение с присоединёнными данными.
Definition: gostcrypto.hpp:114
static std::array< uint8_t, STREEBOG512_RESULT_SIZE > digest(const uint8_t *msg, uintptr_t len) noexcept
Хэшировать сообщение.
uint8_t KuznyechikMgm[KUZNYECHIK_MGM_SIZE]
Блочный шифр с длиной блока 128 бит в режиме работы блочных шифров, реализующим аутентифицирующее шиф...
Definition: gostcrypto.h:382
uint8_t KuznyechikOfb[KUZNYECHIK_OFB_SIZE]
Потоковый шифр с длиной блока 128 бит в режиме гаммирования с обратной связью по выходу с размером си...
Definition: gostcrypto.h:807
intptr_t ec512_vko512(Ec512 cid, Ec512PrivateKey sk, Ec512PublicKey pk, const uint8_t ukm[EC_512_WIDTH], uint8_t out[EC_512_WIDTH])
Выработать общий ключ.
void magma_cbc_encrypt_blocks(MagmaCbc cipher, uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t blocks_len)
Зашифровать массив блоков.
intptr_t ec256_vko256(Ec256 cid, Ec256PrivateKey sk, Ec256PublicKey pk, const uint8_t ukm[EC_256_WIDTH], uint8_t out[EC_256_WIDTH])
Выработать общий ключ.
Magma_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:825
#define GOST3410_2012_256C
Идентификатор кривой id-tc26-gost-3410-2012-256-paramSetC, заданной в Р 1323565.1.024-2019.
Definition: gostcrypto.h:841
std::array< uint8_t, EC_256_WIDTH > vko256(const Ec256PublicKey_t< CurveID > &other_pk, intptr_t &error_code) const noexcept
Выработать общий ключ.
#define EC_256_WIDTH
Длина закрытого ключа и хэша сообщения кривых Ec256 (в байтах)
Definition: gostcrypto.h:179
intptr_t seek(uint64_t pos) noexcept
Установить позицию ключевого потока шифра.
Библиотека криптографических алгоритмов ГОСТ.
uint8_t MagmaCfb[MAGMA_CFB_SIZE]
Потоковый шифр с длиной блока 64 бит в режиме гаммирования с обратной связью по шифртексту с размером...
Definition: gostcrypto.h:468
void update(const uint8_t *msg, uintptr_t len) noexcept
Обновить состояние режиму выработки имитовставки.
Ec512PublicKey_t< CurveID > & operator=(const Ec512PublicKey_t< CurveID > &)=default
static void digest(const uint8_t *msg, uintptr_t len, uint8_t res[STREEBOG256_RESULT_SIZE]) noexcept
Хэшировать сообщение.
KuznyechikEcb_t & operator=(const KuznyechikEcb_t &)=default
~MagmaEcb_t() noexcept
std::array< uint8_t, KUZNYECHIK_MAC_RESULT_SIZE > finalize() const noexcept
Финализировать состояние режима выработки имитовставки.
void kuznyechik_cbc_decrypt_blocks(KuznyechikCbc cipher, uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t blocks_len)
Расшифровать массив блоков.
MagmaCbc_t(const MagmaCbc_t &)=default
uint8_t Ec256PrivateKey[EC_256_WIDTH]
Несериализованный закрытый ключ кривых Ec256 длиной EC_256_WIDTH и выравниванием EC_256_PRIVATE_KEY_A...
Definition: gostcrypto.h:640
Magma_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:812
KuznyechikMgm_t(const std::array< uint8_t, SYMMETRIC_KEY_SIZE > &key) noexcept
Создать контекст AEAD.
Definition: gostcrypto.hpp:42
MagmaCfb_t(const uint8_t key[SYMMETRIC_KEY_SIZE], const uint8_t nonce[MAGMA_CFB_NONCE_SIZE]) noexcept
Создать контекст потокового шифра.
Definition: gostcrypto.hpp:588
void finalize(uint8_t res[MAGMA_MAC_RESULT_SIZE]) const noexcept
Финализировать состояние режима выработки имитовставки.
void kuznyechik_decrypt_blocks(Kuznyechik cipher, uint8_t blocks[KUZNYECHIK_BLOCK_SIZE], uintptr_t len)
Расшифровать массив блоков.
Режим выработки имитовставки с использованием шифра с длиной блока 128 бит.
~Magma_t() noexcept
Definition: gostcrypto.hpp:831
KuznyechikMac_t(const KuznyechikMac_t &)=default
Kuznyechik_t(const uint8_t key[SYMMETRIC_KEY_SIZE]) noexcept
Создать контекст блочного шифра.
Definition: gostcrypto.hpp:699
void ec256_private_key_drop(Ec256PrivateKey sk)
Уничтожить закрытый ключ.
intptr_t verify_hash(const std::array< uint8_t, STREEBOG512_RESULT_SIZE > &hash, const std::array< uint8_t, EC_512_DOUBLE_WIDTH > &signature) const noexcept
Проверить подпись хэша сообщения.
bool verify(const uint8_t code[MAGMA_MAC_RESULT_SIZE]) const noexcept
Проверить целостность данных.
void magma_cfb_decrypt(MagmaCfb cipher, uint8_t *buf, uintptr_t buf_len)
Расшифровать сообщение.
Ec512PublicKey_t< CurveID > get_public_key() const noexcept
Получить открытый ключ.
std::array< uint8_t, KUZNYECHIK_MAC_RESULT_SIZE > finalize_reset() noexcept
Финализировать состояние режима выработки имитовставки и заменить его новым.
void encrypt_blocks(uint8_t blocks[MAGMA_BLOCK_SIZE], uintptr_t len) noexcept
Зашифровать массив блоков.
Definition: gostcrypto.hpp:874
intptr_t encrypt(const std::array< uint8_t, KUZNYECHIK_MGM_NONCE_SIZE > &nonce, const std::vector< uint8_t > &aad, std::vector< uint8_t > &buf, std::array< uint8_t, KUZNYECHIK_MGM_TAG_SIZE > &tag) const noexcept
Зашифровать сообщение с присоединёнными данными.
Definition: gostcrypto.hpp:88
std::array< uint8_t, EC_512_WIDTH > vko512(const Ec512PublicKey_t< CurveID > &other_pk, intptr_t &error_code) const noexcept
Выработать общий ключ.
void finalize(uint8_t res[STREEBOG512_RESULT_SIZE]) const noexcept
Финализировать состояние функции хэширования.