Valutazione 4.87/ 5 (100.00%) 5838 voti

Condividi:        

programma in C per leggere/scrivere binary files

Problemi di HTML? Di PHP, ASP, .NET, JSP, Perl, SQL, JavaScript, Visual Basic..?
Vuoi realizzare programmi in C, C++, Java, Ruby o Smalltalk, e non sai da che parte cominciare?
Entra qui e troverai le risposte!

Moderatori: Triumph Of Steel, archimede

programma in C per leggere/scrivere binary files

Postdi danrevella » 05/04/08 14:51

Buona giornata a tutti!!
Una doverosa premessa: ho qualche minima nozione di programmazione, ma risale a quasi 30 (purtroppo è vero... :-(() anni fa..... quindi perdonatemi...
Che cosa dovrebbe fare il mio programma?
>myprog /?
Sintassi myprog nome_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) effetua uno xor utilizzando il valore "chiave" (sempre in esadecimale) che è stato fornito dalla linea di comando.
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
dopo l'esecuzione diventa:
>myprog prova.bin 000a 000c 3e
prova.bin
0000: 3e f2 00 00 00 00 00 00 00 10 3e 3e 3e
Il programma vorrei farlo in C (non C++) nel modo piu' semplice e banale possibile, mi è sufficiente che giri sotto xp da linea di comando, e se il farlo in dos significa che posso utilizzare ad es. il Turbo C 2.01 della Borland con il buon vecchio Turbo debugger, evitando dei template piuttosto complicati, forse sarebbe l'ideale.
Se invece avete altri software (freeware per favore....) da consigliarmi, vi ringrzio, tenete però presente che per me sarebbe fondamentale comunque poter usufruire di uno strumento di debugging come Turbo debugger che linea dopo linea mi faccia vedere e capire come procedere.
Ho cercato di documentarmi un po': ho capito che per leggere un file in modo binario si devono utilizzare fread, fwrite, e nel mio caso forse è utile fseek; inoltre ho provato (senza successo) a capire come funziona il passaggio dei parametri da linea di comando.....
Per favore, se avete qualche piccolo template per aiutarmi, io poi farò tutte le prove e sperimentazioni possibili, vorrei usare questo programma come stimolo e come trampolino di lancio per tornare a fare un po' di programmazione, ma da solo non ce la faccio proprio...

Grazie a chiunque vorrà darmi una mano.

Danrevella
danrevella
Utente Junior
 
Post: 25
Iscritto il: 27/10/03 18:35

Sponsor
 

Re: programma in C per leggere/scrivere binary files

Postdi danrevella » 08/04/08 20:28

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... :cry: :cry: :cry:
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... :oops: :oops: :oops:

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;
}
danrevella
Utente Junior
 
Post: 25
Iscritto il: 27/10/03 18:35

Re: programma in C per leggere/scrivere binary files

Postdi zello » 09/04/08 00:22

Scritto di botto, debuggato il minimo, messaggi di errore all'osso. Fallisce se il file non esiste, o se l'indirizzo di destinazione è minore di quello di partenza, o se tenti lo xor con più di un byte. Cripta dall'offset di partenza a quello di arrivo *compreso*
Codice: Seleziona tutto
#include <stdio.h>
#include <stdlib.h>

int main(int argn, char** args)
{
   unsigned int from,to,with,size,i;
   struct FILE* fp=NULL;
   unsigned char* buf=NULL;
   if(argn!=5 ||
      !(fp=fopen(args[1],"r+b"))||
      !sscanf(args[2],"%x",&from)||
      !sscanf(args[3],"%x",&to)||
      !sscanf(args[4],"%x",&with)||
      with>(unsigned char)(-1)||
      to<from)
   {
      if(fp)   fclose(fp);
      fprintf(stderr,"Invalid command line\n");
      return EXIT_FAILURE;
   }
   size=to-from+1;
   fseek(fp,from,SEEK_SET);
   if(!(buf=malloc(size)))
   {
      fclose(fp);
      fprintf(stderr,"Out of memory\n");
      return EXIT_FAILURE;
   }
   size=fread(buf,1,size,fp);
   for(i=0;i<size;++i)
      buf[i]^=((unsigned char)with);
   fseek(fp,from,SEEK_SET);
   fwrite(buf,1,size,fp);
   free(buf);
   fclose(fp);
   return EXIT_SUCCESS;
}
Il faut être toujours ivre. Tout est là : c'est l'unique question. Pour ne pas sentir l'horrible fardeau du Temps qui brise vos épaules et vous penche vers la terre,il faut vous enivrer sans trêve...
Avatar utente
zello
Moderatore
 
Post: 2351
Iscritto il: 06/05/02 13:44

Re: programma in C per leggere/scrivere binary files

Postdi danrevella » 09/04/08 10:23

innanzitutto per adesso grazie mille!!!! :) :D :D :D
Come avrai capito sono un absolute newbie, ma in ogni caso farò il bravo e me lo studierò per bene.
Posterò miei commenti.
Grazie ancora.

Danrevella
danrevella
Utente Junior
 
Post: 25
Iscritto il: 27/10/03 18:35


Torna a Programmazione


Topic correlati a "programma in C per leggere/scrivere binary files":


Chi c’è in linea

Visitano il forum: Nessuno e 3 ospiti