//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;
}