Buona serata a tutti!!!
Posto qui di seguito il codice del programma, che SEMBREREBBE funzionare, ma in realtà nella routine che esegue lo xoring di un byte alla volta, qualcosa non funziona, ma io non riesco proprio a capire cosa sia...
Il programma è stato debuggato e compilato con LCC-win32 che ho trovato davvero stupendo: leggerissimo, efficiente e molto vicino al buon vecchio Turbo debugger per dos
Ovviamente il programma è penoso, malfatto e con buona probabilità infrange innumerevoli regole di programmazione, e forse anche nelle parti in cui funziona, è solo per una fortunata coincidenza....
Perdonatemi ed aiutatemi, vi prego...
- Codice: Seleziona tutto
//xora.exe 05/04/2008
//programma in C per leggere/scrivere binary files
//Uso: xora.exe input_file indirizzo_iniziale indirizzo_finale chiave
//Ovvero il programma prende un file .bin oppure exe e a partire dall'indirizzo_iniziale
//all' indirizzo finale (valori espressi in esadecimale della posizione assoluta del file)
//effettua uno xor utilizzando il valore "chiave" (sempre in esadecimale)
//che è stato fornito dalla linea di comando.
// Il programma accetta un massimo di 4 parametri,
// di cui il primo deve essere il file binario da elaborare,
// il secondo deve essere l'indirizzo iniziale in HEX
// il terzo l'indirizzo finale in HEX
// il quarto il valore da usare per lo XOR in HEX
//si supponga un file binario lungo 13 bytes così strutturato:
//prova.bin
//0000: 3e f2 00 00 00 00 00 00 00 10 00 00 00
//>xora.exe prova.bin 000a 000c 3e prova2.bin
//prova2.bin dopo l'esecuzione
//0000: 3e f2 00 00 00 00 00 00 00 10 3e 3e 3e
/* --- The following code comes from d:\lcc\lib\wizard\textmode.tpl. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Usage(char *programName)
{
fprintf(stderr,"%s usage:\n",programName);
/* Modify here to add your usage message when the program is
* called without arguments */
}
/* returns the index of the first argument that is not an option; i.e.
does not start with a dash or a slash
*/
int HandleOptions(int argc,char *argv[])
{
int i,firstnonoption=0;
for (i=1; i< argc;i++) {
if (argv[i][0] == '/' || argv[i][0] == '-') {
switch (argv[i][1]) {
/* An argument -? means help is requested */
case '?':
Usage(argv[0]);
break;
case 'h':
case 'H':
if (!stricmp(argv[i]+1,"help")) {
Usage(argv[0]);
break;
}
/* If the option -h means anything else
* in your application add code here
* Note: this falls through to the default
* to print an "unknow option" message
*/
/* add your option switches here */
default:
fprintf(stderr,"unknown option %s\n",argv[i]);
break;
}
}
else {
firstnonoption = i;
break;
}
}
return firstnonoption;
}
int main(int argc,char *argv[])
{
if (argc == 1) {
/* If no arguments we call the Usage routine and exit */
Usage(argv[0]);
return 1;
}
/* handle the program options */
HandleOptions(argc,argv);
/* The code of your application goes here */
//Da qui inizio io: prima tutto il lavoro lo ha fatto LCC_win32
//#include <stdio.h>
//int main(int argc, char **argv);
{
// Verifica che il numero di parametri sia corretto.
if( argc != 5 ) {
printf("Errato numero di parametri!\n");
printf("Uso:xora.exe input_file indirizzo_iniziale indirizzo_finale chiave\n");
printf("valori i esadecimale\n");
system ("pause");
return 1;
}
//Assegna alle variabili i dati provenienti dalla linea di comando
//Lo scopo è quello di ottenere i valori decimali che da command line vengono dati in hex
char *stopstring;// questo puntatore serve per strtol per convertire da esadecimale
char *input_file;
input_file=argv[1];
char *indirizzo_iniziale;
indirizzo_iniziale=argv[2];
long indirizzo_inizialeD; //valore in decimale
indirizzo_inizialeD=strtol(indirizzo_iniziale,&stopstring,16);
char *indirizzo_finale;
indirizzo_finale=argv[3];
long indirizzo_finaleD; //valore in decimale
indirizzo_finaleD=strtol(indirizzo_finale,&stopstring,16);
char *chiave;
chiave=argv[4];
int chiaveDL; //valore in decimale ma qui è un LongINT mentre serve un INT per lo xor successivo
chiaveDL=strtol(chiave,&stopstring,16);
int chiaveD= (int)chiaveDL;
//qui richiamo la command line per copiare il file "original" in "original.ori"
//in quanto poi tutte le operazioni vengono effettuate sul file "original" e se
//qualcosa dovesse andare storto possiamo sempre ripartire dal file .ori
char comando_dos[100]="copy ";
strcat(comando_dos,input_file);
strcat(comando_dos," ");
strcat(comando_dos,input_file);
strcat(comando_dos,".ori");
system (comando_dos);
FILE *fp_input_file;
// Apre il file di input in modalità "binaria a lettura/scrittura su file già esistente".
fp_input_file = fopen(input_file, "r+b");
if( fp_input_file == NULL ) {
printf("Il file %s specificato come input non esiste!\n",input_file);
return 2;
}
//Adesso a partire da indirizzo_iniziale e sino ad "indirizzo_iniziale" si legge un byte, o forse
//dovrei dire meglio un carattere ascii alla volta, si esegue uno xor e poi lo si riscrive xorato
long byte_seek=0;
//for (i=1; i< argc;i++) {
//qui casca l'asino: mentre utilizzando un editor esadecimale il byte seek 0 sarebbe il primo byte
//ossia: nel file ci sono ad es. 13 bytes numerati da 0 a 12(hview..), qui l'accesso avviene invece
//con i bytes numerati da 1 a 13..... insomma sempre 13 bytes sono, ma se non si sta attenti
//si corre il rischio di xorare quelli sbagliati....
for (byte_seek=(indirizzo_inizialeD); byte_seek<(indirizzo_finaleD+1); byte_seek++) {
fseek(fp_input_file,byte_seek,SEEK_SET);
if( fseek == NULL ) {
printf("Seek non riuscito sul file %s specificato come input!\n",input_file);
return 3;
}
char leggi_char[1];
int scrivi_char;
char scrivi_xor_char;
fread (leggi_char,1,1,fp_input_file);
fseek(fp_input_file,byte_seek,SEEK_SET);//dopo ogni operazione di read o write serve una nuova seek
scrivi_char=atoi(leggi_char);
scrivi_char=(scrivi_char ^ chiaveD);//operazione di xor eseguita tra due interi
scrivi_xor_char= (char) scrivi_char;
fwrite (&scrivi_xor_char,1,1,fp_input_file);
}//fine ciclo for
fclose(fp_input_file);
}
/* The code of your application ends here */
return 0;
}
Registrazione
