[C/C++] stampare ciò che è fuori da una stringa

[Duchamp]

Ciao a tutti! Inauguro il mio primo messaggio con un esperimento abbastanza surreale. Ieri sera ho voluto prendere un array di caratteri (chiamiamola stringa) e provare a stampare ciò che andava oltre la sua dimensione.


char s[] = "abc";
std::cout << s[6];


Ho visto che si poteva superare di molto il "boundary" di quella stringa, e quindi ho spinto al limite l'esperimento con un ciclo infinito:


int i = 0;
while( true )
std::cout << s[i];
i++


A questo punto le (per me) meravigliose scoperte! La segfault arrivava con "i" oscillante tra i 7000 e gli 11000: come mai così variabile? E prima di tutto, come mai non partiva già a i = 4, ovvero subito dopo il termine della stringa?
Inoltre la stampa mi ha rivelato,dopo una serie di caratteri spazzatura, alcune informazioni in chiaro probabilmente relative al sistema (uso Linux). Le aggiungo di seguito:


/*
* �F��HG��uԷ����HG��uԷ
tG��|G�����

͂��������HG���Q�`�
* �e������Է�O��
�����
tG������ph��lG��C��
�V���V��W��#
* W��PW��[W��kW���W���W���W���W��"\��M\��}\���\���\���\��]��1]��~]���]���
* ]���]���]���]��
* ^��^��%^��@^��O^���^�� _��)_��6_��C_��o_���_���_���_���_�� t��!p��
* ����d4� ��� ���
* ��_���H��i686./strORBIT_SOCKETDIR=/tmp/orbit-dopombSSH_AGENT_PID
* =4208GLADE_PIXMAP_PATH=:/usr/share/glade3/pixmapsTERM=xtermSHELL=/bin/bashXDG
* _SESSION_COOKIE=e5cbfbe3a9ed4dde5577ed0e49fcaa10-1270745902.295512-286352254W
* INDOWID=44042625GTK_MODULES=canberra-gtk-moduleUSER=dopombLS_COLORS=no=00:fi=
* 00:di=01;34:ln=01;36:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40
* ;31;01:su=37;41:sg=30;43:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tg
* z=01;31:*.svgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.zip=01
* ;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz2=01
* ;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.rar=01;31:*.ace=01;31:*.z
* oo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;
* 35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.x
* pm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.mng=01;35:*.pcx=01
* ;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.ogm=01;35:*
* .mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=0
* 1;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*
* .gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.aac=00;36:*.au=00;3
* 6:*.flac=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.
* ogg=00;36:*.ra=00;36:*.wav=00;36:GLADE_MODULE_PATH=:/usr/lib/glade3/modulesGNO
* ME_KEYRING_SOCKET=/tmp/keyring-0h8Wlk/socketSSH_AUTH_SOCK=/tmp/ssh-qKDCcb4087/
* agent.4087SESSION_MANAGER=local/dopomb-laptop:/tmp/.ICE-unix/4222USERNAME=tobl
* erXDG_CONFIG_DIRS=/etc/xdg/xubuntu:/etc/xdgDESKTOP_SESSION=xfcePATH=/usr/local
* /sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/gamesGDM_XSERVER_LOCAT
* ION=localPWD=/home/dopomb/Software/c++/testLANG=en_US.UTF-8GNOME_KEYRING_PID=4
* 074GDMSESSION=xfceHISTCONTROL=ignorebothSHLVL=1HOME=/home/dopombGTK_PATH=:/usr/
* lib/gtk-2.0LOGNAME=dopombXDG_DATA_DIRS=/etc/xdg/xubuntu:/usr/local/share/:/usr
* /share/:/usr/share/gdm/:/usr/shareDBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/
* Segmentation fault
*/


Che cos'è successo in quest'ultimo passaggio? Non dovrebbero essere informazioni "riservate"?
Ringrazio chiunque possa illuminarmi e spero di non aver annoiato :)

[tomminno]

Perchè in C/C++ non esiste alcun controllo sui limiti degli array. La tua scoperta di informazioni può andare tranquillamente avanti fino a che non provi ad accedere ad un'area di memoria riservata che ti viene segnalata dal sistema operativo con un signal in Linux o una SEH in Windows.

Oltretutto molto probabilmente puoi anche sovrascrivere le informazioni che trovi oltre il limite del tuo array modificando il comportamento del programma.

Molti dei problemi di buffer overflow (e dei conseguenti bug di sicurezza) derviano da questo.

Personalmente ho smesso in C++ di usare gli array in ogni loro forma sostituendoli con vector (o la nuova classe std::tr1::array) essendo perfettamente compatibili con i tradizionali array.

[Unrue]

A questo punto le (per me) meravigliose scoperte! La segfault arrivava con "i" oscillante tra i 7000 e gli 11000: come mai così variabile? E prima di tutto, come mai non partiva già a i = 4, ovvero subito dopo il termine della stringa?




Prova a compilare con -O3 e vedrai che il sigfault avverrà molto prima ;)

[Duchamp]

Perchè in C/C++ non esiste alcun controllo sui limiti degli array. La tua scoperta di informazioni può andare tranquillamente avanti fino a che non provi ad accedere ad un'area di memoria riservata che ti viene segnalata dal sistema operativo con un signal in Linux o una SEH in Windows.


Ora capisco; Segmentation fault avviene quando esco dall'area di memoria che il sistema operativo ha assegnato al mio programma.
Sono inoltre d'accordo con te, vector (e string) sono delle ottime invenzioni :)


@ Unrue: non lo sapevo, farò subito un test... Leggendo il manuale sono rimasto impressionato dal numero di parametri di gcc, solo per l'ottimizzazione.

[insane74]

che linux usi?
io quando tempo fa ho provato a fare una cosa simile mi sono accorto che il programma si "piantava" in loop perché il sistema operativo gli impediva l'accesso ad aree di memoria "non consentite".

non so se è stato SELinux o altro, ma tant'è, il programma arrivato al termine dell'array s'è "piantato" (nessun crash, semplicemente cpu al 100% per quel processo, ma il resto del sistema era "pulito" e non compromesso). :confused:

altre volte anche con programmi "ufficiali" mi sono accorto di blocchi/messaggi di SELinux che avvisava di tentativi di accesso "non autorizzati". poi dando il "permesso" all'applicazione questa funzionava regolarmente... :stordita:

[Tommo]

In modalità debug di VC++, Windows si pianta senza ritegno se provi a fare una cosa del genere, al primo carattere che vai fuori :asd:

Ma in effetti non ho mai provato ad andare fuori apposta, magari in modo release...

[Duchamp]

che linux usi?
non so se è stato SELinux o altro, ma tant'è, il programma arrivato al termine dell'array s'è "piantato" (nessun crash, semplicemente cpu al 100% per quel processo, ma il resto del sistema era "pulito" e non compromesso). :confused:


Ho atteso un po' a rispondere perchè ad un tratto ho ottenuto anch'io il tuo risultato! Purtroppo non sono più riuscito a ripetere l'esperimento :( In ogni caso sono su un (x)ubuntu con uno degli ultimi kernel usciti.
Farò altri test.