Newsgroup: it.comp.lang.c++
Titolo: perchèèèèèèèè

Il mio grido disperato si leva perchè il seguente programma non fa il suo
dovere...
cioè non decritta in modo decente quello che precedentemente avevo crittato:
in teoria le tabelle dalla 0 alla 127 sono quelle crittanti, quelle dalla
128 alla 255 sono quelle decrittanti, e come valori ascii sono giuste, ma il
problema è che per qualche strana ragione il programma non lo fa nel modo
adeguato...
Grazie a chiunque troverà l'errore...
///////////////////////////////////////inizio programma
///////////////////////////////////////
#include <iostream>
#include <stdlib.h>
#include <vector>
#include <string>
#include <fstream>
string critta(string str, bool m,int n){
if(!m) n+=128;
int B[256]=
{3, 5, 6, 7, 10, 12, 14, 19, 20, 24, 27, 28, 33, 37, 38, 39, 40, 41, 43,
45, 47, 48, 51, 53, 54, 55, 56, 63, 65, 66, 69, 71, 74, 75, 76, 77, 78,
80, 82, 83, 85, 86, 87, 90, 91, 93, 94, 96, 97, 101, 102, 103, 105, 106,
107, 108, 109, 110, 112, 115, 119, 125, 126, 127, 130, 131, 132, 138,
142, 145, 147, 148, 149, 150, 151, 152, 154, 155, 156, 160, 161, 163,
164, 166, 167, 170, 171, 172, 174, 175, 177, 179, 180, 181, 182, 183,
186, 188, 191, 192, 194, 201, 202, 203, 204, 206, 209, 210, 212, 214,
216, 217, 218, 219, 220, 224, 229, 230, 233, 237, 238, 243, 245, 247,
250, 251, 252, 254};
unsigned char T[256][256];
int i,j,last,S,SZero=55,P;
S=SZero;
// prime 128 tabelle
for (i=0; i<128; i++)
{ last=1;
   P=B[i];
   for (j=0; j<256; j++)
   {
    last = (last*P) % 257;
    T[i][j]=(last-1+S) % 256;
   } S=T[i][77];
}
// seconde 128 tabelle
for (i=0; i<128; i++){
    for (j=0; j<256; j++)
       T[i+128][T[i][j]]=(char)j;}
string tmp;
for(int k=0;k<str.size();k++) tmp+=T[n][str[k]];
return tmp;}
int main()
{string locazione;
std::cout<<"Scrivi l'indirizzo completo del file: ";
std::cin>>locazione;
std::cout<<"Vuoi (c)rittare o (d)ecrittare? ";
char choose;
std::cin>>choose;
std::cout<<"Scrivi il numero di crittazione (0-127): ";
int h;std::cin>>h;
bool c_or_d;
if (choose=='c') c_or_d=true;
else c_or_d=false;
ifstream in(locazione.c_str());
std::cout<<'\n'<<"Sto lavorando..." <<'\n';
string line;
vector<string> filez;
while(getline(in,line))filez.push_back(line+'\n');
ofstream out(locazione.c_str());
for(int i=0;i<filez.size();i++) out<<critta(filez[i],c_or_d,h)+'\n';
std::cout<<'\n';
}
///////////////////////////////////// fine programma
///////////////////////////////
--
« Ma il tempo, il tempo chi me lo rende?
Chi mi da' indietro quelle stagioni
di vetro e sabbia, chi mi riprende
la rabbia e il gesto, donne e canzoni...»
                                      Francesco Guccini
«Considerate la vostra semenza:
fatti non foste a viver come bruti,
ma per seguir virtute e conoscenza»
                                       Dante
mailto: 
savecast...@virgilio.it

 ifstream in(locazione.c_str());
Forse il problema è qui: se devi leggere un file in cui i caratteri non
sono nell'intervallo 32-127, allora lo dovresti aprire come binario
Non ho risolto molto, però se magari ci commenti un po' il programma...
Ciao!
Azathot

 dovere...
Forse c'è qualcosa che non va nell'algoritmo con cui crei le tabelle ma
non è facile, non conoscendolo, capire come dovrebbe funzionare.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 ha scritto nel messaggio
news:pan.2003.03.09....@hell.com...


Ciao!
Ti consiglio di lasciar perdere questo algoritmo che è molto debole (è un
classico cifrario di Cesare, quindi scardinabile velocemente con un
algoritmo di analisi delle frequenze). Ti conviene usare un metodo
riconducibile all'one-time pad simmetrico. Esempio:
#include <iostream>
#include <string>
using namespace std;
void critta( const unsigned char * _original, int _size, unsigned char * _dest, unsigned char * _key ) {
   int key_size( strlen( ( char * ) _key ) );
   for( int index = 0; index < _size; ++index ) {
      _dest[ index ] = _original[ index ] ^ _key[ index % key_size ];
   }
}
int main( ) {
   unsigned char temp[ 1024 ];
   unsigned char testo[] = "ABCABCABCABC";
   unsigned char key[] = "Azathot";
   critta( testo, strlen( ( char * ) testo ) + 1, temp, key );
   critta( temp, strlen( ( char * ) testo ) + 1, temp,  key );
   cout << temp << endl;
   return 0;
}

 ha scritto nel messaggio
news:pan.2003.03.09....@hell.com...


 dovere...
Non sono in grado di controllare istruzione per
istruzione il tuo programma (faccio molto prima a riscriverne uno
che funziona qui sotto).
Se vuoi correggere il tuo programma tieni ben presente che
tutte le operazioni le devi fare su unsigned char altrimenti
il programma sballa, visto che i codici criptati spannnano su tutto 
0-255 anche quando l'input e' puro ascii. Poi stai attento ai fine
linea: il tuo programma aggiunge 2 bytes ogni volta che viene invocato.
Inoltre non mi sembra una buona scelta spezzare il file di ingresso in
linee di testo perche' in questo modo ti precludi la possibilita' di
criptare files binari, e sei ridotto a trattere i finea linea "a parte".
Molto meglio leggere e scrivere i files in modalita' binaria.
Infine scusa, ma mi sembra abbastanza assurdo, per ogni linea da
codificare o decodificare, andarsi a calcolare tutte le tabelle.
((Quando hai postato il quesito originario su it.scienza.matematica mi
avevi chiesto un  metodo che fosse semplice ma veloce (anche a scapito
della robustezza).  Se per ogni linea ricalcoli tutti i valori il
programma non sara' molto  veloce...)).
Meglio farlo una volta sola all'inizio del programma (IniTabs()).
Prova a studiare questo mio programmino sotto
(sorry, e' in C...) e cerca di capire perche' funziona...
piu' di tanto non posso fare.
il programma si invoca con i parametri a linea di comando tipo
CRITTA C/D tab 
file.in
 file.out
dove C o D (maiuscole) indicano critto o decritto, tab da 0 a 127 e' la
tabella e  
file.in
 e file.out sono i nomi dei file da leggere e
scrivere.
ciao,
g.
#include<stdio.h>
#include<stdlib.h>
unsigned char T[256][256];
int B[128]=
{3, 5, 6, 7, 10, 12, 14, 19, 20, 24, 27, 28, 33, 37, 38, 39, 40, 41, 43,
45, 47, 48, 51, 53, 54, 55, 56, 63, 65, 66, 69, 71, 74, 75, 76, 77, 78,
80, 82, 83, 85, 86, 87, 90, 91, 93, 94, 96, 97, 101, 102, 103, 105, 106,
107, 108, 109, 110, 112, 115, 119, 125, 126, 127, 130, 131, 132, 138,
142, 145, 147, 148, 149, 150, 151, 152, 154, 155, 156, 160, 161, 163,
164, 166, 167, 170, 171, 172, 174, 175, 177, 179, 180, 181, 182, 183,
186, 188, 191, 192, 194, 201, 202, 203, 204, 206, 209, 210, 212, 214,
216, 217, 218, 219, 220, 224, 229, 230, 233, 237, 238, 243, 245, 247,
250, 251, 252, 254};
void IniTabs()
{
   int i,j,last,S,SZero=55,P;
   S=SZero;
   for (i=0; i<128; i++)
   { last=1; P=B[i];
    for (j=0; j<256; j++)
    {
     last = (last*P) % 257;
     T[i][j]=(unsigned char) ((last-1+S) % 256);
    }
    S=T[i][77];
   }
   for (i=0; i<128; i++)
     for (j=0; j<256; j++)
        T[i+128][T[i][j]]=(unsigned char)j;
}
void critta(unsigned char *B, int tab, int n)
{
   for (n--; n>=0; n--) B[n]=T[tab][(unsigned)B[n]];
}
void Errore(char *s)
{ printf("Errore: %s\n",s);
   printf(" Uso: AURON (C/D) 0..127 
file.in
 file.out\n");
   exit(0);
}
int main(int argc, char *argv[])
{
   FILE *fin, *fout;
   int L, tab;
   char op;
   unsigned char Buf[1024];
   if (argc!=5) Errore("Numero argomenti errato");
   op=argv[1][0];
   if (op!='C' && op!='D') Errore("Operazione: C o D");
   tab=atoi(argv[2]);
   if (tab<0 || tab>127) Errore("Tabelle da 0 a 127");
   fin=fopen(argv[3],"rb");
   if (!fin) Errore("Impossibile aprire 
file.in
");
   fout=fopen(argv[4],"wb");
   if (!fout) Errore("Impossibile aprire file.out");
   IniTabs();
   if (op == 'D') tab += 128; // decritta
   while (!feof(fin))
     {
       L = fread(Buf, 1, 1024,fin);
       critta(Buf, tab, L);
       fwrite(Buf,1,L,fout);
     }
   fclose(fout); fclose(fin);
   return 0;
}