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

No.
Devi considerare che non stai guardando nella memoria ma nell'eseguibile. Nell'eseguibile ci sono le istruzioni per creare il buffer e per riempirlo, non c'è il buffer.

Giusto, non ci avevo pensato! Questo apre la strada a tutta una serie di considerazioni.

Ti so dare anche una mezza risposta sul perché la stringa è spezzata.
Io ho compilato a 32 bit e forse anche tu, l'uint64_t è inframezzato dal codice che lo sposterà a blocchi di word.
Se compili a 64bit la stringa è intera.
Se modifichi la stringa nell'eseguibile a 64bit, si riperquote in tutte e tre le visualizzazioni.

I tuoi programmi compilati a 64bit funzionano, vedi immagine allegata.

Il byte 0xCD (primo in ogni sequenza) è l'opcode MOV che serve a spostare il valore imm32 seguente (4 caratteri di parte della stringa) in un colpo in memoria (essendo coinvolto il registro esp questo avviene durante il passaggio dei parametri prima della chiamata di una funzione)

In particolare

C7 44 24 0C [50 72 6F 76]    mov dword ptr [esp+0x0C],0x766F7250 (vorP)
C7 44 24 10 [65 74 74 61]    mov dword ptr [esp+0x10],0x61757565 (atte)

passa Provetta nello stack per essere usato dalla funzione successiva e lo fa più volte come se fosse chiamata una funzione con

funz("Provetta", "Provetta" ... )

o qualcosa di simile.

Se posti l'eseguibile si può vedere meglio (ancora meglio con il sorgente e le relative corrispondenze)

Grazie nessuno, hai evidenziato anche la mia imprecisone, sposta le Dword, non le Word.

@AldoBaldo
Ti ho chiesto forse troppo velatamente: perché gli uint64_t?
Vuoi nascondere il nome delle password sul sorgente?
Perché come hai visto nell'eseguibile i nomi sono comunque visibili e comunque al primo cambio quello che era scritto sul sorgente è ininfluente.

Con questo codice per creare programma.exe tutti i problemi scompaiono:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#define kVar1 "Provetta"
#define kVar2 "@perolGrazie nessuno, hai evidenziato anche la mia imprecisone, sposta le Dword, non le Word.



@AldoBaldo

Ti ho chiesto forse troppo velatamente: perché gli uint64_t?

Vuoi nascondere il nome delle password sul sorgente?

Perché come hai visto nell'eseguibile i nomi sono comunque visibili e comunque al primo cambio quello che era scritto sul sorgente è ininfluente.



Con questo codice per creare programma.exe tutti i problemi scompaiono:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#define kVar1 "Provetta"
#define kVar2 "@perol{parsed_message}{parsed_message}"

int main() {
 
    printf ("%s\n%s", kVar1, kVar2);

    while( '\n'!=getchar() );
    return 0;
}


La ricerca del seek funzionerà anche a 32bit, e la modifica dell'eseguibile avverrà con successo.Grazie nessuno, hai evidenziato anche la mia imprecisone, sposta le Dword, non le Word.



@AldoBaldo

Ti ho chiesto forse troppo velatamente: perché gli uint64_t?

Vuoi nascondere il nome delle password sul sorgente?

Perché come hai visto nell'eseguibile i nomi sono comunque visibili e comunque al primo cambio quello che era scritto sul sorgente è ininfluente.



Con questo codice per creare programma.exe tutti i problemi scompaiono:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#define kVar1 "Provetta"
#define kVar2 "@perol{parsed_message}{parsed_message}"

int main() {
 
    printf ("%s\n%s", kVar1, kVar2);

    while( '\n'!=getchar() );
    return 0;
}


La ricerca del seek funzionerà anche a 32bit, e la modifica dell'eseguibile avverrà con successo."

int main() {
 
    printf ("%s\n%s", kVar1, kVar2);

    while( '\n'!=getchar() );
    return 0;
}

La ricerca del seek funzionerà anche a 32bit, e la modifica dell'eseguibile avverrà con successo.

Grazie a entrambi, anche se non sono in grado di comprendere a fondo l'aspetto tecnico di quel che mi avete spiegato (credo di intuirne i fondamenti, ma non le ricadute concrete, operative), ho compreso di essere in un vicolo cieco dal quale mi conviene uscire retrocedendo verso la parte dalla quale sono entrato.

Volendo fare meno il raffinato: abbandono quest'idea e mi limito a inserire nel codice un file nel quale raccogliere tutte le impostazioni che potrei un domani voler cambiare. A quel punto, cambiate le impostazioni, posso ricompilare il programmino in una manciata di secondi. Per le mie finalità posso accontentarmi.

Ah, per il fatto che le password sarebbero comunque visibili ho già trovato una soluzione che, sempre per il campo di applicazione che ho in mente, può andar benissimo: maschero i caratteri con un banalissimo xor contro 0xff e chi si è visto, si è visto, tanto nessuno andrà mai a cercarli.

Mi è invece venuta in mente una caratteristica interessante che intendo inserire: il programma funzionerà solo dalle ore x alle ore y di certi giorni predeterminati della settimana: quelli nei quali ho lezione io e non qualche collega. Inoltre, il programma si chiuderà automaticamente all'ora prestabilita, anche se dovessi dimenticarlo aperto. Bon, direi che più di così si entra nel campo della paranoia!

Grazie davvero, questo forum è ormai semideserto, ma i pochi superstiti sono persone apprezzabili assai, e spero che le cose non cambino.

EDIT: Appena avrò terminato il tutto, per correttezza verso di voi metterò il sorgente su questo thread, così avrete qualche motivo più che valido per farvi una risata.

Sì, in origine avevo quello in mente. Mi auto-dedico un'icona animata:

Penso che sia il risultato compilato di:
printf( "0x%016llx %19lld %s\n", kVar1, kVar1, p );
kVar1 dichiarato come costante uint64_t, viene diviso in Dword perché non è spostabile in un colpo solo a 32bit mov dword.
const uint64_t kVar1 = 0x61747465766f7250; // "Provetta"
lo stesso succede per p

il sorgente completo era:

#include <stdlib.h>
#include <string.h>
#include <stdint.h>

const uint64_t kVar1 = 0x61747465766f7250; // "Provetta"
const uint64_t kVar2 = 0x00006c6f72657040; // "@perol"


char *rovescia_8( uint64_t n ) {
    static char buff[16] = {0};
    memcpy( buff, (void*)&n, 8 );
    return buff;
}

int main() {
   char *p;

   p = rovescia_8( kVar1 );
   printf( "0x%016llx   %19lld   %s\n", kVar1, kVar1, p );

   p = rovescia_8( kVar2 );
   printf( "0x%016llx   %19lld   %s\n", kVar2, kVar2, p );

    while( '\n'!=getchar() );
    return 0;
}

la porzione di eseguibile vista nell'HexEditor, il primo mov dword dovrebbe essere a 0x00001577:

0x00001550   40 00 90 90 FF 25 F4 70 40 00 90 90 66 90 66 90 
0x00001560   55 89 E5 53 83 E4 F0 83 EC 20 E8 31 F8 FF FF C7 
0x00001570   44 24 14 20 60 40 00 C7 44 24 0C 50 72 6F 76 C7 
0x00001580   44 24 10 65 74 74 61 C7 44 24 04 50 72 6F 76 C7 
0x00001590   44 24 08 65 74 74 61 C7 04 24 48 40 40 00 C7 05 
0x000015A0   20 60 40 00 50 72 6F 76 C7 05 24 60 40 00 65 74 
0x000015B0   74 61 E8 59 F2 FF FF C7 44 24 14 20 60 40 00 C7 
0x000015C0   44 24 0C 40 70 65 72 C7 44 24 10 6F 6C 00 00 C7 
0x000015D0   44 24 04 40 70 65 72 C7 44 24 08 6F 6C 00 00 C7 
0x000015E0   04 24 48 40 40 00 C7 05 20 60 40 00 40 70 65 72 
0x000015F0   C7 05 24 60 40 00 6F 6C 00 00 E8 11 F2 FF FF 8B 
0x00001600   1D 64 71 40 00 EB 18 8D B4 26 00 00 00 00 66 90 
0x00001610   8B 03 8D 50 01 89 13 0F B6 00 83 F8 0A 74 13 83 
0x00001620   6B 04 01 79 EB 89 1C 24 E8 8F FE FF FF 83 F8 0A 
0x00001630   75 ED 8B 5D FC 31 C0 C9 C3 90 90 90 90 90 90 90 
0x00001640   E9 EB F0 FF FF 90 90 90 90 90 90 90 90 90 90 90

Lo stesso succede per: @perol a 0x000015BF
allegata l'immagine comprensiva dei caratteri.