Stack overflow: differenze tra le versioni

Versione delle 16:32, 28 mar 2009

Versione attuale delle 22:54, 22 giu 2025

(68 versioni intermedie di 38 utenti non mostrate)

Riga 1:

{{nota disambigua|il sito di Q&A omonimo|Stack Overflow (sito)|Stack Overflow}}

{{S|informatica}}

In [[informatica]], uno '''''stack overflow''''' avviene quando è richiesto l'uso di una quantità troppo elevata di [[Memoria (informatica)|memoria]] nello [[Allocazione dinamica della memoria|''stack'']].

Uno '''stack overflow''' consiste (solitamente) nella sovrascrittura della locazione di memoria interna allo stack contenente l''''indirizzo di ritorno''' oppure la copia del precedente '''frame pointer''' (vedi [[call stack]]). In modo tale, è possibile forzare il sistema a redirigere il flusso di esecuzione - nel momento del ritorno alla funzione chiamante - ad una locazione di memoria dove ha inizio del codice arbitrario.

In molti [[linguaggi di programmazione]], lo [[Call stack|stack delle chiamate]] contiene una quantità limitata di memoria, fissata di solito all'avvio del programma. La dimensione dello stack dipende da molteplici fattori, inclusi il linguaggio di programmazione, l'[[Architettura (computer)|architettura]] della macchina, l'uso del ''[[multithreading]]'' e la disponibilità di memoria nel sistema. Quando è usata troppa memoria nello ''stack'' si dice che avviene un ''[[Overflow aritmetico|overflow]]'', e si verifica un [[Crash (informatica)|crash]] del programma<ref name="fortran1">{{Cita web|cognome=Burley|nome=James Craig|titolo=Using and Porting GNU Fortran|url=http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html|data=1º giugno 1991|urlmorto=sì|urlarchivio=https://www.webcitation.org/6BBbWyyAU?url=http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html|dataarchivio=5 ottobre 2012}}</ref>. Questa classe di [[bug]] solitamente è causata da uno dei due tipi di errori di programmazione<ref name="devx">{{Cita web|cognome=Danny|nome=Kalev|titolo=Understanding Stack Overflow|url=http://www.devx.com/tips/Tip/14276|data=5 settembre 2000}}</ref>: la ricorsione infinita e l'uso di variabili di stack molto grandi.

I moderni sistemi operativi sono dotati di vari meccanismi di protezione e randomizzazione dello stack, e di riorganizzazione fisica delle variabili sensibili (per evitare la sovrascrittura di puntatori).

== Ricorsione infinita ==

=== Esempio di programma vulnerabile in Linux ===

{{Vedi anche|Loop infinito}}

<source lang="c">

La causa più comune di uno stack overflow è una [[ricorsione]] con profondità eccessiva o infinita.

#include <stdio.h>

#include <string.h>

I linguaggi che implementano la tecnica [[Algoritmo_ricorsivo#Eliminazione_della_ricorsione|''tail recursion'']], come ad esempio il linguaggio [[Scheme]], permettono una particolare ricorsione infinita che può essere eseguita senza ''stack overflow''. Questo avviene poiché le chiamate che fanno uso di ''tail recursion'' non richiedono uno spazio aggiuntivo nello ''stack''<ref name="tailRecur">{{Cita web|titolo=An Introduction to Scheme and its Implementation|url=http://www.federated.com/~jim/schintro-v14/schintro_73.html|data=19 febbraio 1997|urlmorto=sì|urlarchivio=https://web.archive.org/web/20070810213035/http://www.federated.com/~jim/schintro-v14/schintro_73.html|dataarchivio=10 agosto 2007}}</ref>.

int main(int argc, char *argv[])

{

char buf[16];

strcpy(buf, argv[1]);

};

</source>

== Variabili di stack molto grandi ==

Se '''0xbffff7c4''' è l'indirizzo di memoria di '''buf''', allora:

L'altra causa principale dello ''stack overflow'' è il tentativo di allocare più memoria di quella disponibile nello stack. Questo avviene quando si crea un [[array]] di [[Variabile (informatica)#Visibilità di una variabile|variabili locali]] molto grande. Per questo motivo gli array più grandi di qualche [[kilobyte]] dovrebbero essere [[Allocazione dinamica della memoria|allocati dinamicamente]] anziché allocarli come variabili locali<ref name="onlamp">{{Cita web|cognome=Feldman|nome=Howard|titolo=Modern Memory Management, Part 2|url=http://www.onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html|data=23 novembre 2005|accesso=10 novembre 2009|dataarchivio=20 settembre 2012|urlarchivio=https://web.archive.org/web/20120920112622/http://onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html|urlmorto=sì}}</ref>.

<source lang="text">

# gdb --args ./test `perl -e 'print "\xc8\xf7\xff\xbf"x5'`

GNU gdb 6.8-debian

Copyright (C) 2008 Free Software Foundation, Inc.

License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>

This is free software: you are free to change and redistribute it.

There is NO WARRANTY, to the extent permitted by law. Type "show copying"

and "show warranty" for details.

This GDB was configured as "i486-linux-gnu"...

(gdb) run

Starting program: /tmp/test �����������������

== Cause che possono ridurre la dimensione dello stack disponibile e quindi rendere più probabile uno ''stack overflow'' ==

Program received signal SIGILL, Illegal instruction.

Gli ''stack overflow'' sono aggravati da qualsiasi cosa riduca la dimensione effettiva dello ''stack'' di un programma.

0xbffff7da in ?? ()

Ad esempio un programma eseguito come ''[[Thread (informatica)|thread]]'' singolo potrebbe funzionare correttamente, ma se lo stesso programma è eseguito con ''thread'' multipli si verifica un crash del programma, perché molti programmi che usano i ''thread'' hanno a disposizione uno ''stack'' più piccolo per ogni singolo ''thread'' rispetto a un programma che non usa i ''thread''.

</source>

Allo stesso modo, chi studia lo [[sviluppo (informatica)|sviluppo]] di un [[kernel]] è invitato a non usare [[algoritmo ricorsivo|algoritmi ricorsivi]] e [[buffer]] molto grandi nello stack<ref name="apple1">{{Cita web|editore=[[Apple Inc]].|titolo=Kernel Programming Guide: Performance and Stability Tips|url=https://developer.apple.com/DOCUMENTATION/Darwin/Conceptual/KernelProgramming/style/chapter_5_section_5.html|data=7 novembre 2006|urlmorto=sì|urlarchivio=https://web.archive.org/web/20081207013401/http://developer.apple.com/DOCUMENTATION/Darwin/Conceptual/KernelProgramming/style/chapter_5_section_5.html|dataarchivio=7 dicembre 2008}}</ref><ref name="xenotime">{{Cita web|cognome=Dunlap|nome=Randy|titolo=Linux Kernel Development: Getting Started|url=http://www.xenotime.net/linux/mentor/linux-mentoring.pdf|data=19 maggio 2005|urlmorto=sì|urlarchivio=https://web.archive.org/web/20120227142532/http://www.xenotime.net/linux/mentor/linux-mentoring.pdf|dataarchivio=27 febbraio 2012}}</ref>.

redirige l'esecuzione alla locazione '''0xbffff7c8''', fino ad arrivare a 0xbffff7da dove è presente - in questo caso - un'istruzione non valida.

== Esempi nel linguaggio C/C++ ==

{{Portale|Sicurezza informatica}}

=== Ricorsione infinita con una funzione ===

<syntaxhighlight lang="c" line="1" copy=1>

void f() {

f();

}

int main(void) {

f();

return 0;

}

</syntaxhighlight>

Questo frammento di codice invoca la [[funzione (informatica)|funzione]] <code>f()</code>, e la funzione <code>f()</code> a sua volta richiama se stessa, generando in tal modo una ricorsione infinita.

[[Categoria:Tecniche di attacco informatico]]

=== Ricorsione infinita con due funzioni (mutuale) ===

[[en:Stack overflow]]

<syntaxhighlight lang="c" line="1" copy=1>

[[ja:スタックオーバーフロー]]

void f(void);

[[pl:Przepełnienie stosu]]

void g(void);

int main(void) {

f();

return 0;

}

void f(void) {

g();

}

void g(void) {

f();

}

</syntaxhighlight>

La funzione <code>f()</code> e la funzione <code>g()</code> si richiamano continuamente a vicenda, finché non si verifica lo ''stack overflow''.

=== Variabile nello stack eccessivamente grande ===

<syntaxhighlight lang="c" line="1" copy=1>

int main(void) {

double n[10000000];

return 0;

}

</syntaxhighlight>

L'array dichiarato in questo frammento di codice richiede più memoria di quella disponibile nello ''stack'', causando così uno ''stack overflow''.

== Note ==

<references />

== Voci correlate ==

* [[Heap overflow]]

* [[Buffer overflow]]

== Collegamenti esterni ==

* {{FOLDOC||stack overflow}}

{{Portale|informatica}}

[[Categoria:Gestione del software]]

[[Categoria:Terminologia informatica]]