Fermat Encoding in S-Box for Secured Encryption

Step 1: Take an 8x8 matrix as ‘A’ and an 8X1 matrix as ‘b’

Step 2: Calculate 256 distinct values using the formula 1S(x)=Ax+b

Step 3: Make a S-box with the 256 distinct values obtained.

Encryption of S-Box (Sbox)

Step 1: Take all the values from the S-box {S(0) … S(255)}

Step 2: Perform S(0)′=S(0)⊕S(1)S(1)′=S(1)⊕S(2)S(2)′=S(2)⊕S(3)……S(255)′=S(255)⊕S(0)′ where ⊕ is the tensor product [14].

Step 3: Generate Sbox′ with the 256 values.

Step 4: Obtain the cipher text using Fermat encoding to generate a new encrypted S-box (Sbox′) .

Decryption of the S-Box

Step 1: Calculate the values of S-box values forward with the help of Fermat numbers and calculate the values of the S-Box from S(0)′ to S(255)′

Step 2: Make a decrypted S-box with the values.

Step 3: Calculate the values of the S(0) to S(255) with the the help of XOR operation S(255)=S(255)′⊕S(0)′S(254)=S(254)′⊕S(255)′S(253)=S(253)′⊕S(254)′……S(0)=S(0)′⊕S(1)′

Step 4: After this step, make a value of S(0) to S(255) and get the decrypted S-box again.

AES is a symmetric key where a single private key is used for both the encryption and decryption processes. But here, the AES is so designed that it becomes asymmetric, and the encrypted S-box is used as a public key.

The flow diagram of Encryption and Decryption of the S-box is shown in Figure 1 and Figure 2 respectively.

Figure 1.

Encryption of the S-box

Figure 2.

Decryption of the S-box

Flow Diagram:

 void print_bigger_matrix(int matrix[ROWS_16][COLS_16][BITS], const char *filename) { FILE *file = fopen(filename, “w”);

                      if (file == NULL) {

                      printf(“Error opening file.\n”);

                      return; }

fprintf(file, “[“);

for (int i = 0; i < ROWS_16; i++) {

  for (int j = 0; j < COLS_16; j++) {

    fprintf(file, ““);

    for (int k = 0; k < 8; k++) {

      fprintf(file, “%d”, matrix[i][j][k]); }

    fprintf(file, “, “); }

  fprintf(file, “\n”); }

fprintf(file, “]”);

fclose(file);}

void cartesian_product(int sets[][SET_SIZE], int result[][NUM_SETS]) {

  int index[NUM_SETS] = {0};

  int total_elements = 1;

  for (int i = 0; i < NUM_SETS; ++i) {

    total_elements *= SET_SIZE; }

  for (int i = 0; i < total_elements; ++i) {

    for (int j = 0; j < NUM_SETS; ++j) {

      result[i][j] = sets[j][index[j]];}

    for (int j = NUM_SETS - 1; j >= 0; --j) {

      if (index[j] == SET_SIZE - 1) {

        index[j] = 0;

  } else {

      index[j]++;

      break; } } } }

void convert_to_3D(int matrix[256][8], int result[16][16][8]) {

  for (int i = 0; i < 256; i++) {

    int row = i / 16;

    int col = i % 16;

    for (int j = 0; j < 8; j++) {

      result[row][col][j] = matrix[i][j]; } } }

void xor(int mat1[8][1], int mat2[8][1], int res[8][1]){

  for (int i = 0; i < 8; i++){

    res[i][1] = mat1[i][1] ^ mat2[i][1]; } }

ENCRYPTION

printf(“Enter the numbers separated by spaces:\n”);

for (int i = 0; i < NUM_SETS; ++i) {

    for (int j = 0; j < SET_SIZE; ++j) {

      scanf(“%d”, &sets[i][j]); } }

      cartesian_product(sets, binary_matrix);

      int A[8][8] = {

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

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

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

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

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

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

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

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

      };

      //transpose_row(binary_matrix, b_matrix);

      int B[8][1] = {

        {1},

        {1},

        {0},

        {0},

        {0},

        {1},

        {1},

        {0}

      };

FILE *encryption_debug = fopen(“Encryption_debug.txt”, “w”);

  int decimal = 0;

  for (int index = 0; index <=255; index++){

    fprintf(encryption_debug, “index %d\n”, decimal);

        decimal_to_binary(decimal, x_matrix);

        fprintf(encryption_debug, “X matrix\n”);

    for (int i = 0; i < 8; i++){

      fprintf(encryption_debug, “%d “, x_matrix[i][1]); }

      fprintf(encryption_debug, “\n”);

      matrix_multiply(A, x_matrix, a_x);

      fprintf(encryption_debug, “Ax\n”);

       for (int i = 0; i < 8; i++){

        fprintf(encryption_debug, “%d “, a_x[i][1]); }

      fprintf(encryption_debug, “\n”);

      xor(a_x, B, output_matrix);

       fprintf(encryption_debug, “Ax+B\n”);

  for (int i = 0; i < 8; i++){

    fprintf(encryption_debug, “%d “, output_matrix[i][1]);

    resultant_matrix[index][i] = output_matrix[i][1]; }

      fprintf(encryption_debug, “\n”);

      decimal++; }

  fprintf(encryption_debug, “\n”);

      fprintf(encryption_debug, “Ax+B\n”);

  for (int i = 0; i < 256; i++){

      for (int j = 0; j < 8; j++){

    fprintf(encryption_debug, “%d “, resultant_matrix[i][j]); }

        fprintf(encryption_debug, “\n”); }

  fprintf(encryption_debug, “\nS Box\n”);

  convert_to_3D(resultant_matrix, s_box);

    for (int i = 0; i < 16; i++){

      for (int j = 0; j < 16; j++){

      fprintf(encryption_debug, ““);

          for (int k = 0; k < 8; k++){

  fprintf(encryption_debug, “%d”, s_box[i][j][k]); }

          fprintf(encryption_debug, “,”); }

      fprintf(encryption_debug, “\n”); }

      print_bigger_matrix(s_box, “b_sbox.txt”);

      fclose(encryption_debug);

      fflush(encryption_debug);

      //print_bigger_matrix(s_box, “b_sbox1.txt”);

      for (int i = 0; i < ROWS_16; i++) {

        for (int j = 0; j < COLS_16; j++) {

          for (int k = 0; k < BITS; k++) {

           int s_0[8];

           int xor_val;

           if (i==0 && j==0){

            xor_val = s_box[i][j][k] ^ s_box[i][j+1][k];

            s_0[k] = xor_val;

            s_box_f[i][j][k] = xor_val; }

           else if (i==15 && j==15){

            xor_val = s_0[k] ^ s_box[i][j][k];

            s_box_f[15][15][k] = xor_val; }

           else{

            s_box_f[i][j][k] = s_box[i][j][k] ^ s_box[i][j+1][k]; } } } }

      print_bigger_matrix(s_box_f, “b_enc_sbox.txt”);

      convert_to_decimal(s_box_f, s_box_d);

      printf(“\nS box:\n”);

      print_16x16_matrix(s_box_d);

FILE *fermat_encoding = fopen(“Fermat_encoding.txt”, “w”);

      fprintf(fermat_encoding, “Fermat Encoding: \n”);

      int fe_index = 0;

      for (int i = 0; i < ROWS_16; i++){

       for (int j = 0; j < COLS_16; j++){

        fprintf(fermat_encoding, “Index = %d\n”, fe_index);

        int element = s_box_d[i][j];

        fprintf(fermat_encoding, “\n”);

        for (int k = 0; k < BITS; k++){

         fprintf(fermat_encoding, “%d - %d = “, element, fer-mat_numbers[k]);

          encrypted_val = element - fermat_numbers[k];

          if (encrypted_val<0)

            encrypted_val = 256 + encrypted_val;

          fprintf(fermat_encoding, “%d\n”, encrypted_val);

          element = encrypted_val; }

        fe_index++;

        fprintf(fermat_encoding, “\n”);

        fprintf(fermat_encoding, “\n”);

        s_box_e[i][j] = encrypted_val; } }

      fclose(fermat_encoding);

      fflush(fermat_encoding);

    printf(“\nS box Encrypted:\n”);

      print_16x16_matrix(s_box_e);

FILE *file = fopen(“encrypted_sbox.txt”, “w”);

  if (file == NULL) {

    perror(“Error opening file”);

    return 1; }

  for (int i = 0; i < ROWS_16; ++i) {

    for (int j = 0; j < COLS_16; ++j) {

      fprintf(file, “%d “, s_box_e[i][j]); }

    fprintf(file, “\n”); }

  fclose(file);

printf(“\nS-Box stored in ‘encrypted_sbox.txt’ successfully.\n”);

  printf(“Binary initial sbox stored in ‘b_sbox.txt’\n”);

printf(“Binary encrypted sbox stored in ‘b_enc_sbox.txt’\n”);

      break;

DECRYPTION

printf(“Enter the encrypted s-box filename(decimal): “);

scanf(“%s”, filename);

file = fopen(filename, “r”);

if (file == NULL) {

  perror(“Error opening file”);

  return 1; }

for (int i = 0; i < ROWS_16; ++i) {

  for (int j = 0; j < COLS_16; ++j) {

    if (fscanf(file, “%d”, &s_box_e[i][j]) != 1) {

      fprintf(stderr, “Error reading from file\n”);

      fclose(file);

      return 1; } } }

fclose(file);

printf(“\nEncrypted S-box read from file:\n”);

print_16x16_matrix(s_box_e);

FILE *fermat_decoding = fopen(“Fermat_decoding.txt”, “w”);

  fprintf(fermat_decoding, “Fermat Decoding: \n”);

  int fd_index = 0;

  for (int i = 0; i < ROWS_16; i++){

    for (int j = 0; j < COLS_16; j++){

fprintf(fermat_decoding, “Index = %d\n”, fd_index);

      int element = s_box_e[i][j];

      fprintf(fermat_decoding, “\n”);

      for (int k = 0; k < BITS; k++){

fprintf(fermat_decoding, “%d + %d = “, element, fer-mat_numbers[k]);

  decrypted_val = element + fermat_numbers[k];

    if (decrypted_val>=256)

      decrypted_val = decrypted_val - 256;

fprintf(fermat_encoding, “%d\n”, decrypted_val);

          element = decrypted_val; }

        fd_index++;

        fprintf(fermat_encoding, “\n”);

        fprintf(fermat_encoding, “\n”);

        s_box_d[i][j] = decrypted_val;

        int_to_binary(decrypted_val, s_box_f[i][j]); } }

      fclose(fermat_decoding);

      fflush(fermat_decoding);

      printf(“\nFermat decoded S-box:\n”);

      print_16x16_matrix(s_box_d);

      print_bigger_matrix(s_box, “b_dec_sbox.txt”);

      int s_255[8];

      for (int i = 15; i >= 0; i--) {

        for (int j = 15; j >= 0; j--) {

          for (int k = 0; k < BITS; k++) {

            if (i==15 && j==15){

s_box[i][j][k] = s_box_f[0][0][k] ^ s_box_f[i][j][k];

            s_255[k] = s_box[i][j][k];

            }else{

            s_255[k] = s_box[i][j][k]; } } } }

          printf(“\nDecrypted S-box:\n”);

        convert_to_decimal(s_box, d_s_box);

        print_16x16_matrix(d_s_box);

FILE *decrypted_sbox = fopen(“decrypted_sbox.txt”, “w”);

  if (decrypted_sbox == NULL) {

    perror(“Error opening file”);

    return 1; }

  for (int i = 0; i < ROWS_16; ++i) {

    for (int j = 0; j < COLS_16; ++j) {

  fprintf(decrypted_sbox, “%d “, d_s_box[i][j]); }

fprintf(decrypted_sbox, “\n”); }

      fclose(decrypted_sbox);

      fflush(decrypted_sbox);

      print_bigger_matrix(s_box, “b_dec_sbox.txt”);

printf(“Binary decrypted sbox stored in ‘b_dec_sbox.txt’\n”);

printf(“Decrypted(decimal) sbox stored in ‘decrypted_sbox.txt’\n”);