[c++] Problema Cifratura e Decifratura RSA

[HeroGian]

Salve a tutti, ho un problema riguardo il seguente frammento di codice:
in pratica è un programma che cifra e decifra del testo secondo la codifica RSA.

char CalcolaPotenza( int N, int e, uint64_t r )
{
	char ris = 1;
	for ( ; e > 0; e-- ){
		ris = (ris*N)%r;
	}
	return ris;
}

int Codifica( int esp, uint64_t mod )
{
	char CarCorrente, Car;
	ifstream leggi(NomeFileIn);
	if ( !leggi )
		return 1;

	ofstream scrivi(NomeFileOut);
	if ( !scrivi )
		return 2;

	while( (CarCorrente = leggi.get()) !=  EOF )
	{
		Car = CalcolaPotenza(CarCorrente, esp, mod);
		scrivi.put(Car);
	}
	return 0;
}

Il problema molto probabilmente sta nella lettura e scrittura non formattata.. in pratica dato un file di testo pensavo di prendere carattere per carattere cola la .get() e cifrarlo per mezzo della funzione moltiplica.. il problema è che in decifratura il messaggio non viene appunto decifrato

ad esempio supponendo di dover cifrare il carattere 'a' con le chiavi (5, 323) e (173, 323) avrei

97^5 mod 323 = 241 cifratura
241^173 mod 323 = 97 decifratura

cosa che funziona bene in teoria, ma che non mi viene in pratica

[oregon]

Penso che la funzione CalcolaPotenza debba essere

char CalcolaPotenza( int N, int e, unsigned long long r )
{
	unsigned long long ris = 1;
	for ( ; e > 0; e-- )
		ris *=N ;

	ris %= r;

	return ris;
}

in quanto prima esegui l'elevamento a potenza e solo alla fine calcoli il modulo

E infatti per la cifratura funziona.

Ovviamente non va per la decifratura dato che il risultato dell'elevamento a potenza è eccessivo.

[HeroGian]

mmh ho provato ma mi da lo stesso problema di prima
Probabilmente mi sbaglio, ma secondo me è per il fatto che nella funzione CalcolaPotenza ris è un long long int, mentre io ritorno un char e da qualche parte si ha una perdita di informazioni a causa di tutte queste conversioni e quindi i risultati vengono sballati..

[oregon]

Originariamente inviato da HeroGian
mmh ho provato ma mi da lo stesso problema di prima

Cosa hai provato? Il codice che ti ho mandato io? O un altro?

Ti ho spiegato che funziona nella codifica ma non nella decodifica ...

[HeroGian]

Scusami, avevo capito male io..
Ho provato a cambiare un po le letture e le scritture e in questo modo funziona, anche col calcolo della potenza come l'avevo scritto..

int CalcolaPotenza( int N, int e, uint64_t r )
{
	int ris = 1;
	for ( ; e > 0; e-- ){
		ris = (ris*N)%r;
	}
	cout << "ris = " << ris << endl;
	return ris;
}

int Codifica( int esp, uint64_t mod )
{
	char CarCorrente, Car;
	uint64_t tmp;
	ifstream leggi(NomeFileIn);
	if ( !leggi )
		return 1;

	ofstream scrivi(NomeFileOut);
	if ( !scrivi )
		return 2;

	while( (CarCorrente = leggi.get()) != EOF )
	{
		tmp = static_cast<uint64_t>(CarCorrente);
		tmp = CalcolaPotenza(tmp, esp, mod);
		scrivi << tmp << " ";
	}
	return 0;
}

int Decodifica( int esp, uint64_t mod )
{
	uint64_t IntCorrente, IntConv;
	char tmp;
	ifstream leggi(NomeFileIn);
	if ( !leggi )
		return 1;

	ofstream scrivi(NomeFileOut);
	if ( !scrivi )
		return 2;

	while( leggi >> IntCorrente )
	{
		IntConv = CalcolaPotenza(IntCorrente, esp, mod);
		tmp = static_cast<char>(IntConv);
		scrivi.put(tmp);
	}
	return 0;
}

Funziona con chiavi piccole, ma per chiavi molto grandi non funziona, non so perchè.. in teoria la funzione moltiplica scritta in quel modo dovrebbe tenere basso il risultato e non avere problemi di overflow.. strano