Leitura de arquivos para algoritmo de Criptografia Leve Simon

Muril02
(usa XUbuntu)

Enviado em 20/06/2017 - 23:41h

Boa noite a todos, gostaria de pedir ajuda num trabalho que eu tenho que fazer para a disciplina de Sistemas Operacionais. No caso, o líder do meu grupo é um aluno da pós que escolheu o tema Criptografia Leve Simon. Ele nos forneceu o código de como funciona essa criptografia para 64bits e nos disse que teríamos que criar um arquivo txt de 100mb para ser lido por esse algoritmo. Portanto a gente tem que dividir esse arquivo txt em trechos de 64bits pra que o algoritmo funcione. O algoritmo em si recebe no vetor text64[2] os 64bits do arquivo txt, metade na posição text64[0] e a outra metade (32bits) na posição text64[1]. Portanto o orientador sugeriu que eu lesse 4 caracteres do arquivo txt e armazenasse na posição text64[0] e mais 4 caracteres e armazenasse na posição text64[1], realizando a criptografia e fizesse isso sucessivamente dentro de um laço até que o arquivo txt inteiro tenha sido criptografado.
Para tanto eu pensei em usar a função fread (void *buffer, int numero_de_bytes, int count, FILE *fp); , onde o número total de bytes lido vai ser numero_de_bytes*count, assim é só fazer numero_de_bytes = 4 e count = 1 pra ler 4 bytes (32bits). Só que aí eu não consigo armazenar 4 caracteres em uma posição só da string, então eu acredito que devo ter que converter essa string para hexadecimal pra que o código funcione. Estou tendo muitas dúvidas sobre como prosseguir e gostaria da ajuda de vocês, abaixo segue o código que ele nos disponibilizou onde o algoritmo funciona com um caso teste (valores hexadecimais já definidos pra text64[0] e text64[1]):

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <omp.h>



static uint8_t z[62] =

{1,1,0,1,1,0,1,1,1,0,1,0,1,1,0,0,0,1,1,0,0,1,0,1,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,1,1,0,1,0,0,0,0,1,1,1,1};



#define ROTATE_LEFT_64(x,bits) ( (x << bits) | ((x & 0xffffffffffff) >> (64-bits)) )

#define ROTATE_RIGHT_64(x,bits) ( ((x & 0xffffffffffff) >> bits) | (x << (64-bits)) )



void KeyExpansion64 (uint64_t k[], uint8_t m, uint8_t T)

{

    uint8_t i;

    uint64_t tmp;

   // #pragma omp parallel for private(i,tmp)

    for (i = m; i<T; i++)

    {

        tmp = ROTATE_RIGHT_64(k[i-1],3);

        if(m == 4)

			tmp = tmp ^ k[i-3];

		tmp = tmp ^ ROTATE_RIGHT_64(tmp,1);

        k[i] = ~k[i-m] ^ tmp ^ z[i-m] ^ 3;

    }

}



void Encrypt64 (uint64_t text[], uint64_t crypt[], uint64_t key[], uint8_t T)

{

    uint8_t i;

    uint64_t tmp;

    crypt[0] = text[0];

    crypt[1] = text[1];



   // #pragma omp parallel for private(i,tmp)

    for (i = 0 ; i<T ; i++)

    {

        tmp = crypt[0];

        crypt[0] = crypt[1] ^ ((ROTATE_LEFT_64(crypt[0],1)) & (ROTATE_LEFT_64(crypt[0],8))) ^ (ROTATE_LEFT_64(crypt[0],2)) ^ key[i];

        crypt[1] = tmp;

    }

    printf("ENC 64:\nPT %lx %lx\nCRYPT %lx %lx\n\n\n", text[0], text[1], crypt[0], crypt[1]);

}



void Decrypt64 (uint64_t text[], uint64_t decrypt[], uint64_t key[], uint8_t T)

{

    uint8_t i, sizek;

    uint64_t tmp;

    decrypt[0] = text[0];

    decrypt[1] = text[1];

    sizek = T-1;



   // #pragma omp parallel for private(i,tmp,T)

    for (i = 0 ;i<T ; i++)

    {

        tmp = decrypt[1];

        decrypt[1] = decrypt[0] ^ ((ROTATE_LEFT_64(decrypt[1],1)) & (ROTATE_LEFT_64(decrypt[1],8))) ^ (ROTATE_LEFT_64(decrypt[1],2)) ^ key[sizek-i];

        decrypt[0] = tmp;

    }

    printf("CRIPT %lx %lx\nDECRIPT %lx %lx\n\n\n", text[0], text[1], decrypt[0], decrypt[1]);

}

int main ()

{

	//n = tamanho da palavra (se 16 m = 4, se 24 m = 3 ou 4 , se 32 m = 3 ou 4, se 48 m = 2 ou 3 ou se 64 m = 2, 3 ou 4) | m = numero de palavras-chaves

	uint8_t m = 4, n = 32, rounds;

	uint64_t crypt48[2] = {0};

	uint64_t crypt64[2] = {0};



					if (m == 2)

						rounds = 68;

					if (m == 3)

						rounds = 69;

					if (m == 4)

						rounds = 72;

					//vetor texto plano

					uint64_t text64[2];

					//key

					uint64_t key64[rounds];





					text64[0] = 0x6373656420737265; text64[1] = 0x6c6c657661727420;



					key64[3] = 0x131211106c6c657b; key64[2] = 0x348f38a198e547b2; key64[1] = 0x0f0e0d0c0b0a0908; key64[0] = 0x0706050403020100;



					//Encryption

					KeyExpansion64 (key64,m,rounds);

					Encrypt64 (text64,crypt64,key64,rounds);



					//Decryption

					Decrypt64(crypt64,text64,key64,rounds);



}

 

removido
(usa Nenhuma)

Enviado em 21/06/2017 - 00:30h

Estou fazendo umas pesquisas para entender melhor.

http://calhau.dca.fee.unicamp.br/wiki/images/8/84/Algoritmos_de_Criptografia_Leve_v1.pdf
http://aberto.univem.edu.br/bitstream/handle/11077/1578/TCC_Final_Claudio.pdf?sequence=1

Tem alguma S-Box? z[62] é sua S-Box?

----------------------------------------------------------------------------------------------------------------
Nem direita, nem esquerda. Quando se trata de corrupção o Brasil é ambidestro.
(anônimo)