C/C++ - Salvare dati nel file dell'eseguibile

L'ho archiviato sugli esempi in C che chissà quando consulterò
Ci sono delle cosette carine che potrebbero tornare utili.

Al posto di

const char kPIN[MAX_CIFRE_PIN] = { 4,5,4,5,2,0,0,0 };

usa semplicemente

int kPIN = 0;

e poi sparse nel codice, dove vuoi

kPIN += 40000;
...
kPIN += 5000;
...
kPIN += 400;
...
kPIN += 50;
...
kPIN += 2;

in modo da rendere le cose un po' meno costanti...

Nell'exe

Grazie Nessuno. Creare un po' di "confusione creativa" senz'altro aiuterebbe a offuscare la disponibilità del dato per eventuali curiosi. Viste le finalità del programmino, comunque, non serve un livello di "paranoia" così elevato. In definitiva, coloro che potrebbero essere interessati sono gli studenti, che non hanno praticamente mai accesso a quei PC (e quando riescono ad averlo "di straforo" è solo per poche manciate di secondi). Ai colleghi non interessa nulla di risalire ai miei codici. Più che altro, il PIN è lì per rendere non troppo ovvio e immediato l'uso del programmino per le rarissime situazioni "mordi e fuggi". Inoltre, ottenere le password (ammesso che uno intuisca questa cosa e sia interessato a farlo) è semplicissimo: basta aprire il Notepad e fare un drag-and-drop su un qualsiasi documento aperto. Davvero, è un po' come quando metti un lucchetto ad una porta: cosa ci vuole ad aprirlo? ben poco, però si conta sul fatto che nessuno voglia davvero farlo, sapendo che sarebbe cosa per niente gradita a chi il lucchetto lo ha messo.

Son di nuovo qui a rompere le scatole con le mie domande senza una finalità immediata. Portate pazienza, è tipico dei dilettanti. Dunque, ho condotto una serie di prove per vedere di trovare un metodo per portare a termine quel che sto facendo...

===============================================

Mi sono posto come obiettivo quello di inserire in un eseguibile per windows alcune costanti di tipo uint64_t che regolano le impostazioni del programma. Diciamo che quel programma si chiama "programma.exe". Fatto, funziona (ovviamente).

Ho poi creato un secondo programma che scorre il contenuto di "programma.exe" in cerca delle sequenze di 8 byte che costituiscono i valori delle costanti "impiantate" in fase di compilazione. Questo secondo programma crea un file di testo (diciamo "posizioni.txt" nel quale scrive come uint32_t le posizioni del primo byte di ciascuna delle sequenza di byte trovate. Fatto, funziona (non troppo "ovviamente", ma funziona).

Da ultimo, ho creato un terzo programma, che...
a) carica il file "posizioni.txt" sotto forma di array di uint32_t
b) con fopen("programma.exe", "rb+" apre in FILE *fPrg il file "programma.exe"
c) in un ciclo dotato di un numero adeguato di ripetizioni, accede con fseek(fPrg) a ciascuna delle posizioni caricate da "posizioni.txt" e sostituisce con fwrite() i valori uint64_t ivi immagazzinati

===============================================

L'idea di tutto questo intruglio è avere la possibilità di modificare le impostazioni di "programma.exe" senza ricompilare tutto e senza lasciare in giro file di impostazione troppo facilmente accessibili. Dunque dove sta il problema?

Il problema è che tutto sembra funzionare a dovere: quando vado a leggere dal programma di modifica il contenuto di "programma.exe" agli indirizzi dove ho effettuato la modifica, ci trovo in effetti i nuovi valori MA...

...MA se lancio "programma.exe" dopo la presunta modifica, l'esecuzione avviene come se le impostazioni non fossero state cambiate! Con un exe editor ho cercato nel "programma.exe" modificato le sequenze di byte dei vecchi valori e, udite udite, QUELLE SEQUENZE NON RISULTANO!

In che razza di arcano mi sono imbattuto? Ora, posso benissimo vivere senza risolvere questa cosa, buttando tutto nel cestino, ma davvero mi scombussola non riuscire a comprendere cosa sta accadendo. A voi suona qualche campanello?

QUELLE SEQUENZE NON RISULTANO, le vecchie o le nuove?

La cosa più probaile è che modifichi un file e ne esegui un'altro, controlla BENE i percorsi.
L'eseguibile originale e l'eseguibile modificato DEVONO avere lo stesso peso.

Non ho ancora aperto l'allegato.

Carlo, è sempre possibile che mi scappi qualche idiozia (sai quante volte mi è già successo?) però in questo caso ho provato e riprovato tante di quelle volte che la considero una possibilità molto remota.

Comunque, cerco di riformulare: il programma di "inoculazione" mostra il contenuto del file "programma.exe" nelle locazioni indicate prima e dopo la modifica, e da lì appare che i nuovi dati sono effettivamente stati scritti.

Lancio "programma.exe", e verifico che si comporta esattamente come PRIMA della modifica, ovvero come se la modifica non fosse stata posta in essere.

Controllo il "programma.exe" appena lanciato, lo stesso che si comporta come PRIMA della modifica, ma nel file non c'è traccia dei vecchi valori!

Sembra quasi una storia da film sui fenomeni paranormali...
Posso provare a consultare un esorcista, che dici?

Con i computer i fenomeni paranormali si risolvono SEMPRE con: errore del programmatore.

Compilato programma.exe, poi con trova posizioni.exe sono andato a vedere le locazioni che ha trovato.
Nelle locazioni individuate ci sono le stringhe, ma se le modifichi con un Hex Editor, capisci che non sono quelle di interesse.

Hai usato gli uint64_t che bisognerebbe sapere come vengono memorizzati, non è detto che i byte siano consecutivi, altro dubbio è che sono costanti, non ho idea di come il compilatore le tratta. Ricorda che non stiamo guardando nella memoria ma nell'eseguibile.

Cercando porzioni delle stringhe infatti ho trovato i valori a gruppi di 4 caratteri, nella foto allegata vedi come sono memorizzati i valori di Provetta in tre locazioni distinte.
Il primo modifica i valori decimali
Il secondo esadecimali
Il terzo la stringa

Non ti so aiutare di più, ci vuole nessuno, oppure usa le variabili e i char

Grazie Carlo. Potrebbe essere una questione di "padding" dei valori? Sai, tipo quando succede che tu dichiari un char, ma il sistema per ragioni tutte sue decide di impiegare una quantità di memoria maggiore rispetto al minimo indispensabile, per poi ignorare lo spazio in più (che viene in un certo senso "sprecato". Comunque mi hai dato un bello spunto. Partendo da lì proverò qualche nuovo intrigo, tanto sto giusto "spippolando" senza troppe pretese. Prima o poi esplode tutto!