/*
  Questo programma fa parte di una libreria messa a disposizione dei
  lettori del libro
  Alessandro Languasco & Alessandro Zaccagnini,
  Introduzione alla Crittografia, Ulrico Hoepli Editore, Milano, 2004.

  Codifica e decodifica di messaggi per mezzo di RSA.
  Paragrafo 5.9
*/

#include<iostream>
#include<string.h>
#include "aritmetica.cc"

// L'alfabeto
static const
char alfa[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ,.' ";

// Il numero di caratteri nell'alfabeto
static const
long long CAR_ALFA = 30;

// Questa variabile contiene il numero massimo di caratteri di un messaggio
static const
long long MAX_CAR = 1000;

// Questa variabile contiene il numero di caratteri di ogni "blocco"
static const
long long LUNGH_BLOCCO = 4;

// Massimo numero di blocchi
static const
long long MAX_BLOCCHI = 100;

/*
  Ritorna la posizione del carattere "c" nell'alfabeto "alfa",
  oppure -1 se il carattere "c" non compare nell'alfabeto "alfa"
*/
long long
alfabeto(char c) {

  for(int i = 0; i < CAR_ALFA; ++i)
    if (c == alfa[i])
      return(i);
  return(-1);
}

/*
  Trasformazione del messaggio in un equivalente numerico
  "num_car" è il numero di caratteri nel messaggio
*/
void 
trasforma_in_numeri(std::string& messaggio, long long num_blocchi,
		    long long plaintxt[MAX_BLOCCHI]) {

  for(long long i = 0; i < num_blocchi; ++i) {
    long long k = 0;
    for(long long j= LUNGH_BLOCCO * i; j <LUNGH_BLOCCO * i+LUNGH_BLOCCO; ++j) {
      k *= CAR_ALFA;
      k += alfabeto(messaggio[j]);
      std::cout << messaggio[j];
    }
    plaintxt[i] = k;
    std::cout << "  " << k << std::endl;
  }
}

/*
  Codifica del messaggio "plaintxt" con RSA
*/
void
codifica(long long n, long long e, long long num_blocchi,
	 long long plaintxt[MAX_BLOCCHI], long long ciphertxt[MAX_BLOCCHI]) {

  for(long long i = 0; i < num_blocchi; ++i) {
    long long k = plaintxt[i];
    long long C = potenze_mod_n(k, e, n);
    std::cout << k << "  " << C << std::endl;
    ciphertxt[i] = C;
  }
}

/*
  Decodifica del messaggio "ciphertxt"
*/
void
decodifica(long long n, long long d, long long num_blocchi,
	   long long ciphertxt[MAX_BLOCCHI],
	   long long testo_in_chiaro[MAX_BLOCCHI]) {

  for(int i = 0; i < num_blocchi; ++i) {
    long long k = potenze_mod_n(ciphertxt[i], d, n);
    testo_in_chiaro[i] = k;
    std::cout << ciphertxt[i] << "  " << k << std::endl;
  }
}

/*
  Questa funzione trasforma un vettore di interi nel suo equivalente testuale
*/
void
trasforma_in_caratteri(long long testo_in_chiaro[], long long num_blocchi,
		       std::string& plaintxt) {

  char ch[LUNGH_BLOCCO];
  for(int i = 0; i < num_blocchi; ++i) {
    long long k = testo_in_chiaro[i];
    for(int j = 0; j < LUNGH_BLOCCO; ++j) {
      long long r = k % CAR_ALFA;
      k /= CAR_ALFA;
      ch[LUNGH_BLOCCO - j - 1] = alfa[r];
    }
    for (int j = 0; j < LUNGH_BLOCCO; ++j)
      plaintxt += ch[j];
  }
}

int
main() {

  // Determinazione della chiave pubblica e della chiave privata
  // "p" e "q" sono i fattori primi di "n"
  long long p = 1733;
  long long q = 2801;
  long long n  = p * q;
  long long fi = n - p - q + 1;
  std::cout << "Valori dei parametri: ";
  std::cout << "n = " << n << ", phi(n) = " << fi;

  long long i = 10000;
  long long lambda, mi;
  // cerca un intero > 10000 che sia primo con fi = phi(n)
  long long j;
  do {
    ++i;
    j = mcd_est(i, fi, lambda, mi);
  } while(j > 1);
  long long e = i;
  long long d = lambda;
  if (d < 0)
    d += fi;
  std::cout << ", e = " << e << ", d = " << d << std::endl;
  // La chiave pubblica è "(n,e)", la chiave privata è "(n,d)"

  // Il messaggio da cifrare per mezzo di RSA
  std::string messaggio="MESSAGGIO DI PROVA PER RSA.";
  long long num_car = messaggio.length();
  // Il numero di blocchi necessari
  long long num_blocchi = num_car / LUNGH_BLOCCO;

  // Copiamo il messaggio nell'array "testo"
  std::string testo;
  testo = messaggio;
  // Se il numero di caratteri non è un multiplo di "LUNGH_BLOCCO"
  // aggiungi in fondo a "testo" un certo numero di spazi
  if ((num_car % LUNGH_BLOCCO) != 0) {
    ++num_blocchi;
    for (int i = 0; i < LUNGH_BLOCCO - (num_car % LUNGH_BLOCCO); ++i)
      testo += ' ';
  }
  std::cout << "N. caratteri " << num_car << " N. blocchi " << num_blocchi;
  std::cout << std::endl;
  // A questo punto "testo" ha esattamente LUNGH_BLOCCO * num_blocchi caratteri
  std::cout << "Messaggio in chiaro: " << testo << std::endl;

  // Per prima cosa trasformiamo "testo" nei suoi equivalenti numerici
  long long plaintxt[MAX_BLOCCHI] = {MAX_BLOCCHI * 0};
  trasforma_in_numeri(testo, num_blocchi, plaintxt);

  // Codifichiamo "plaintxt" ottenendo "ciphertxt"
  // Si usa solo la chiave pubblica "(n,e)"
  std::cout << "Inizio codifica" << std::endl;
  long long ciphertxt[MAX_BLOCCHI] = {MAX_BLOCCHI * 0};
  codifica(n, e, num_blocchi, plaintxt, ciphertxt);

  // Decodifichiamo "ciphertxt" ottenendo "testo_in_chiaro"
  // Qui si usa la chiave privata
  std::cout << "Inizio decodifica" << std::endl;
  long long testo_in_chiaro[MAX_BLOCCHI] = {MAX_BLOCCHI * 0};
  decodifica(n, d, num_blocchi, ciphertxt, testo_in_chiaro);

  // Trasformiamo "testo_in_chiaro" nel suo equivalente testuale
  // ottenendo il messaggio di partenza
  std::string messaggio_dec;
  trasforma_in_caratteri(testo_in_chiaro, num_blocchi, messaggio_dec);
  std::cout << "Messaggio decifrato: " << messaggio_dec << std::endl;
}