Ещё лучше

можно вопрос? а то я запутался

Rijndael это AES или нет?
дело в том, что я релизовал Rijndael зная что он AES, но я сейчас пересмотрел, оказывается есть отдельный AES

как это понять?

Wiki говорит, что это одно и тоже

На самом деле не совсем

Aes это подмножество rijndael, где зафиксирован размер блока и 3 варианта размера ключей

Если в плане конкретно алгоритма то одно и то же

добрый день. пытаюсь реализовать протокол гост, но уже второй день не могу понять в чем трабла.

#define HIGHT_LIMIT 4294967296ULL
uint64_t crypted_block(uint64_t block){
    for (register int i = 0; i < 32; i++){
        uint32_t first_block = block >> 32;
        uint32_t second_block = block & 0xFFFFFFFF;
        
        uint32_t cur_key = key[i < 24 ? i % 8: 7-i%8];
        
        uint32_t smod = (first_block + cur_key) % HIGHT_LIMIT;

        print_binary_code(smod);

        uint8_t block1_2 = (smod & 0xFF);
        uint8_t block3_4 = (smod & 0xFF00)>>8;
        uint8_t block5_6 = (smod & 0xFF0000)>>16;
        uint8_t block7_8 = (smod & 0xFF000000)>>24;

        print_binary_code(block1_2);
        print_binary_code(block3_4);
        print_binary_code(block5_6);
        print_binary_code(block7_8);

        uint32_t t_swap = 0;
        t_swap |= table[0][block1_2 & 0x0F];
        t_swap |= table[1][block1_2 >> 4] << 4;
        t_swap |= table[2][block3_4 & 0x0F] << 8;
        t_swap |= table[3][block3_4 >> 4] << 12;
        t_swap |= table[4][block5_6 & 0x0F] << 16;
        t_swap |= table[5][block5_6 >> 4] << 20;
        t_swap |= table[6][block7_8 & 0x0F] << 24;
        t_swap |= table[7][block7_8 >> 4] << 28;

        print_binary_code(t_swap);

        t_swap=(t_swap<<11) | (t_swap >> 21);
        
        print_binary_code(t_swap);

        uint32_t sum = t_swap ^ second_block;
        block = ((uint64_t)sum<<32) | first_block;
    }

    printf("return in crypt: %ld\n", block);
    return block;
}

uint64_t uncrypted_block(uint64_t block){
    for (register int i = 0; i < 32; i++){
        uint32_t first_block = block >> 32;
        uint32_t second_block = block & 0xFFFFFFFF;
        
        uint32_t cur_key = key[i < 8 ? i : 7 - i%8];
        
        uint32_t smod = (first_block + cur_key) % HIGHT_LIMIT;

        uint8_t block1_2 = (smod & 0xFF);
        uint8_t block3_4 = (smod & 0xFF00)>>8;
        uint8_t block5_6 = (smod & 0xFF0000)>>16;
        uint8_t block7_8 = (smod & 0xFF000000)>>24;

        uint32_t t_swap = 0;
        t_swap |= table[0][block1_2 & 0x0F];
        t_swap |= table[1][block1_2 >> 4] << 4;
        t_swap |= table[2][block3_4 & 0x0F] << 8;
        t_swap |= table[3][block3_4 >> 4] << 12;
        t_swap |= table[4][block5_6 & 0x0F] << 16;
        t_swap |= table[5][block5_6 >> 4] << 20;
        t_swap |= table[6][block7_8 & 0x0F] << 24;
        t_swap |= table[7][block7_8 >> 4] << 28;

        t_swap = (t_swap << 11) | (t_swap >> 21);

        uint32_t sum = t_swap ^ second_block;
        block = ((uint64_t)sum<<32) | first_block;
    }

    printf("return in uncrypt: %ld\n", block);
    return block;
}

если кто заметит в коде ошибку, подскажите. протокол гост 28147-89
print_binary_code - там просто для вывода, поэтому забейте на него. вручную проверил один цикл шифрования, вроде все правильно, но расшифровываться не хочет

static uint8_t table[8][16] = {
    { 0xc, 0x4, 0x6, 0x2, 0xa, 0x5, 0xb, 0x9, 0xe, 0x8, 0xd, 0x7, 0x0, 0x3, 0xf, 0x1 },
    { 0x6, 0x8, 0x2, 0x3, 0x9, 0xa, 0x5, 0xc, 0x1, 0xe, 0x4, 0x7, 0xb, 0xd, 0x0, 0xf },
    { 0xb, 0x3, 0x5, 0x8, 0x2, 0xf, 0xa, 0xd, 0xe, 0x1, 0x7, 0x4, 0xc, 0x9, 0x6, 0x0 },
    { 0xc, 0x8, 0x2, 0x1, 0xd, 0x4, 0xf, 0x6, 0x7, 0x0, 0xa, 0x5, 0x3, 0xe, 0x9, 0xb },
    { 0x7, 0xf, 0x5, 0xa, 0x8, 0x1, 0x6, 0xd, 0x0, 0x9, 0x3, 0xe, 0xb, 0x4, 0x2, 0xc },
    { 0x5, 0xd, 0xf, 0x6, 0x9, 0x2, 0xc, 0xa, 0xb, 0x7, 0x8, 0x1, 0x4, 0x3, 0xe, 0x0 },
    { 0x8, 0xe, 0x2, 0x5, 0x6, 0x9, 0x1, 0xc, 0xf, 0x4, 0xb, 0x0, 0xd, 0xa, 0x3, 0x7 },
    { 0x1, 0x7, 0xe, 0xd, 0x0, 0x5, 0x8, 0x3, 0x4, 0xf, 0xa, 0x6, 0x9, 0xc, 0xb, 0x2 }
};   
static uint32_t key[8];

вот два массива, которые дополнительно юзаются. таблица замен и ключ шифрования

я бы вашу конструкцию так переписал:

static uint8_t index_key_e[32]=
{0,1,2,3,4,5,6,7, 0,1,2,3,4,5,6,7, 0,1,2,3,4,5,6,7, 7,6,5,4,3,2,1,0};

static uint8_t index_key_d[32]=
{0,1,2,3,4,5,6,7, 7,6,5,4,3,2,1,0, 7,6,5,4,3,2,1,0 ,7,6,5,4,3,2,1,0};

static __inline uint32_t
_F(uint32_t x)
{
  x = table[7][x>>28 & 15] << 28 | table[6][x>>24 & 15] << 24 |
      table[5][x>>20 & 15] << 20 | table[4][x>>16 & 15] << 16 |
      table[3][x>>12 & 15] << 12 | table[2][x>> 8 & 15] <<  8 |
      table[1][x>> 4 & 15] <<  4 | table[0][x     & 15];

  return x<<11 | x>>(32-11);
}

uint64_t
crypted_block(uint64_t block)
{
int i;
uint32_t first_block;
uint32_t second_block;

   first_block  = block >> 32;
   second_block = block;

   for (i = 0; i < 32; i+=2)
   {
       second_block ^= _F(first_block  + key[index_key_e[i+0]]);
       first_block  ^= _F(second_block + key[index_key_e[i+1]]);
   }

   return ((uint64_t)second_block<<32) | first_block;
}

uint64_t uncrypted_block(uint64_t block)
{
int i;
uint32_t first_block;
uint32_t second_block;

   first_block  = block >> 32;
   second_block = block;

   for (i = 0; i < 32; i+=2)
   {
       second_block ^= _F(first_block  + key[index_key_d[i+0]]);
       first_block  ^= _F(second_block + key[index_key_d[i+1]]);
   }

   return ((uint64_t)second_block<<32) | first_block;
}


void
main(void)
{
uint64_t a=1;
uint64_t b,c;

  b =crypted_block(a);
  c =uncrypted_block(b);

  printf("%016I64X %016I64X %016I64X\n",a,b,c);

}

спасибо.  сейчас чекну где разница. для начала нужна была простая наглядности, а код улучшил бы после

лично у меня сложилось впечатление, что у вас неверно ключи выбираются

хотя, то что предложил, это упрощенный ваш вариант

DI, попробуй так. Да мне тоже показалось, что индексы в расшифровке не правильно получаются.
uint64_t uncrypted_block(uint64_t block){
 uint32_t tmp;
   for (register int i = 0; i < ROUNDS; i++){
       uint32_t first_block = block >> 32;
       uint32_t second_block = block & 0xFFFFFFFF;
       /*Swap*/
   tmp = first_block; first_block=second_block; second_block = tmp;
       uint32_t cur_key = key[i < 8 ? i : 7 - i%8];
       
       uint32_t smod = (first_block + cur_key) % HIGHT_LIMIT;

       uint8_t block1_2 = (smod & 0xFF);
       uint8_t block3_4 = (smod & 0xFF00)>>8;
       uint8_t block5_6 = (smod & 0xFF0000)>>16;
       uint8_t block7_8 = (smod & 0xFF000000)>>24;

       uint32_t t_swap = 0;
       t_swap |= table[0][block1_2 & 0x0F];
       t_swap |= table[1][block1_2 >> 4] << 4;
       t_swap |= table[2][block3_4 & 0x0F] << 8;
       t_swap |= table[3][block3_4 >> 4] << 12;
       t_swap |= table[4][block5_6 & 0x0F] << 16;
       t_swap |= table[5][block5_6 >> 4] << 20;
       t_swap |= table[6][block7_8 & 0x0F] << 24;
       t_swap |= table[7][block7_8 >> 4] << 28;

       t_swap = (t_swap << 11) | (t_swap >> 21);

       uint32_t sum = t_swap ^ second_block;
   /*Swap*/
   tmp = sum; sum=first_block; first_block = tmp;
       block = (((uint64_t)sum)<<32) | first_block;
   }

   printf("return in uncrypt: %" PRIu64 "\n", block);
   return block;
}

Должно расшифровывать. Но нужно будет сверить зашифрованные данные с заведомо рабочим шифровальщиком на ГОСТ.

да, вы правы. видимо в подборке ключей ошибка вышла) спасибо большое

проход по ключам, лучше не вычислять, а использовать таблицу, как у меня в примере, удобней будет