стандарт шифрования AES

__host__ void h_generateCipherKey128( uchar4 *result, uint64_t block1, uint64_t block2 )
{
    for (int i = 0; i < 2; ++i) {
        result[i + 0].x = (block1 >> (56 - 32*i)) & 0xFF;
        result[i + 0].y = (block1 >> (48 - 32*i)) & 0xFF;
        result[i + 0].z = (block1 >> (40 - 32*i)) & 0xFF;
        result[i + 0].w = (block1 >> (32 - 32*i)) & 0xFF;
        
        result[i + 2].x = (block2 >> (56 - 32*i)) & 0xFF;
        result[i + 2].y = (block2 >> (48 - 32*i)) & 0xFF;
        result[i + 2].z = (block2 >> (40 - 32*i)) & 0xFF;
        result[i + 2].w = (block2 >> (32 - 32*i)) & 0xFF;
    }
}
 
__host__ /*inline*/ uchar4 * d_generateCipherKey128( uint64_t block1, uint64_t block2 )
{
    uchar4 *d_cipher_key;
    uchar4 *h_cipher_key = (uchar4 *) malloc(4 * sizeof(uchar4));
    
    // Создает ключ шифрования на хосте из двух блоков uint64_t
    h_generateCipherKey128(h_cipher_key, block1, block2);
    
    // Выделяет память для ключа шифрования устройства, копирование хозяина к ней
    cudaMalloc((void **) &d_cipher_key,    4 * sizeof(uchar4));
    cudaMemcpy(d_cipher_key, h_cipher_key, 4 * sizeof(uchar4), cudaMemcpyHostToDevice);
    
    // Освобождает память, используемая для временного ключа шифра принимающей
    free(h_cipher_key);
    
    return d_cipher_key;
}
__host__ void nouveau128( int argc, char *argv[] ) {
    uchar4 *h_round_keys;
    uchar4 *d_cipher_key, *d_round_keys;
    uint8_t *d_sbox, *d_inv_sbox;
    char *h_file;
    char *d_file;
    size_t file_size;
    char fname[80],fname1[80], fname2[80];
    
    // Создание 128-битный шифр-ключ из двух uint64_t
    d_cipher_key = d_generateCipherKey128( 0x95A8EE8E89979B9E, 0xFDCBC6EB9797528D );
    printf("Enter src file name: ");
    gets_s(fname);
    
    // Загружает файл с диска
    file_size = loadFileIntoMemory(&h_file, fname);
    
    // Выделяет память для различных ресурсов
    h_round_keys = (uchar4 *) malloc(11 * 4 * sizeof(uchar4));
    cudaMalloc((void **) &d_round_keys, 11 * 4 * sizeof(uchar4));
    cudaMalloc((void **) &d_sbox, 256 * sizeof(uint8_t));
    cudaMalloc((void **) &d_inv_sbox, 256 * sizeof(uint8_t));
    cudaMalloc((void **) &d_file, file_size * sizeof(char));
    
    // Копии памяти на устройстве
    cudaMemcpy(d_sbox, s_box, 256 * sizeof(uint8_t), cudaMemcpyHostToDevice);
    cudaMemcpy(d_inv_sbox, inv_s_box, 256 * sizeof(uint8_t), cudaMemcpyHostToDevice);
    cudaMemcpy(d_file, h_file, file_size * sizeof(char), cudaMemcpyHostToDevice);
    
    
    // Создает вокруг ключи, сохраняя их на глобальной памяти
    d_round_keys = d_expandKey128( d_cipher_key, d_sbox );
 
    
    // Шифрование файлов
    h_file = encryptHostToHost128(h_file, file_size, d_sbox, d_round_keys);
    printf("Enter dst file name: ");
    gets_s(fname1);
    //Записывает зашифрованный файл на диске
    writeToFile(h_file, fname1, file_size);
    
    
    // Расшифровка файлов
    h_file = decryptHostToHost128(h_file, file_size, d_inv_sbox, d_round_keys);
    printf("Enter res file name: ");
    gets_s(fname2);
    //Пишет расшифрованный файл на диск
    writeToFile(h_file, fname2, file_size);
    
    
    // Освобождает память, которая больше не используется
    free(h_round_keys);
    free(h_file);
    cudaFree(d_cipher_key);
    cudaFree(d_round_keys);
    cudaFree(d_inv_sbox);
    cudaFree(d_sbox);
    cudaFree(d_file);
}