Το προφίλ μας στο Google Plus
17

Format String Attack: Καταιγίδα εν αιθρία!

Στο παρόν post ασχολούμαστε με έναν κλασικό τύπο επιθέσεων που άφησε εποχή και ίσως ακόμα αφήνει, ο οποίος συνδυασμένος με τη μητέρα όλων των μαχών, το buffer overflow, πριν αρκετό καιρό ήταν ικανός να χτυπήσει επιτυχώς το 70% των διαδικτυακών server!

Ο λόγος γίνεται για το λεγόμενο format string attack, μια επίθεση που ανήκει στη λίστα των πιο συχνών επιθέσεων του The Web Application Security Consortium.

Προκειμένου ν’ αναλύσουμε τη συγκεκριμένη μεθοδολογία επίθεσης θα παίξουμε το ρόλο του ερευνητή ασφαλείας. Αναλυτικότερα, θα δούμε τι συμβαίνει στο παρασκήνιο κατά την προετοιμασία ενός άρθρου σαν αυτό που τώρα διαβάζετε. Έτσι θα φανεί πώς σκεφτόμαστε, τι εργαλεία χρησιμοποιούμε, τι παραμέτρους λαμβάνουμε υπόψη μας και πώς βγάζουμε τα συμπεράσματα μας. Γενικά, θα διαφανεί -πάντα μέσα από το πρίσμα του format string attack- πώς λειτουργούμε για να καταλήξουμε σε κάποιο συμπέρασμα, είτε αυτό είναι θετικό είτε αρνητικό είτε ακόμη και… άγνωστο. Αυτό το τελευταίο υπονοεί ότι δεν καταφέρνουμε πάντα να καταλήγουμε σε κάποιο χειροπιαστό συμπέρασμα. Διότι, μη νομίζετε, ο κόσμος της έρευνας έχει υψηλό δείκτη ασάφειας ή καλύτερα… εντροπίας!

Πάμε πρώτα να εξηγήσουμε τι ακριβώς είναι αυτό το format string attack. Η εν λόγω επίθεση εκμεταλλεύεται μια συγκεκριμένη αδυναμία που μπορεί να εμφανιστεί σε προγράμματα γραμμένα σε C/C++ ή ακόμη και σε Perl. Η αδυναμία αφορά στον τρόπο που εμφανίζουμε κάποιες μεταβλητές του προγράμματός μας. Υλοποιείται δε όταν αυτές τις μεταβλητές που εμφανίζουμε τις ζητάμε από το χρήστη κατά τη διάρκεια της εκτέλεσης του προγράμματος ή τις περάσουμε ως παραμέτρους κατά την κλήση του προγράμματος (π.χ., σε περίπτωση που το καλέσουμε από command line). Αν ο χρήστης είναι, χμ, ζωηρός, είναι δυνατόν να εξάγει από το πρόγραμμα δεδομένα τα οποία υπό φυσιολογικές συνθήκες δεν θα ‘πρεπε να ‘ναι προσβάσιμα! Το πρόβλημα θα γίνει καλύτερα κατανοητό με το ακόλουθο πρόγραμμα, σε C.

#include <stdio.h>
int main(int argc, char *argv[])
{
	if (argc != 2)	  // Αν ο χρήστης δεν έχει δώσει ακριβώς μία παράμετρο, κλείσε!
		return 0; // (το όνομα του προγράμματος θεωρείται πάντα ως η πρώτη παράμετρος)
	// Εμφάνισε το χαιρετισμό...
	printf("Format String Attack for deltaHacker!\n");
	// Εμφάνισε την παράμετρο που έδωσε ο χρήστης...
	printf(argv[1]);
	// Πες αντίο...
	printf("\nBye Bye!\n");
	// Επέστρεψε στο λειτουργικό σύστημα
	return 1;
}

Το πρόγραμμα περιμένει από το χρήστη να το καλέσει μαζί με ακριβώς μια παράμετρο, την οποία κι εμφανίζει. Ομολογουμένως, πρόκειται για ένα πάρα πολύ απλό πρόγραμμα. Ας ξεκινήσουμε όμως από την αρχή. Γράφουμε το πρόγραμμα σ’ έναν text editor και το αποθηκεύουμε με τ’ όνομα fma.c.

Στη συνέχεια το μετατρέπουμε σε εκτελέσιμο (executable) με χρήση κάποιου μεταγλωττιστή (compiler) της γλώσσας C. Εμείς, π.χ., θα καταφύγουμε στον Microsoft C++ compiler του Visual Studio 2008. Θα κάνουμε όμως μια πρωτοτυπία: Δεν θα καλέσουμε ολόκληρο το περιβάλλον του Visual Studio αλλά θα δουλέψουμε the good, old way, δηλαδή από την command line. Ακολουθούμε. λοιπόν, τη διαδρομή Start –> Programs –> Visual Studio 2008 –> Visual Studio Tools –> Visual Studio 2008 Command Prompt (βλ. εικόνα 1).

Εικόνα 1: Ναι, το compilation στα Windows με το Visual Studio 2008 μπορεί να γίνει *και* από τη γραμμή εντολής :)

Θα βγούμε σε γραμμή εντολών. Πρόκειται για το γνωστό command line windows του λειτουργικού, με τη διαφορά ότι έχουν προστεθεί πληροφορίες σε κάποιες μεταβλητές συστήματος για τη σωστή κλήση του compiler της Microsoft. Για να κάνουμε compile το πρόγραμμά μας απλά πληκτρολογούμε

C:\> cl fma.c

Αν έχουμε γράψει σωστά το πρόγραμμα και δεν έχουμε συντακτικά λάθη, ο compiler θα μας απαντήσει όπως φαίνεται στην εικόνα 2.

Εικόνα 2: Μεταγλώττιση του απλού προγράμματός μας σε C κάτω από στο command line των Windows, με χρήση του compiler που βρίσκεται στο Visual Studio 2008.

Μπορούμε τώρα να καλέσουμε το πρόγραμμα μας. Ιδού ένα παράδειγμα από τις δικές μας δοκιμές.

C:\> fma trelaras
Format String Attack for deltaHacker!
trelaras
Bye Bye!
C:\>_

Το πρόγραμμα, μετά το χαιρετισμό εμφάνισε τη λέξη που του δώσαμε και μετά τερματίστηκε. Για να κάνουμε τώρα κάτι πονηρό! Δίνουμε τα ακόλουθα:

C:\> fma trelaras:%p:%p:%p
Format String Attack for deltaHacker!
Trelaras:0018FF88:00401226:00000002
Bye Bye!
C:\>_

Ωχ! Αυτό δεν το περιμέναμε! Το πρόγραμμα δεν συμπεριφέρθηκε με τον αναμενόμενο τρόπο. Κάτι συμβαίνει εδώ. Τι είναι αυτοί οι αριθμοί, dammit;

0018FF88:00401226:00000002

Εμείς δώσαμε ό,τι και πριν, με τη διαφορά ότι τώρα προσθέσαμε τους λεγόμενους type field χαρακτήρες. Αυτοί οι χαρακτήρες χρησιμοποιούνται συχνά από τους προγραμματιστές της C, οι οποίοι καταφεύγουν στη συνάρτηση printf() θέλοντας να εμφανίσουν τις τιμές κάποιων μεταβλητών. Εμείς ως type fields βάλαμε τα %p:%p:%p, που σημαίνει ότι θέλουμε να εμφανίσουμε τις τιμές τριών μεταβλητών. Για την ακρίβεια, το “p” σημαίνει ότι θέλουμε να εμφανίσουμε μια μεταβλητή σε 16δική μορφή και συγκεκριμένα με τη μορφή 16δικής διεύθυνσης μνήμης. Η σειρά χαρακτήρων που δώσαμε θα μπει στη μεταβλητή argv[1] και στην πραγματικότητα το πρόγραμμα θα εκτελέσει την εντολή printf(argv[1]) ως εξής:

printf("trelaras:%p:%p:%p");

Ωραία μέχρι εδώ. Δηλώσαμε ότι θέλουμε να πάρουμε τις διευθύνσεις μνήμης τριών μεταβλητών. Που είναι όμως αυτές οι μεταβλητές; Χρησιμοποιούμε μεν το type field “%p” αλλά πρέπει να δηλώσουμε και τις μεταβλητές που θέλουμε να δούμε. Εμείς όμως -και καλά- το ξεχάσαμε! Και χωρίς να το καταλάβουμε -λέμε, τώρα- μόλις πραγματοποιήσαμε μια επίθεση format string. Τι είναι όμως αυτοί οι περίεργοι αριθμοί που εμφανίζονται; Από πού προέρχονται; Μπορεί κάποιος κακόβουλος χρήστης να τις χρησιμοποιήσει για να παραβιάσει την ασφάλεια μας; Χμ, αν ναι, τότε πρέπει να το ψάξουμε και να το αποδείξουμε αυτό. Πώς, όμως; Μα, με μια από τις προσφιλείς μας τακτικές: Θα λερώσουμε τα χέρια μας με τον Olly Debugger.

Θα ελέγξουμε το πρόγραμμά μας (με τη χρήση του Olly) κατά την εκτέλεσή του, προκειμένου να δούμε από πού προέρχονται αυτοί οι αριθμοί. Αμέσως μετά θα προσπαθήσουμε ν’ αποδείξουμε αν κάποιος μπορεί να χρησιμοποιήσει αυτή την τεχνική για να παραβιάσει την ασφάλεια ενός προγράμματός μας.

Ξεκινάμε τον Olly, δίνουμε File -> Open και καλούμε το πρόγραμμά μας. Θέλουμε αμέσως να βάλουμε ένα break point , ώστε μόλις πατήσουμε RUN να σταματήσει ο Olly σ’ εκείνο το break point και να ελέγξουμε όλες τις μεταβλητές του προγράμματος, μήπως και βρούμε κάπου τις

0018FF88:00401226:00000002 

Πού όμως θα βάλουμε αυτό το break point; Πρέπει να το βάλουμε στο σημείο που εμφανίζουμε τη λέξη trelaras. Πατάμε right click κι επιλέγουμε Search for –> All Referenced text strings (βλ. εικόνα 3).

Εικόνα 3: Βρίσκουμε το σημείο που θα βάλουμε το break point...

Επιλέγουμε ένα γνωστό σημείο στον κώδικα, το οποίο καλείται λίγο πριν την κλήση της συνάρτησης που πάμε να ελέγξουμε. Θέλουμε να σταματήσει το πρόγραμμά μας στο σημείο που εμφανίζουμε τον χαιρετισμό. Το επόμενο βήμα είναι να εισάγουμε τους χαρακτήρες που περάσαμε ως παραμέτρους κατά την κλήση του προγράμματος. Για να το κάνουμε δίνουμε Debug –> Arguments και εισάγουμε τις παραμέτρους που θέλουμε (βλ. εικόνα 4).

Εικόνα 4: Εισαγωγή των παραμέτρων που θα περάσουν στο πρόγραμμα...

Πατάμε στο RUN και περιμένουμε να σταματήσει ο Olly στο break point που βάλαμε. Πράγματι, μετά από λίγα χιλιοστά του δευτερολέπτου (αρκετός χρόνος, δεν συμφωνείτε;) ο Olly σταματά και μας περιμένει να κάνουμε κάποια ενέργεια. Εν προκειμένω, το μόνο που θα κάνουμε είναι να πατήσουμε το πλήκτρο [F8] διαδοχικά, ώστε να υποχρεώσουμε το πρόγραμμα να εκτελεί μια εντολή τη φορά, ελέγχοντας σε κάθε βήμα όλες τις μεταβλητές, το stack (κάτω δεξιά) αλλά και τους καταχωρητές (πάνω δεξιά). Πράγματι, μετά από λίγα πατήματα του [F8] βρισκόμαστε ένα βήμα πριν την εντολή που τυπώνει το “bye bye” (βλ. εικόνα 5).

Εικόνα 5: Ψάχνοντας το πρόγραμμά μας με τον Olly debugger...

Παρατηρήστε το stack, κάτω δεξιά. Περιέχει ακριβώς τις περίεργες εκείνες τιμές που εμφανίστηκαν όταν τρέξαμε το πρόγραμμά μας! Μπορούμε με ασφάλεια να πούμε ότι πρόκειται για μια αδυναμία του, αφού ο χρήστης τους μπορεί να εμφανίσει -κατά βούληση- τις τιμές του stack! Εδώ μερικοί θα σκεφτείτε -και με το δίκιο σας- κάτι σαν: “Ε, και λοιπόν; Τι είναι αυτό το τόσο σημαντικό που περιέχει αυτό το stack;”. Χμ, σε γενικές γραμμές, μεταξύ άλλων το stack περιέχει τις τιμές των μεταβλητών του προγράμματός μας. Δεν μπορεί -και δεν πρέπει- κανένας χρήστης να μπορεί να διαβάζει τις τιμές αυτές, αφού εκεί ενδέχεται να κρύβονται πολύ σημαντικές ή απόρρητες πληροφορίες, όπως κωδικοί, passwords, serials κ.λπ. Το όλο πρόβλημα δημιουργήθηκε από την παρακάτω εντολή:

printf(argv[1]);

Δυστυχώς, αυτή η τρύπα ασφαλείας θα ξέφευγε πάρα πολύ εύκολα από τους περισσότερους προγραμματιστές, κι αυτό διότι τα προαναφερθέντα προβλήματα πολύ σπάνια διδάσκονται στις αίθουσες διδασκαλίας. Βλέπετε, είναι άγνωστα ακόμα και στους ίδιους τους… διδάσκοντες! Ο τρόπος για να ξεπεράσουμε αυτή την αδυναμία είναι πάρα πολύ απλός. Για την ακρίβεια, όποτε θέλουμε να εμφανίζουμε μεταβλητές τότε οφείλουμε να χρησιμοποιούμε type field χαρακτήρες *μέσα* στην printf(). Με βάση αυτόν τον κανόνα, η παραπάνω εντολή θα έπρεπε να γίνει ως ακολούθως:

printf("%s",argv[1]);

Πρακτικά, λέμε στο πρόγραμμα: Εμφάνισε τη σειρά χαρακτήρων που βρίσκεται στη μεταβλητή argv[1]. Πράγματι, αν τρέξουμε το πρόγραμμά μας μ’ αυτή την διόρθωση, θα πάρουμε το παρακάτω:

C:\> fma trelaras:%p:%p:%p
Format String Attack for deltaHacker!
trelaras:%p:%p:%p
Bye Bye! 
C:\>_

Σίγουρα καλύτερο αποτέλεσμα, δεν νομίζετε; Μην πείτε όχι, γιατί δεν θα σας πιστέψουμε :)

Το θέμα που τίθεται τώρα είναι ν’ αποδείξουμε κι εμπράκτως ότι με τη χρήση αυτής της αδυναμίας ένας κακόβουλος χρήστης είναι δυνατόν να προβάλει -αλλά και να ξεσκεπάσει- το περιεχόμενο κάποιων μεταβλητών ενός προγράμματος, περιεχόμενο που με κανέναν τρόπο δεν θα ‘πρεπε να δει. Για το λόγο αυτό θα κατασκευάσουμε άλλο ένα πρόγραμμα, λίγο πιο σύνθετο από το προηγούμενο, το οποίο θα δημιουργεί ένα serial number. Θα φτιάξουμε φυσικά το πρόγραμμα με τέτοιον τρόπο, ώστε να πάσχει από την αδυναμία format string. Μετά θα μπούμε στη θέση του κακόβουλου χρήστη και θα προσπαθήσουμε να διαβάσουμε το serial, εκμεταλλευόμενοι την αδυναμία. Έχει ενδιαφέρον η δοκιμή μας αυτή, διότι κατ’ αυτόν τον τρόπο θα δούμε και πώς αποθηκεύονται τα δεδομένα στη μνήμη του υπολογιστή, καθώς το πρόγραμμά μας τα δημιουργεί. Θα δούμε, επίσης, πώς ακριβώς σκέφτονται και λειτουργούν οι σκοτεινοί τύποι που κλέβουν κωδικούς, serials κι άλλα τέτοια χαρωπά :S

Έστω λοιπόν ότι έχουμε ένα πρόγραμμα το οποίο θα δέχεται από τη γραμμή εντολών ένα password και με βάση αυτό θα δημιουργεί έναν σειραϊκό αριθμό. Ο αλγόριθμος είναι ο παρακάτω:
1. Ο χρήστης δίνει έναν κωδικό (τουλάχιστον τεσσάρων χαρακτήρων)
2. Το πρόγραμμα παίρνει τους πρώτους τέσσερις χαρακτήρες του κωδικού και καθέναν τους τον “κολλάει” στ’ αριστερά κάθε μέρους ενός σειραϊκού αριθμού.

Για παράδειγμα, αν ο χρήστης δώσει 1234 τότε το πρόγραμμα θα κολλήσει τα 1, 2, 3 και 4 σε κάθε ένα από τα μέρη του σειραϊκού αριθμού aaa-bbb-ccc-ddd. Έτσι, αυτός θα γίνει 1aaa-2bbb-3ccc-4ddd. Εντάξει, στην πραγματικότητα δεν πρόκειται για αριθμό, αφού δεν αποτελείται μόνο από αριθμητικά ψηφία, επιτρέψτε μας όμως να τον ονομάζουμε “σειραϊκό αριθμό γνησιότητας”. Ο κώδικας του προγράμματός μας φαίνεται (ελπίζουμε!) στην εικόνα 6.

Εικόνα 6: Ιδού το πρόγραμμα σε C για τη δημιουργία του σειραϊκού αριθμού...

Δεν θα σταθούμε στις λεπτομέρειες της συγγραφής του source code του προγράμματος, αλλά στ’ αποτελέσματα του. Πάμε να κατασκευάσουμε το exploitάκι μας, το οποίο θα εκμεταλλεύεται την αδυναμία που υπάρχει στη γραμμή 36 του προγράμματος. Θα χρησιμοποιήσουμε την τεχνική που αναπτύξαμε παραπάνω. Θα καλέσουμε το πρόγραμμα με μια αυθαίρετη σειρά χαρακτήρων, δίνοντας ως παράμετρο το 1234 μαζί μ’ αρκετά “%p”, τόσα όσα χρειάζονται για να διαβάσουμε σχεδόν όλες τις μεταβλητές που υπάρχουν στο stack – φυσικά μαζί με το ίδιο το serial number! Αποφασίσαμε να επαναλάβουμε το “%p” 30 φορές! Επειδή όμως βαριόμαστε να γράφουμε όλα αυτά τα “%p”, θα εκμεταλλευτούμε τη δύναμη της γλώσσας Perl:

perl -e " system 'fma2'.' 1234'.':%p'x30"

Τα αποτελέσματα της εκτέλεσης του προγράμματος fma2, πριν τα αναλύσουμε διεξοδικά τα βλέπουμε στην εικόνα 7.

Εικόνα 7: Παράξενα αποτελέσματα. Παράξενα και χαοτικά! Ή μήπως όχι;

Όπως βλέπετε, έχουμε τρέξει το πρόγραμμα δύο φορές: Την πρώτη με παράμετρο το 1234 και την άλλη δίνοντας το %p 30 φορές! Όπως είπαμε, με το %p εμφανίζουμε τα περιεχόμενα της μνήμης όπως αυτά καταχωρούνται στο stack. Αυτά εμφανίζονται σε 16δική μορφή αριθμών τεσσάρων byte ή αλλιώς ενός word. Έχετε υπόψη σας ότι τα δεδομένα καταχωρούνται “ανάποδα”, εξαιτίας της λογικής LIFO. Για παράδειγμα, η σειρά χαρακτήρων “abcd” θα εμφανιστεί ως bcda και πιο συγκεκριμένα στην ASCII μορφή. Θα δούμε, λοιπόν, το 64636261.

Ας αρχίσουμε να παρατηρούμε τα αποτελέσματα του προγράμματος μας. Κατ’ αρχάς, εμφανίζεται (σωστά) το 1234. Αυτό είναι το πρώτο μέρος της σειράς χαρακτήρων που δώσαμε, άρα και το πρώτο μέρος της μεταβλητής usercode που εμφανίζεται. Ακολουθεί η τιμή 3 (00000003). Μήπως σας θυμίζει τη μεταβλητή z; Ναι. Ακριβώς από κάτω εμφανίζονται και οι μεταβλητές x και y, με τιμές 1 και 2 αντίστοιχα. Ερχόμαστε τώρα στο ψητό: Στο κόκκινο πλαίσιο εμφανίζεται το serial number. Τι; Δεν το καταλάβατε; Ε, εντάξει, λογικό είναι, εκτός κι αν είστε καλός reverser ;) Θα το αποδείξουμε ευθύς αμέσως: Έχουμε 5 words, τα οποία αντιστοιχούν στους εξής χαρακτήρες:

WORD		>[<--Α->] [<--Β->] [<--C->] [<--D->] [<--E->]
TIMH		>61616131:6262322D:63332D62:342D6363:00646464:
ΧΑΡΑΚΤΗΡΕΣ	>a a a 1  b b 2 -  c 3 - b  4 - c c  0 d d d

Είπαμε όμως ότι οι χαρακτήρες είναι ανάποδα, μέσα στο word! Aν λοιπόν τους καθρεφτίσουμε θα τους δούμε όπως τους έδωσε ο χρήστης:

[A][B][C][D][E] = 1aaa-2bbb-3ccc-4ddd0

Σας θυμίζει τίποτα το 1aaa-2bbb-3ccc-4ddd; Εμάς, πάντως, κάτι μας λέει ;)

Μόλις αποδείξαμε ότι με τη χρήση της αδυναμίας format string ένας κακόβουλος χρήστης μπορεί να δει πράγματα που δεν προορίζονται γι’ αυτόν, παραβιάζοντας την αρχή της εμπιστευτικότητας και κατά συνέπεια παραβιάζοντας την ασφάλεια. Αντί επιλόγου, ν’ αναφέρουμε ότι στη βασική επίθεση format string αναφέρεται και η χρήση του type field χαρακτήρα %n, ο οποίος γράφει σε συγκεκριμένη διεύθυνση μνήμης. Πάντως τα τελευταίας τεχνολογίας λειτουργικά συστήματα αλλά και οι compilers, ενσωματώνουν προστασίες οι οποίες μας έκαναν να μην παρουσιάσουμε επίθεση με τη χρήση του “%n”, με το σκεπτικό ότι δεν είναι πλέον επίκαιρη. Για παράδειγμα, η Microsoft αγνοεί τ’ αποτελέσματα του “%n” στην printf(). Επίσης, τα εκτελέσιμα σε πολλές σύγχρονες διανομές Linux, κάθε φορά εκτελούνται σε διαφορετική base address, κάνοντας έτσι το γράψιμο σε προ-υπολογισμένη διεύθυνση (π.χ., σ’ αυτή του Instruction Pointer, για buffer overflow attacks) από δύσκολη έως αδύνατη. Αυτό βέβαια δεν μειώνει την επικινδυνότητα της επίθεσης σε προγράμματα που έχουν μεταγλωττιστεί με παλαιούς compilers ή μετά την επιπόλαιη απενεργοποίηση των προστατευτικών παραμέτρων.

17 Responses to “Format String Attack: Καταιγίδα εν αιθρία!”

  1. ariskos | 23/08/2011 at 21:58

    Πολύ ωραίο άρθρο αλλα θα ήθελα να σημειώσω οτι στην εικόνα με το 2ο πρόγραμμα που κάνετε επίθεση δεν είναι πλήρες ο κώδικας! Οι χρήστες θα πρέπει να προσθέσουν στην αρχή του κώδικα κάτω απο το #include “stdio.h” την ακόλουθη γραμμή #include “string.h” sorry που άργησα να κάνω register (subz) ;)

    • Thiseas | 23/08/2011 at 22:23

      @ ariskos
      Ενώ από θεωρητικής πλευράς έχεις δίκο δεν έχεις από πρακτικής. Και εξηγώ:
      Αν δημιουργήσεις το 2ο πρόγραμμα όπως το βλέπεις (χωρίς το string.h) και το κάνεις compile από command line με microsoft C++ δίνοντας την εντολή “cl fma2.c” δεν θα παραπονεθεί ο compiler αλλά ούτε και ο linker (που εδώ ίσως θα βρισκόταν το πρόβλημα – με unresolved external στην strcpy)! Επίσης το πρόγραμμα θα τρέξει κανονικά. ;)

  2. subZraw | 23/08/2011 at 22:05

    @ariskos Συγχωρεμένος, λόγω προτέρας καλής διαγωγής ;)

  3. electrovesta | 23/08/2011 at 22:56

    %d Responses to “Format String Attack: Καταιγίδα εν αιθρία!”???

    • praeto | 24/08/2011 at 01:26

      Είναι bug που έχει πέσει ήδη στην υπόληψή μας και θα διορθωθεί σύντομα.

      Καλύτερα τέτοια σχόλια να γίνονται στο ανάλογο forum για να μη βγαίνουμε off topic στα σχόλια της δημοσίευσης.

  4. ariskos | 24/08/2011 at 15:21

    χμμ εμένα πάντως είχε παράπονα ο compiler μάλλον επειδή χρησιμοποίησα GNU gcc compiler.

  5. mkosmas | 25/08/2011 at 06:26

    Πολύ ωραίο άρθρο! Ελπίζω να μην βγαίνω από το θέμα. Τους τελευταίους 2 μήνες μαθαίνω C++ στο πανεπιστήμιο. Δεν ξέρω καλά αυτή τη γλώσσα. Διαβάζοντας το άρθρο όμως μου γεννήθηκε μια απορία. Στον κώδικα αντί printf(usercode); χρησιμοποιούσαμε cout << usercode ; θα υπήρχε η ίδια ευπάθεια? (εμάς με cin και cout μας έμαθαν να δουλεύουμε μέχρι στιγμής, για το printf() διάβασα λίγα πράγματα online)

    • Thiseas | 25/08/2011 at 09:47

      Χμ, νομίζω οτι θα ήταν κρίμα να δώσω μια έτοιμη απάντηση σε μια τέτοια ερώτηση που σου δίνει την ευκαιρία να κάνεις ένα στοιχειώδη πειραματισμό μόνος σου και να αρχίζεις να επιβεβαιώνεις σιγά-σιγά την ιδιότητα και τα χαρακτηριστικά που πρέπει να έχει ένας γνήσιος αναγνώστης του Delta… ;-)

      • mkosmas | 25/08/2011 at 14:19

        Καλός. Έχω δουλειά όταν πάω σπίτι τότε. Thank you thiseas

    • ariskos | 26/08/2011 at 15:10

      Φίλε μου θα σου δώσω ενα μικρό “tip” σχετικά με την prinf και το cout κτλπ.. καταρχήν όταν άρχισα εγώ να γράφω προγράμματα σε c++ παρατήρησα ότι το μέγεθος τον προγραμμάτων ήταν 2mb++ με 1-2 εντολές και μόνο! Εκεί παραξενεύτικα και λέω τι στο καλό γίνετε! Παίξε λιγο με τα “#include” και αντί για cout βάλε printf και δες διαφορά! :)

  6. ^^TnT^^ | 25/08/2011 at 17:55

    Σωστά μας το έδειχνε εμάς ο καθηγητής :)

  7. giwrg98 | 02/09/2011 at 19:10

    Εγώ δεν κατάλαβα τι σχέση έχει το 61 με το γραμμα a. Επίσης τι είναι το stack και υπάρχει κανένα alternative αυτού του OllyDbg για Linux;

  8. Filippos | 03/09/2011 at 12:24

    Συγχαρητήρια για το άρθρο.
    @Thiseas: Να περιμένουμε και ένα άρθρο για το Buffer Overflow; Ναι ή ναι ;-)
    ^ Πρόταση ήταν αυτό!

Leave a Reply

You must be logged in to post a comment.

Σύνδεση

Αρχείο δημοσιεύσεων