Ειδική Επιστημονική Εργασία

Συμμετρικοί Αλγόριθμοι
Κρυπτογράφησης Δεδομένων –
Η περίπτωση του Αλγόριθμου
AES
Λυκούδης Κων/νος
Πτυχιούχος Τμήματος Φυσικής Πανεπιστημίου Πατρών

Πανεπιστήμιο Πατρών, 2/11/2012

 ΠΑΝΕΠΙΣΤΗΜΙΟ ΠΑΤΡΩΝ

ΔΙΑΤΜΗΜΑΤΙΚΟ ΠΡΟΓΡΑΜΜΑ ΜΕΤΑΠΤΥΧΙΑΚΩΝ ΣΠΟΥΔΩΝ

ΗΛΕΚΤΡΟΝΙΚΗ ΚΑΙ ΕΠΕΞΕΡΓΑΣΙΑ ΠΛΗΡΟΦΟΡΙΑΣ

Συμμετρικοί Αλγόριθμοι
Κρυπτογράφησης Δεδομένων –
Η περίπτωση του Αλγόριθμού
AES

Εγκρίθηκε από την τριμελή εξεταστική επιτροπή την 02/11/2012

στα πλαίσια του ΔΠΜΣ Ηλεκτρονικής και Επεξεργασίας της Πληροφορίας

___________________ ___________________ ___________________

Δημήτριος Μπακάλης Ευάγγελος Ζυγούρης Βλάσσης Σπυρίδων
Επίκουρος Καθηγητής Αναπληρωτής Καθηγητής Επίκουρος Καθηγητής
Τμήμα Φυσικής Τμήμα Φυσικής Τμήμα Φυσικής

Παν/μιο Πατρών Παν/μιο Πατρών Παν/μιο Πατρών

ΠΑΤΡΑ 2012
 Περίληψη

Στη σύγχρονη ζωή του ανθρώπου η ανταλλαγή και η διακίνηση της πληροφορίας
αποτελεί πλέον αναπόσπαστο κομμάτι. Η τεράστια ανάπτυξη των δικτύων
υπολογιστών και η επικοινωνία πληροφοριών κάθε μορφής έφερε ένα τεράστιο
πρόβλημα στην επιφάνεια, την ανάγκη για προστασία αυτής της πληροφορίας. Το
πρόβλημα αυτό καλείται να το αντιμετωπίσει η επιστήμη της Κρυπτογραφίας όπου
μέσα από διάφορους μετασχηματισμούς προσπαθεί θα μετατρέψει τα δεδομένα σε μια
ακατανόητη μορφή η οποία θα είναι δυνατόν να αντιστραφεί μόνο από τον νόμιμο
παραλήπτη. Για το λόγο αυτό έχουν αναπτυχθεί πληθώρα αλγορίθμων
κρυπτογράφησης όπου παρόλο που η δουλειά τους είναι η ίδια, χειρίζονται και
μετασχηματίζουν τα δεδομένα με διαφορετικό τρόπο.

Στην παρούσα εργασία γίνεται παρουσίαση του αλγορίθμου AES (Advanced Encryption
Standard) που αποτελεί το τρέχον πρότυπο από το NIST (National Institute of
Standards and Technology). Ο AES ο οποίος είναι και γνωστός ως Rijndael, είναι ένας
συμμετρικός αλγόριθμος τμήματος και βασίζεται στα δίκτυα μετάθεσης –
αντικατάστασης, ενώ είναι υλοποιήσιμος και γρήγορος τόσο σε λογισμικό όσο και σε
υλικό. Αντίθετα με τον προκάτοχο του DES, δεν χρησιμοποιεί το δίκτυο Feistel. matr
4x4 (128 bits), που ορίζεται ως κατάσταση (state), με τους περισσότερους
μετασχηματισμούς να πραγματοποιούνται σε ένα πεπερασμένο πεδίο. Ο αλγόριθμος
AES, δίνει τη δυνατότητα κρυπτογράφησης με τρία κλειδιά διαφορετικού μήκους, 128
bits κλειδί με 10 κύκλους επανάληψης, 192 bits κλειδί με 12 κύκλους επανάληψης και
256 bits κλειδί με 14 κύκλους επανάληψης παρουσιάζοντας κάθε φορά μεγάλη
ανθεκτικότητα σε κρυπταναλυτικές επιθέσεις.

Στα πλαίσια της εργασίας έγινε λεπτομερής ανάλυση των μετασχηματισμών που
χρησιμοποιεί ο AES στην κρυπτογράφηση και αποκρυπτογράφηση σύμφωνα με το
πρότυπο Fips-197 αρχικά σε θεωρητικό επίπεδο και έπειτα πραγματοποιήθηκαν
υλοποιήσεις σε λογισμικό και σε υλικό. Συγκεκριμένα, στο 1ο κεφάλαιο της εργασίας
γίνεται μια εισαγωγή στην Κρυπτογραφία, παρουσιάζοντας τις βασικές της έννοιες και
την ιστορική της εξέλιξη από τα πρώτα χρόνια εμφάνισης της ως σήμερα. Στο κεφάλαιο
2, αρχικά παρουσιάζονται τα υπάρχοντα κρυπτοσυστήματα, αναδεικνύοντας κάθε
φορά τον τρόπο με τον οποίο λειτουργούν, τους αλγόριθμους που υπάγονται σε αυτά
και τις εφαρμογές που έχουν. Στη συνέχεια γίνεται σύγκριση μεταξύ των αλγορίθμων
ενός συστήματος αλλά και μεταξύ των κρυπτοσυστημάτων. Το κεφάλαιο 3 αποτελεί το
κυρίως σώμα της εργασίας καθώς σε αυτό παρουσιάζεται και επεξηγείται ο αλγόριθμος
AES. Δίνεται το απαραίτητο μαθηματικό υπόβαθρο και αναλύονται οι μετασχηματισμοί
του αλγορίθμου. Παρουσιάζεται ο τρόπος που επεκτείνονται τα κλειδιά του αλγορίθμου
καθώς και οι διαδικασίες κρυπτογράφησης και αποκρυπτογράφησης. Τέλος γίνεται
αναφορά σε ζητήματα ασφάλειας και στην αντοχή του AES σε κρυπταναλυτικές
επιθέσεις, καθώς και στις εφαρμογές που χρησιμοποιείται. Στο 4ο κεφάλαιο
παρουσιάζονται και συγκρίνονται οι μέθοδοι υλοποίησης του αλγορίθμου.
Περιγράφεται μια υλοποίηση σε λογισμικό με τη χρήση της γλώσσας προγραμματισμού
C++, η οποία επεκτείνεται και σε μια διαδικτυακή υλοποίηση και μια υλοποίηση σε
υλικό με τη χρήση της περιγραφικής γλώσσας VHDL και το σχεδιαστικό εργαλείο
Quartus II. Τέλος στο 5ο κεφάλαιο εξάγονται συμπεράσματα και γίνονται προτάσεις για
μελλοντική εργασία.

i
ii
 Abstract

In modern life the exchange and transfer of information has become an integral part.
The enormous development of computer networks and the information communication
of every form,has brought a new massive problem on the surface, the need to protect
this information.The science of Cryptography is challenged to face this problem, so
through various transformations is trying to convert tha data in a incomprehensive
form, which will be possible to be inverted only from the legal receiver. For this reason a
variety of algorithms have been developed and although their work is the same, they
handle and convert data in different ways.

In the present thesis the AES (Advanced Encryption Standard) algorithm is presented,
which is the current standard of NIST (National Institute of Standards and Technology).
AES, which is also known as Rijndael, is a symmetric block cipher and is based on
substitution - permutation networks, while it can be efficiently implemented both in
software and hardware. Unlike it's predecessor DES, it does not use Feistel network. It
is applied in 4x4 Bytes matrix (128 bits),which is defined as state, with the most
transformations to be performed in a finite field. AES algorithm provides encryption
capability with three keys of different size: key of 128 bits with 10 rounds, key of 192
bits with 12 rounds and key of 256 bits with 14 rounds.

This thesis includes detailed analysis of transformtions that AES uses in ecryption and
decryption according to the Fips-197 standard, along with software and hardware
implementations. Specifically, in the first chapter an introduction to Cryptography is
made, presenting basic concepts and a historical overview. In chapter 2, contemporary
cryptosystems are introduced. In chapter 3 the AES algorithm is presented and
explained. The necessary mathematical background is provided and the transformations
of the algorithm are analysed. The way the algorithm keys are expanded is presented, as
well as the encryption and decryption processes. In chapter 4 the implementations of
AES are presented and compared. An implementation in software is described using the
programming language C++, and an implementation in hardware is given using the
VHDL language and the design tool Altera Quartus II. Finally in chapter 5 the conclusions
are given and proposals are made for future work.

iii
iv
 Ευχαριστίες

Με την ολοκλήρωση της παρούσας ειδικής επιστημονικής εργασίας, μου δίνεται η

ευκαιρία να ευχαριστήσω τον κ. Δ. Μπακάλη που στήριξε την προσπάθεια μου, με
καθοδήγησε και μου αφιέρωσε πολύ από τον πολύτιμο χρόνο του για να φτάσουμε ως
εδώ.

Επίσης ευχαριστώ για την πολύτιμη συνεργασία τη συνάδελφο Φλωκατούλα Δώρα με

την οποία μελετήσαμε και συνεργαστήκαμε γύρω από το αντικείμενο της
κρυπτογραφίας.

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

v
Περιεχόμενα
1.Εισαγωγή στην Κρυπτογραφία ...................................................................................................... 1
1.1 Εισαγωγικές έννοιες και Ορολογία ................................................................................... 1
1.2 Ιστορική Αναδρομή.................................................................................................................. 3
1.2.1 Πρώτη Περίοδος Κρυπτογραφίας (1900 π.Χ. – 1900 μ.Χ.) ................................. 3
1.2.2 Δεύτερη Περίοδος Κρυπτογραφίας (1900 μ.Χ. – 1950 μ.Χ.) .............................. 5
1.2.3 Τρίτη Περίοδος Κρυπτογραφίας (1950 μ.Χ. – Σήμερα.) ...................................... 6
1.3 Βασικές έννοιες κρυπτογραφίας ....................................................................................... 7
1.4 Αναγκαιότητα κρυπτογραφίας .......................................................................................... 9
1.5 Βασικοί στόχοι Κρυπτογραφίας ...................................................................................... 10
1.6 Ασφάλεια Κρυπτοσυστημάτων........................................................................................ 11
1.7 Εφαρμογές Κρυπτογραφίας .............................................................................................. 11
1.8 Κρυπτανάλυση ........................................................................................................................ 12
2.Κρυπτοσυστήματα και Αλγόριθμοι............................................................................................. 15
2.1 Κατηγορίες Κρυπτοσυστημάτων ........................................................................................ 15
2.2 Κλασσικά Κρυπτοσυστήματα ............................................................................................... 16
2.2.1 Αλγόριθμος του Καίσαρα................................................................................................ 17
2.2.2 Αλγόριθμος Vigenere ........................................................................................................ 18
2.2.3 Αλγόριθμος σημειωματάριου μιας χρήσης.............................................................. 19
2.3 Σύγχρονα Κρυπτοσυστήματα ............................................................................................... 20
2.3.1 Συμμετρικά Κρυπτοσυστήματα και Αλγόριθμοι .................................................. 20
2.3.2 Αλγόριθμοι Ροής (Stream Ciphers).............................................................................22
2.3.3 Αλγόριθμοι Τμήματος (Block Ciphers) ..................................................................... 24
2.3.3.1 Βασικές έννοιες και ορισμοί ................................................................................... 24
2.3.3.2 Μέθοδοι Γεμίσματος .................................................................................................. 28
2.3.3.2.1 Μηδενικό Γέμισμα (Zero Padding) ............................................................... 28
2.3.3.2.2 Σαφές Γέμισμα (Unambiguous Padding) ................................................... 28
2.3.3.3 Μέθοδοι Λειτουργίας.................................................................................................28
2.3.3.3.1 Electronic Codebook (ECB) Mode ................................................................. 29
2.3.3.3.2 Cipher Block Chaining (CBC) Mode .............................................................. 30
2.3.3.3.3 Cipher Feedback (CFB) Mode.......................................................................... 31
2.3.3.3.4 Output Feedback (OFB) Mode ........................................................................ 32
2.3.3.3.5 Counter Mode ........................................................................................................ 32
2.3.4 Συμμετρικοί Αλγόριθμοι Κρυπτογράφησης ........................................................... 33
2.3.4.1 Αλγόριθμος DES (Data Encryption Standard) .................................................33
2.3.4.2 Αλγόριθμος Triple DES ............................................................................................. 35
2.3.4.3 Αλγόριθμος AES (Advanced Encryption Standard) ...................................... 36
2.3.4.4 Αλγόριθμος IDEA (International Data Encryption Algorithm) ................37
2.3.4.5 Αλγόριθμος RC2 ........................................................................................................... 37

vi
 2.3.4.5 Αλγόριθμος RC4 ........................................................................................................... 37
2.3.4.6 Αλγόριθμος RC5 ........................................................................................................... 38
2.3.4.7 Αλγόριθμος RC6 ........................................................................................................... 38
2.3.4.8 Αλγόριθμος MARS .......................................................................................................38
2.3.4.9 Αλγόριθμος Serpent ................................................................................................... 39
2.3.4.10 Αλγόριθμος Twofish ................................................................................................ 39
2.3.4.11 Αλγόριθμος Blowfish............................................................................................... 39
2.3.4.12 Αλγόριθμος CAST-128 ............................................................................................ 40
2.3.4.13 Σύγκριση συμμετρικών αλγορίθμων ............................................................... 40
2.3.5 Ασύμμετρα Κρυπτοσυστήματα.................................................................................... 42
2.3.5.1 Αλγόριθμος RSA ........................................................................................................... 44
2.3.5.2 Ανταλλαγή κλειδιών κατά Diffie-Hellman........................................................ 45
2.3.5.3 Κρυπτογραφία Ελλειπτικής καμπύλης (ECC) ................................................. 46
2.3.5.4 Εφαρμογές Κρυπτογραφίας δημοσίου κλειδιού ...........................................47
2.3.5.4.1 Ψηφιακές Υπογραφές ........................................................................................ 48
2.3.5.4.2 Ψηφιακά Πιστοποιητικά................................................................................... 50
2.3.5.4.3 Διανομή μυστικών κλειδιών με Ασύμμετρο Κρυπτοσύστημα ..........51
2.3.6 Σύγκριση Συμμετρικών - Ασύμμετρων Κρυπτοσυστημάτων ......................... 52
3.Το πρότυπο AES .................................................................................................................................. 55
3.1 Ιστορική αναδρομή .................................................................................................................... 55
3.2 Κριτήρια αξιολόγησης υποψήφιων αλγορίθμων .......................................................... 56
3.3 AES - Γενικά .................................................................................................................................. 57
3.4 Μαθηματικό υπόβαθρο του AES .......................................................................................... 58
3.4.1 Το πεδίο (ή Σώμα) GF(28) ............................................................................................... 58
3.4.2 Πρόσθεση στο GF(28) ....................................................................................................... 58
3.4.3 Πολλαπλασιασμός στο GF(28) ...................................................................................... 58
3.4.4 Πολλαπλασιασμός πολυωνύμου με το x ..................................................................59
3.4.5 Πολλαπλασιασμός με συντελεστές στο GF(28) ..................................................... 60
3.4.6 Πολλαπλασιασμός πολυωνύμων με συντελεστές στο GF(28) με το x .........60
3.5 Κρυπτογράφηση ......................................................................................................................... 61
3.5.1 Μετασχηματισμός SubBytes()...................................................................................... 63
3.5.2 Μετασχηματισμός ShiftRows() .................................................................................... 66
3.5.3 Μετασχηματισμός MixColumns() ...............................................................................67
3.5.4 Μετασχηματισμός AddRoundKey() ...........................................................................68
3.6 Επέκταση κλειδιού..................................................................................................................... 69
3.7 Αποκρυπτογράφηση ................................................................................................................. 71
3.7.1 Μετασχηματισμός InvSubBytes() ............................................................................... 72
3.7.2 Μετασχηματισμός InvShiftRows() ............................................................................. 73
3.7.3 Μετασχηματισμός InvMixColumns() ........................................................................ 74

vii
 3.7.4 Αντίστροφος μετασχηματισμός AddRoundKey() ................................................74
3.7.5 Αλγόριθμος ισοδύναμης Αποκρυπτογράφησης.................................................... 74
3.8 Παρουσίαση διαδικασίας κρυπτογραφήσεως μέσω παραδείγματος ..................76
3.9 Ασφάλεια AES .............................................................................................................................. 81
3.10 Εφαρμογές ..................................................................................................................................81
4.Υλοποιήσεις AES..................................................................................................................................83
4.1 Κρυπτογραφία και λογισμικό ή υλικό ............................................................................... 83
4.2 Υλοποίηση σε Λογισμικό ......................................................................................................... 85
4.2.1 Ανάλυση προγράμματος ................................................................................................. 85
4.2.2 Παρουσίαση αποτελεσμάτων ....................................................................................... 89
4.3 Διαδικτυακή υλοποίηση .......................................................................................................... 91
4.4 VHDL υλοποίηση AES........................................................................................................... 95
4.4.1 AES-128 .............................................................................................................................. 96
4.4.1.1 Μονάδα παραγωγής κλειδιού............................................................................. 96
4.4.1.2 Μονάδα κρυπτογράφησης/αποκρυπτογράφησης ................................ 101
4.4.1.3 Μονάδα ελέγχου .................................................................................................... 108
4.4.1.4 AES-128 υλοποίηση και εξομοίωση .............................................................. 108
4.4.2 AES-128/192/256 .......................................................................................................... 114
4.4.2.1 Μονάδα παραγωγής κλειδιού ............................................................................. 114
4.4.2.2 Μονάδα ελέγχου ....................................................................................................... 119
4.4.2.3 AES-128/192/256 υλοποίηση και εξομοίωση............................................. 120
5.Συμπεράσματα .................................................................................................................................. 129
Αναφορές ................................................................................................................................................ 131
Παράρτημα Α ......................................................................................................................................... 135
Παράρτημα Β ......................................................................................................................................... 147

viii
ix
 1.Εισαγωγή στην Κρυπτογραφία

1.1 Εισαγωγικές έννοιες και Ορολογία

Κρυπτογραφία είναι ο επιστημονικός κλάδος που πραγματεύεται τη μελέτη και

σχεδίαση κρυπτογραφικών τεχνικών, συστημάτων και πρωτοκόλλων. Μαζί με τον
κλάδο της Κρυπτανάλυσης, που ασχολείται με τη μελέτη τρόπων παραβίασης αυτών,
απαρτίζουν την Επιστήμη της Κρυπτολογίας. Η επιθυμία προστασίας του
περιεχομένου μηνυμάτων οδήγησε στην επινόηση και χρήση κρυπτογραφικών
τεχνικών και συστημάτων τα οποία επιτρέπουν το μετασχηματισμό μηνυμάτων ή
δεδομένων κατά τέτοιον τρόπο ώστε να είναι αδύνατη η υποκλοπή του περιεχομένου
τους κατά τη μετάδοσή ή αποθήκευσή τους και, βεβαίως, την αντιστροφή του
μετασχηματισμού [5].

Ιστορικά η κρυπτογραφία χρησιμοποιήθηκε για την κρυπτογράφηση μηνυμάτων,

δηλαδή μετατροπή της πληροφορίας από μια κατανοητή μορφή σε έναν γρίφο, που
χωρίς τη γνώση του κρυφού μετασχηματισμού θα παρέμενε ακατανόητος. Κύριο
χαρακτηριστικό των παλαιότερων μορφών κρυπτογράφησης ήταν ότι η επεξεργασία
γινόταν πάνω στη γλωσσική δομή. Στις νεότερες μορφές η κρυπτογραφία κάνει χρήση
του αριθμητικού ισοδύναμου, η έμφαση έχει μεταφερθεί σε διάφορα πεδία των
μαθηματικών, όπως διακριτά μαθηματικά, θεωρία αριθμών, θεωρία πληροφορίας,
υπολογιστική πολυπλοκότητα, στατιστική και συνδυαστική ανάλυση [6].

Ορολογία

• Κρυπτογράφηση (encryption) ονομάζεται η διαδικασία μετασχηματισμού

ενός μηνύματος σε μια ακατανόητη μορφή με τη χρήση κάποιου
κρυπτογραφικού αλγορίθμου ούτως ώστε να μην μπορεί να διαβαστεί από
κανέναν εκτός του νόμιμου παραλήπτη.
• Η αντίστροφη διαδικασία όπου από το κρυπτογραφημένο κείμενο παράγεται το
αρχικό μήνυμα ονομάζεται αποκρυπτογράφηση (decryption).
• Κρυπτογραφικός αλγόριθμος (cipher) είναι η μέθοδος μετασχηματισμού
δεδομένων σε μια μορφή που να μην επιτρέπει την αποκάλυψη των
περιεχομένων τους από μη εξουσιοδοτημένα μέρη. Κατά κανόνα ο
κρυπτογραφικός αλγόριθμος είναι μια πολύπλοκη μαθηματική συνάρτηση.
• Αρχικό κείμενο (plaintext) είναι το μήνυμα το οποίο αποτελεί την είσοδο σε
μια διεργασία κρυπτογράφησης.
• Κλειδί (key) είναι ένας αριθμός αρκετών bit που χρησιμοποιείται ως είσοδος
στη συνάρτηση κρυπτογράφησης.
• Κρυπτογραφημένο κείμενο (ciphertext) είναι το αποτέλεσμα της εφαρμογής
ενός κρυπτογραφικού αλγορίθμου πάνω στο αρχικό κείμενο.
• Κρυπτανάλυση (cryptnalysis) είναι ο κλάδος της επιστήμης που ασχολείται
με τη μελέτη και την επινόηση μεθόδων που εξασφαλίζουν την κατανόηση του
νοήματος της κρυπτογραφημένης πληροφορίας, έχοντας ως άγνωστο το κλειδί
με βάση το οποίο πραγματοποιήθηκε και το κρυπτογραφημένο μήνυμα.

1
 Εικόνα 1. 1 Διαδικασία Κρυπτογράφησης/Αποκρυπτογράφησης.

Η διαδικασία της κρυπτογράφησης και αποκρυπτογράφησης φαίνεται στην Εικόνα 1. 1.

Η κρυπτογράφηση και αποκρυπτογράφηση ενός μηνύματος γίνεται με τη βοήθεια ενός

αλγορίθμου κρυπτογράφησης και ενός κλειδιού κρυπτογράφησης. Συνήθως ο
αλγόριθμος κρυπτογράφησης είναι γνωστός, οπότε η εμπιστευτικότητα του
κρυπτογραφημένου μηνύματος που μεταδίδεται βασίζεται ως επί το πλείστον στη
μυστικότητα του κλειδιού. Το μέγεθος του κλειδιού μετριέται σε αριθμό bits. Γενικά
ισχύει ο εξής κανόνας: όσο μεγαλύτερο είναι το κλειδί, τόσο δυσκολότερα μπορεί να
αποκρυπτογραφηθεί το κρυπτογραφημένο μήνυμα από επίδοξους εισβολείς.
Διαφορετικοί αλγόριθμοι κρυπτογράφησης απαιτούν διαφορετικά μήκη κλειδιών για
να πετύχουν το ίδιο επίπεδο ανθεκτικότητας κρυπτογράφησης [6].

Οι διαδικασίες της κρυπτογράφησης και αποκρυπτογράφησης μπορούν να

παρασταθούν, ισοδυνάμως είτε χρησιμοποιώντας μαθηματικές σχέσεις, είτε
σχηματικώς όπως φαίνεται στον Πίνακα 1. 1.

Μαθηματική παράσταση Συμβολική παράσταση

Κρυπτογράφηση c = ek (p)

Αποκρυπτογράφηση p = dk (c)

p: Αρχικό κείμενο
c: Κρυπτογραφημένο κείμενο
k: Κλειδί
e: Συνάρτηση κρυπτογραφήσεως
d: Συνάρτηση αποκρυπτογραφήσεως

Πίνακας 1. 1 Διαδικασία Κρυπτογράφησης/Αποκρυπτογράφησης.

2
Το κρυπτογραφημένο κείμενο αποτελεί το σημείο επέμβασης των πιθανών εισβολέων
του συστήματος με σκοπό την αποκάλυψη κάποιου από τα συστατικά του συστήματος
κρυπτογράφησης, συνήθως του κλειδιού, με σκοπό είτε την υποκλοπή του μηνύματος
(αποκάλυψη του αρχικού κειμένου) είτε την αλλοίωσή του.

1.2 Ιστορική Αναδρομή

Η εξέλιξη της κρυπτογραφίας χωρίζεται ιστορικά σε τρεις περιόδους:

• Η πρώτη ξεκινά περίπου το 1900 π.Χ. και τερματίζεται στις αρχές του εικοστού
αιώνα.
• Η δεύτερη περίοδος, ουσιαστικά καλύπτει το πρώτο μισό του εικοστού αιώνα.
• Η τρίτη και τελευταία περίοδος ξεκινά το 1950, με την έξαρση της ανάπτυξης στους
επιστημονικούς κλάδους των μαθηματικών, της μικροηλεκτρονικής και των
υπολογιστικών συστημάτων και συνεχίζεται μέχρι και τις ημέρες μας.

1.2.1 Πρώτη Περίοδος Κρυπτογραφίας (1900 π.Χ. – 1900 μ.Χ.)

Κατά τη διάρκεια αυτής της περιόδου αναπτύχθηκε μεγάλο πλήθος μεθόδων και
αλγορίθμων κρυπτογράφησης, που βασίζονταν κυρίως σε απλές αντικαταστάσεις
γραμμάτων. Όλες αυτές δεν απαιτούσαν εξειδικευμένες γνώσεις και πολύπλοκες
συσκευές, αλλά στηρίζονταν στην ευφυΐα και την ευρηματικότητα των δημιουργών
τους. Όλα αυτά τα συστήματα έχουν στις μέρες μας κρυπταναλυθεί και έχει αποδειχθεί
ότι, εάν είναι γνωστό ένα μεγάλο κομμάτι του κρυπτογραφημένου μηνύματος, τότε το
αρχικό κείμενο μπορεί σχετικά εύκολα να επανακτηθεί.
Όπως προκύπτει από μία μικρή σφηνοειδή επιγραφή, που ανακαλύφθηκε στις όχθες
του ποταμού Τίγρη, οι πολιτισμοί που αναπτύχθηκαν στη Μεσοποταμία ασχολήθηκαν
με την κρυπτογραφία ήδη από το 1500 π.Χ. Η επιγραφή αυτή περιγράφει μία μέθοδο
κατασκευής σμάλτων για αγγειοπλαστική και θεωρείται ως το αρχαιότερο
κρυπτογραφημένο κείμενο. Επίσης, ως το αρχαιότερο βιβλίο κρυπτοκωδικών στον
κόσμο, θεωρείται μία σφηνοειδής επιγραφή στα Σούσα της Περσίας. η οποία
περιλαμβάνει τους αριθμούς 1 έως 8 και από το 32 έως το 35, τοποθετημένους τον ένα
κάτω από τον άλλο, ενώ απέναντι τους βρίσκονται τα αντίστοιχα για τον καθένα
σφηνοειδή σύμβολα.
Η πρώτη στρατιωτική χρήση της κρυπτογραφίας αποδίδεται στους Σπαρτιάτες. Γύρω
στον 5ο π.Χ. αιώνα εφηύραν την “σκυτάλη”, την πρώτη κρυπτογραφική συσκευή, στην
οποία χρησιμοποίησαν για την κρυπτογράφηση τη μέθοδο της αντικατάστασης. Όπως
αναφέρει ο Πλούταρχος, η “Σπαρτιατική Σκυτάλη” (Εικόνα 1. 2), ήταν μια ξύλινη
ράβδος, ορισμένης διαμέτρου, γύρω από την οποία ήταν τυλιγμένη ελικοειδώς μια
λωρίδα περγαμηνής. Το κείμενο ήταν γραμμένο σε στήλες, ένα γράμμα σε κάθε έλικα,
όταν δε ξετύλιγαν τη λωρίδα, το κείμενο ήταν ακατάληπτο εξαιτίας της ανάμειξης των
γραμμάτων. Το κλειδί ήταν η διάμετρος της σκυτάλης.

Στην αρχαιότητα χρησιμοποιήθηκαν κυρίως συστήματα, τα οποία βασίζονταν στη

στεγανογραφία και όχι τόσο στην κρυπτογραφία. Οι Έλληνες συγγραφείς δεν
αναφέρουν αν και πότε χρησιμοποιήθηκαν συστήματα γραπτής αντικατάστασης
γραμμάτων, αλλά τα βρίσκουμε στους Ρωμαίους, κυρίως την εποχή του Ιουλίου

3
 Εικόνα 1. 2 Η Σπαρτιατική Σκυτάλη, μια πρώιμη συσκευή για την κρυπτογράφηση.

Καίσαρα. Ο Ιούλιος Καίσαρας έγραφε στον Κικέρωνα και σε άλλους φίλους του,
αντικαθιστώντας τα γράμματα του κειμένου, με γράμματα, που βρίσκονται 3 θέσεις
μετά, στο Λατινικό Αλφάβητο. Έτσι, σήμερα, το σύστημα κρυπτογράφησης που
στηρίζεται στην αντικατάσταση των γραμμάτων του αλφαβήτου με άλλα που
βρίσκονται σε καθορισμένο αριθμό θέσης πριν ή μετά, λέγεται κρυπτοσύστημα
αντικατάστασης του Καίσαρα. Ο Καίσαρας χρησιμοποίησε και άλλα, πιο πολύπλοκα
συστήματα κρυπτογράφησης, για τα οποία έγραψε ένα βιβλίο ο Valerius Probus, το
οποίο δυστυχώς δεν διασώθηκε, αλλά αν και χαμένο, θεωρείται το πρώτο βιβλίο
κρυπτολογίας. Το σύστημα αντικατάστασης του Καίσαρα, χρησιμοποιήθηκε ευρύτατα
και στους επόμενους αιώνες.

Στη διάρκεια του Μεσαίωνα, η κρυπτολογία ήταν κάτι το απαγορευμένο και

αποτελούσε μια μορφή αποκρυφισμού και μαύρης μαγείας, κάτι που συντέλεσε στην
καθυστέρηση της ανάπτυξής της. Η εξέλιξη, τόσο της κρυπτολογίας, όπως και των
μαθηματικών, συνεχίζεται στον Αραβικό κόσμο. Στο γνωστό μυθιστόρημα “Χίλιες και
μία νύχτες” κυριαρχούν οι λέξεις-αινίγματα, οι γρίφοι, τα λογοπαίγνια και οι
αναγραμματισμοί. Έτσι, εμφανίστηκαν βιβλία που περιείχαν κρυπταλφάβητα, όπως το
αλφάβητο “Dawoudi” που πήρε το όνομα του από τον βασιλιά Δαυίδ. Οι Άραβες είναι οι
πρώτοι που επινόησαν αλλά και χρησιμοποίησαν μεθόδους κρυπτανάλυσης. Το
κυριότερο εργαλείο στην κρυπτανάλυση, η χρησιμοποίηση των συχνοτήτων των
γραμμάτων κειμένου, σε συνδυασμό με τις συχνότητες εμφάνισης στα κείμενα των
γραμμάτων της γλώσσας, επινοήθηκε από αυτούς γύρω στον 14ο αιώνα. Η
κρυπτογραφία, λόγω των στρατιωτικών εξελίξεων, σημείωσε σημαντική ανάπτυξη
στους επόμενους αιώνες. Ο Ιταλός Giovanni Batista Porta, το 1563, δημοσίευσε το
περίφημο για την κρυπτολογία βιβλίο “De furtivis literarum notis”, με το οποίο έγιναν
γνωστά τα πολυαλφαβητικά συστήματα κρυπτογράφησης και τα διγραφικά
κρυπτογραφήματα, στα οποία, δύο γράμματα αντικαθίστανται από ένα. Σημαντικός
εκπρόσωπος εκείνης της εποχής είναι και ο Γάλλος Vigenere, του οποίου ο πίνακας
πολυαλφαβητικής αντικατάστασης, χρησιμοποιείται ακόμη και σήμερα.

Ο C.Wheatstone, γνωστός από τις μελέτες του στον ηλεκτρισμό, παρουσίασε την πρώτη
μηχανική κρυπτοσυσκευή, η οποία απετέλεσε τη βάση για την ανάπτυξη των
κρυπτομηχανών της δεύτερης ιστορικής περιόδου της κρυπτογραφίας. Η μεγαλύτερη
αποκρυπτογράφηση ήταν αυτή των αιγυπτιακών ιερογλυφικών τα οποία, επί αιώνες,
παρέμεναν μυστήριο και οι αρχαιολόγοι μόνο εικασίες μπορούσαν να διατυπώσουν για
τη σημασία τους. Ωστόσο, χάρη σε μία κρυπταναλυτική εργασία, τα ιερογλυφικά εν
τέλει αναλύθηκαν και έκτοτε οι αρχαιολόγοι είναι σε θέση να διαβάζουν ιστορικές
επιγραφές [6].

4
1.2.2 Δεύτερη Περίοδος Κρυπτογραφίας (1900 μ.Χ. – 1950 μ.Χ.)

Η δεύτερη περίοδος της κρυπτογραφίας τοποθετείται στις αρχές του 20ου αιώνα και
φτάνει μέχρι το 1950. Καλύπτει, επομένως, τους δύο παγκόσμιους πολέμους, εξαιτίας
των οποίων (λόγω της εξαιρετικά μεγάλης ανάγκης που υπήρξε για ασφάλεια κατά τη
μετάδοση ζωτικών πληροφοριών μεταξύ των στρατευμάτων των χωρών) αναπτύχθηκε
η κρυπτογραφία τόσο όσο δεν είχε αναπτυχθεί τα προηγούμενα 3000 χρόνια. Τα
κρυπτοσυστήματα αυτής της περιόδου αρχίζουν να γίνονται πολύπλοκα, και να
αποτελούνται από μηχανικές και ηλεκτρομηχανικές κατασκευές, οι οποίες ονομάζονται
“κρυπτομηχανές”. Η κρυπτανάλυση τους, απαιτεί μεγάλο αριθμό προσωπικού, το οποίο
εργαζόταν επί μεγάλο χρονικό διάστημα ενώ ταυτόχρονα γίνεται εξαιρετικά αισθητή η
ανάγκη για μεγάλη υπολογιστική ισχύ. Παρά την πολυπλοκότητα που αποκτούν τα
συστήματα κρυπτογράφησης κατά τη διάρκεια αυτής της περιόδου η κρυπτανάλυση
τους είναι συνήθως επιτυχημένη. Οι Γερμανοί έκαναν εκτενή χρήση (σε διάφορες
παραλλαγές) ενός συστήματος γνωστού ως Enigma (Εικόνα 1. 3).

Η μηχανή Αίνιγμα χρησιμοποιήθηκε ευρέως στη Γερμανία Ο Marian Rejewski, στην

Πολωνία, προσπάθησε και, τελικά, παραβίασε την πρώτη μορφή του γερμανικού
στρατιωτικού συστήματος Enigma (που χρησιμοποιούσε μια ηλεκτρομηχανική
κρυπτογραφική συσκευή) χρησιμοποιώντας θεωρητικά μαθηματικά το 1932. Ήταν η
μεγαλύτερη σημαντική ανακάλυψη στην κρυπτολογική ανάλυση της εποχής. Οι
Πολωνοί συνέχισαν να αποκρυπτογραφούν τα μηνύματα που βασίζονταν στην
κρυπτογράφηση με το Enigma μέχρι το 1939. Τότε, ο γερμανικός στρατός έκανε
ορισμένες σημαντικές αλλαγές και οι Πολωνοί δεν μπόρεσαν να τις παρακολουθήσουν,
επειδή η αποκρυπτογράφηση απαιτούσε περισσότερους πόρους από όσους μπορούσαν
να διαθέσουν. Έτσι, εκείνο το καλοκαίρι μεταβίβασαν τη γνώση τους, μαζί με μερικές
μηχανές που είχαν κατασκευάσει, στους Βρετανούς και τους Γάλλους. Ακόμη και ο
Rejewski και οι μαθηματικοί και κρυπτογράφοι του, όπως ο Biuro Szyfrow, κατέληξαν
σε συνεργασία με τους Βρετανούς και τους Γάλλους μετά από αυτή την εξέλιξη. Η
συνεργασία αυτή συνεχίστηκε από τον Άλαν Τούρινγκ (Alan Turing), τον Γκόρντον
Ουέλτσμαν (Gordon Welchman) και από πολλούς άλλους στο Μπλέτσλεϊ Παρκ
(Bletchley Park), κέντρο της Βρετανικής Υπηρεσίας απο/κρυπτογράφησης και οδήγησε
σε συνεχείς αποκρυπτογραφήσεις των διαφόρων παραλλαγών του Enigma, με τη
βοήθεια και ενός υπολογιστή, που κατασκεύασαν οι Βρετανοί επιστήμονες, ο οποίος
ονομάσθηκε Colossus και, δυστυχώς, καταστράφηκε με το τέλος του Πολέμου. Οι
κρυπτογράφοι του αμερικανικού ναυτικού (σε συνεργασία με Βρετανούς και
Ολλανδούς κρυπτογράφους μετά από το 1940) έσπασαν αρκετά κρυπτοσυστήματα του
Ιαπωνικού ναυτικού. Το σπάσιμο ενός από αυτά, του JN-25, οδήγησε στην αμερικανική
νίκη στη Ναυμαχία της Μιντγουέι καθώς και στην εξόντωση του Αρχηγού του
Ιαπωνικού Στόλου Ιζορόκου Γιαμαμότο.

Το Ιαπωνικό Υπουργείο Εξωτερικών χρησιμοποίησε ένα τοπικά αναπτυγμένο

κρυπτογραφικό σύστημα, και χρησιμοποίησε, επίσης, διάφορες παρόμοιες μηχανές για
τις συνδέσεις μερικών ιαπωνικών πρεσβειών. Μία από αυτές αποκλήθηκε "Μηχανή-Μ"
από τις ΗΠΑ, ενώ μια άλλη αναφέρθηκε ως “Red” (Κόκκινη). Μια ομάδα του
αμερικανικού στρατού, η αποκαλούμενη SIS, κατάφερε να σπάσει το ασφαλέστερο
ιαπωνικό διπλωματικό σύστημα κρυπτογράφησης (μια ηλεκτρομηχανική συσκευή, η
οποία ονομάστηκε "Purple" από τους Αμερικανούς) πριν καν ακόμη αρχίσει ο Β΄
Παγκόσμιος Πόλεμος. Οι Αμερικανοί αναφέρονται στο αποτέλεσμα της κρυπτανάλυσης,
ειδικότερα της μηχανής Purple, αποκαλώντας το ως Magic (Μαγεία).

5
 Εικόνα 1. 3 Μηχανή Enigma και Κρυπτομηχανή SIGABA.

Οι συμμαχικές κρυπτομηχανές που χρησιμοποιήθηκαν στο δεύτερο παγκόσμιο πόλεμο

περιλάμβαναν το βρετανικό TypeX και το αμερικανικό SIGABA (Εικόνα 1. 3). Και τα δύο
ήταν ηλεκτρομηχανικά σχέδια παρόμοια στο πνεύμα με το Enigma, με σημαντικές εν
τούτοις βελτιώσεις. Κανένα δεν έγινε γνωστό ότι παραβιάστηκε κατά τη διάρκεια του
πολέμου. Τα στρατεύματα στο πεδίο μάχης χρησιμοποίησαν το M-209 και τη λιγότερη
ασφαλή οικογένεια κρυπτομηχανών M-94. Οι Βρετανοί πράκτορες της Υπηρεσίας "SOE"
χρησιμοποίησαν αρχικά ένα τύπο κρυπτογραφίας που βασιζόταν σε ποιήματα (τα
απομνημονευμένα ποιήματα ήταν τα κλειδιά). Οι Γερμανοί, ώρες πριν την Απόβαση της
Νορμανδίας συνέλαβαν ένα μήνυμα - ποίημα του Πολ Βερλέν, για το οποίο, χωρίς να το
έχουν αποκρυπτογραφήσει, ήταν βέβαιοι πως προανήγγελλε την απόβαση. Η
Γερμανική ηγεσία δεν έλαβε υπόψη της αυτή την προειδοποίηση.

Οι Πολωνοί είχαν προετοιμαστεί για την εμπόλεμη περίοδο κατασκευάζοντας την

κρυπτομηχανή LCD Lacida, η οποία κρατήθηκε μυστική ακόμη και από τον Rejewski.
Όταν τον Ιούλιο του 1941 ελέγχθηκε από τον Rejewski η ασφάλειά της, του
χρειάστηκαν μερικές μόνον ώρες για να την "σπάσει" και έτσι αναγκάστηκαν να την
αλλάξουν βιαστικά. Τα μηνύματα που εστάλησαν με Lacida δεν ήταν, εντούτοις,
συγκρίσιμα με αυτά του Enigma, αλλά η παρεμπόδιση θα μπορούσε να έχει σημάνει το
τέλος της κρίσιμης κρυπταναλυτικής Πολωνικής προσπάθειας [6].

1.2.3 Τρίτη Περίοδος Κρυπτογραφίας (1950 μ.Χ. – Σήμερα.)

Αυτή η περίοδος χαρακτηρίζεται από την έξαρση της ανάπτυξης στους επιστημονικούς
κλάδους των μαθηματικών, της μικροηλεκτρονικής και των υπολογιστικών
συστημάτων. Η εποχή της σύγχρονης κρυπτογραφίας αρχίζει ουσιαστικά με τον Claude
Shannon, αναμφισβήτητα ο πατέρας των μαθηματικών συστημάτων κρυπτογραφίας.
Το 1949 δημοσίευσε το έγγραφο “Θεωρία επικοινωνίας των συστημάτων
μυστικότητας” (Communication Theory of Secrecy Systems) στο τεχνικό περιοδικό Bell
System και λίγο αργότερα στο βιβλίο του, “Μαθηματική Θεωρία της Επικοινωνίας”
(Mathematical Theory of Communication), μαζί με τον Warren Weaver. Αυτά, εκτός από
τις άλλες εργασίες του επάνω στη θεωρία δεδομένων και επικοινωνίας καθιέρωσε μια
στερεά θεωρητική βάση για την κρυπτογραφία και την κρυπτανάλυση. Εκείνη την
εποχή η κρυπτογραφία εξαφανίζεται και φυλάσσεται από τις μυστικές υπηρεσίες
κυβερνητικών επικοινωνιών όπως η NSA. Πολύ λίγες εξελίξεις δημοσιοποιήθηκαν ξανά
μέχρι τα μέσα της δεκαετίας του '70, όταν όλα άλλαξαν.

6
Στα μέσα της δεκαετίας του '70 έγιναν δύο σημαντικές δημόσιες (δηλ. μη-μυστικές)
πρόοδοι. Πρώτα ήταν η δημοσίευση του σχεδίου προτύπου κρυπτογράφησης DES (Data
Encryption Standard) στον ομοσπονδιακό κατάλογο της Αμερικής στις 17 Μαρτίου
1975. Το προτεινόμενο DES υποβλήθηκε από την ΙΒΜ, στην πρόσκληση του Εθνικού
Γραφείου των Προτύπων (τώρα γνωστό ως NIST), σε μια προσπάθεια να αναπτυχθούν
ασφαλείς ηλεκτρονικές εγκαταστάσεις επικοινωνίας για επιχειρήσεις όπως τράπεζες
και άλλες μεγάλες οικονομικές οργανώσεις. Μετά από τις συμβουλές και την
τροποποίηση από την NSA, αυτό το πρότυπο υιοθετήθηκε και δημοσιεύθηκε ως ένα
ομοσπονδιακό τυποποιημένο πρότυπο επεξεργασίας πληροφοριών το 1977 (αυτήν την
περίοδο αναφέρεται σαν FIPS 46-3). Ο DES ήταν ο πρώτος δημόσια προσιτός
αλγόριθμος κρυπτογράφησης που εγκρίνεται από μια εθνική αντιπροσωπεία όπως η
NSA. Η απελευθέρωση της προδιαγραφής της από την NBS υποκίνησε μια έκρηξη
δημόσιου και ακαδημαϊκού ενδιαφέροντος για τα συστήματα κρυπτογραφίας.

Ο DES αντικαταστάθηκε επίσημα από τον AES το 2001 όταν ανήγγειλε ο NIST το FIPS
197. Μετά από έναν ανοικτό διαγωνισμό, ο NIST επέλεξε τον αλγόριθμο Rijndael, που
υποβλήθηκε από δύο Φλαμανδούς κρυπτογράφους, για να είναι το AES. Ο DES και οι
ασφαλέστερες παραλλαγές του όπως ο 3DES ή TDES χρησιμοποιούνται ακόμα και
σήμερα, ενσωματωμένοι σε πολλά εθνικά και οργανωτικά πρότυπα. Εντούτοις, το
βασικό μέγεθος των 56-bit έχει αποδειχθεί ότι είναι ανεπαρκές να αντισταθεί στις
επιθέσεις ωμής βίας (μια τέτοια επίθεση πέτυχε να σπάσει τον DES σε 56 ώρες ενώ το
άρθρο που αναφέρεται ως το σπάσιμο του DES δημοσιεύτηκε από τον O'Reilly and
Associates). Κατά συνέπεια, η χρήση απλής κρυπτογράφησης με τον DES είναι τώρα
χωρίς αμφιβολία επισφαλής για χρήση στα νέα σχέδια των κρυπτογραφικών
συστημάτων και μηνύματα που προστατεύονται από τα παλαιότερα κρυπτογραφικά
συστήματα που χρησιμοποιούν DES, και όλα τα μηνύματα που έχουν αποσταλεί από το
1976 με τη χρήση DES, διατρέχουν επίσης σοβαρό κίνδυνο αποκρυπτογράφησης.
Ανεξάρτητα από την έμφυτη ποιότητά του, το βασικό μέγεθος του DES (56-bit) ήταν
πιθανά πάρα πολύ μικρό ακόμη και το 1976, πράγμα που είχε επισημάνει ο Whitfield
Diffie. Υπήρξε επίσης η υποψία ότι κυβερνητικές οργανώσεις είχαν ακόμα και τότε
ικανοποιητική υπολογιστική δύναμη ώστε να σπάσουν μηνύματα που είχαν
κρυπτογραφηθεί με τον DES [6].

1.3 Βασικές έννοιες κρυπτογραφίας

Ο αντικειμενικός στόχος της κρυπτογραφίας είναι να δώσει τη δυνατότητα σε δύο

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

Ένα κρυπτοσύστημα (σύνολο διαδικασιών κρυπτογράφησης - αποκρυπτογράφησης)

αποτελείται από μία πεντάδα (P,C,k,E,D):

1. Το P είναι ο χώρος όλων των δυνατών μηνυμάτων ή αλλιώς ανοικτών κειμένων

2. Το C είναι ο χώρος όλων των δυνατών κρυπτογραφημένων μηνυμάτων ή
αλλιώς κρυπτοκειμένων
3. Το k είναι ο χώρος όλων των δυνατών κλειδιών ή αλλιώς κλειδοχώρος
4. Η Ε είναι ο κρυπτογραφικός μετασχηματισμός ή κρυπτογραφική συνάρτηση
5. Η D είναι η αντίστροφη συνάρτηση ή μετασχηματισμός αποκρυπτογράφησης

7
Η συνάρτηση κρυπτογράφησης Ε δέχεται δύο παραμέτρους, μέσα από τον χώρο P και
τον χώρο k και παράγει μία ακολουθία που ανήκει στον χώρο C. Η συνάρτηση
αποκρυπτογράφησης D δέχεται δύο παραμέτρους, τον χώρο C και τον χώρο k και
παράγει μια ακολουθία που ανήκει στον χώρο P.

Το Σύστημα που φαίνεται στην Εικόνα 1. 4 λειτουργεί με τον ακόλουθο τρόπο :

1. Ο αποστολέας επιλέγει ένα κλειδί μήκους n από τον χώρο κλειδιών με τυχαίο
τρόπο, όπου τα n στοιχεία του Κ είναι στοιχεία από ένα πεπερασμένο
αλφάβητο.
2. Αποστέλλει το κλειδί στον παραλήπτη μέσα από ένα ασφαλές κανάλι.
3. Ο αποστολέας δημιουργεί ένα μήνυμα από τον χώρο μηνυμάτων.
4. Η συνάρτηση κρυπτογράφησης παίρνει τις δυο εισόδους (κλειδί και μήνυμα)
και παράγει μια κρυπτοακολουθία συμβόλων (έναν γρίφο) και η ακολουθία
αυτή αποστέλλεται διαμέσου ενός μη ασφαλούς καναλιού.
5. Η συνάρτηση αποκρυπτογράφησης παίρνει ως όρισμα τις δύο τιμές (κλειδί και
γρίφο) και παράγει την ισοδύναμη ακολουθία μηνύματος.

Ο αντίπαλος παρακολουθεί την επικοινωνία, ενημερώνεται για την κρυπτοακολουθία

αλλά δεν έχει γνώση για το κλειδί που χρησιμοποιήθηκε και δεν μπορεί να
αναδημιουργήσει το μήνυμα. Αν ο αντίπαλος επιλέξει να παρακολουθεί όλα τα
μηνύματα θα προσανατολιστεί στην εξεύρεση του κλειδιού. Αν ο αντίπαλος
ενδιαφέρεται μόνο για το υπάρχον μήνυμα θα παράγει μια εκτίμηση για την
πληροφορία του μηνύματος [6].

Εικόνα 1. 4 Μοντέλο τυπικού κρυπτοσυστήματος.

8
1.4 Αναγκαιότητα κρυπτογραφίας

Κατά τη διάρκεια των αιώνων έχουν δημιουργηθεί διάφορα πρωτοκόλλα και

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

Για παράδειγμα η μυστικότητα των γραμμάτων επιτυγχάνεται με τη βοήθεια

σφραγισμένων φακέλων και μίας κοινά αποδεκτής ταχυδρομικής υπηρεσίας. Η φυσική
ασφάλεια των φακέλων είναι, για πρακτικούς λόγους, περιορισμένη και για αυτό έχουν
θεσπιστεί νόμοι οι οποίοι καθορίζουν ως ποινικό αδίκημα το άνοιγμα ενός φακέλου από
μη εξουσιοδοτημένα πρόσωπα.

Μερικές φορές η ασφάλεια της πληροφορίας δεν εξασφαλίζεται από τον τρόπο με τον
οποίο είναι μετασχηματισμένη αλλά από το φυσικό έγγραφο στο οποίο καταγράφεται.
Αυτό αφορά την περίπτωση της στεγανογραφίας όπου ουσιαστικά το ίδιο το μήνυμα
αποκρύπτεται. Παλαιότερα για να επιτευχθεί αυτό χρησιμοποιείτο ειδικό μελάνι το
οποίο υπό ορισμένες προϋποθέσεις γινόταν αόρατο.

Ο τρόπος με τον οποίο η πληροφορία καταγράφεται δεν έχει αλλάξει δραματικά κατά
το πέρασμα του χρόνου, παρόλο που παλαιότερα η πληροφορία αποθηκευόταν και
μεταδιδόταν με τη βοήθεια του χαρτιού, ενώ πλέον διανέμεται με οπτικά μέσα και
μεταδίδεται μέσω τηλεπικοινωνιακών συστημάτων. Αυτό που έχει αλλάξει σημαντικά
είναι η δυνατότητα για αντιγραφή και μεταβολή της πληροφορίας. Ο οποιοσδήποτε έχει
τη δυνατότητα να δημιουργήσει χιλιάδες πανομοιότυπα αντίτυπα ενός τμήματος
πληροφορίας που είναι αποθηκευμένο ηλεκτρονικά, το καθένα από τα οποία να μην
ξεχωρίζει από το πρωτότυπο. Με την πληροφορία αποθηκευμένη σε χαρτί αυτό
απαιτούσε πολύ περισσότερη προσπάθεια.

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

Ένα από τα βασικότερα εργαλεία που χρησιμοποιείται για την ασφάλεια της
πληροφορίας είναι η υπογραφή. Αποτελεί θεμέλιο στοιχείο για πολλές υπηρεσίες
όπως η μη αποκήρυξη μίας ενέργειας, η επαλήθευση της προέλευσης της
πληροφορίας και η εξακρίβωση της ακεραιότητας της. Κάθε άτομο μαθαίνει να
δημιουργεί την δική του ξεχωριστή υπογραφή η οποία αποτελεί μέρος της ταυτότητάς
του. Με την ηλεκτρονικά αποθηκευμένη πληροφορία όμως αυτός ο τρόπος δεν μπορεί
να εφαρμοστεί, καθώς η ηλεκτρονική αντιγραφή μίας υπογραφής είναι πάρα πολύ
απλή διαδικασία.

Για την επίτευξη της ασφάλειας της πληροφορίας την σημερινή εποχή απαιτούνται
πολύ διαφορετικά τεχνικά μέσα και νομικά πλαίσια. Τα τεχνικά αυτά μέσα παρέχονται
από την κρυπτογραφία [9].

9
1.5 Βασικοί στόχοι Κρυπτογραφίας

Στο πλαίσιο της ασφάλειας των υπολογιστικών και επικοινωνιακών συστημάτων τα

διάφορα κρυπτογραφικά συστήματα θα πρέπει να παρέχουν τις τέσσερις παρακάτω
υπηρεσίες ασφαλείας:

1. Εμπιστευτικότητα (Confidentiality).

Εμπιστευτικότητα είναι η ιδιότητα των δεδομένων ή πληροφοριών να είναι

προσπελάσιμα μόνο από εξουσιοδοτημένα άτομα. Η εμπιστευτικότητα αναφέρεται στο
περιεχόμενο ηλεκτρονικών εγγράφων ή γενικά αρχείων και μηνυμάτων, στην ύπαρξή
τους και στην ταυτότητα αυτών που εκτελούν ενέργειες και ανταλλάσσουν μηνύματα.
Επίσης, αναφέρεται στο χρόνο και την ποσότητα μηνυμάτων που ανταλλάσσονται. Η
εμπιστευτικότητα, μερικές φορές, καλείται και “ιδιωτικότητα” ή “μυστικότητα” ή
“προστασία του απορρήτου”.

2. Ακεραιότητα (Integrity).

Η ακεραιότητα είναι η υπηρεσία κατά την οποία τα δεδομένα, οι πληροφορίες, οι

υπολογιστικοί και επικοινωνιακοί πόροι τροποποιούνται μόνο από εξουσιοδοτημένες
οντότητες κατά εξουσιοδοτημένο τρόπο. Η ακεραιότητα έχει να κάνει με την ακρίβεια
και τη συνέπεια στη λειτουργία συστημάτων και διεργασιών. Τα δεδομένα σε κάθε
σύστημα πρέπει να παραμένουν πλήρη και ορθά. Η ακεραιότητα διατηρείται όταν
διατηρούνται και οι εξής ιδιότητες: η ακρίβεια, η μη τροποποίηση ή τροποποίηση από
εξουσιοδοτημένους χρήστες ή διεργασίες, με συνέπεια, κατά αποδεκτό τρόπο. Έχουν
αναγνωριστεί τρεις καθοριστικές συνιστώσες του όρου ακεραιότητα: οι
“εξουσιοδοτημένες ενέργειες”, ο “διαχωρισμός και η προστασία αγαθών” και, τέλος, “η
ανίχνευση και διόρθωση σφαλμάτων”.

3. Επαλήθευση (authentication).

Οι υπηρεσίες αυτές παρέχουν επιβεβαίωση της ταυτότητας και απευθύνονται τόσο στις
οντότητες, όσο και στην ίδια την πληροφορία. Όταν δύο μέρη επικοινωνούν θα πρέπει
το καθένα από αυτά να επιβεβαιώσει την ταυτότητά του. Οι πληροφορίες οι οποίες
διακινούνται από ένα τηλεπικοινωνιακό κανάλι θα πρέπει να πιστοποιούν την
προέλευσή τους, την ημερομηνία δημιουργίας τους, το περιεχόμενο τους, την
ημερομηνία αποστολής τους κτλ. Για τους παραπάνω λόγους αυτή η υπηρεσία της
κρυπτογραφίας χωρίζεται σε δύο τμήματα:

1. Το πρώτο περιλαμβάνει την επαλήθευση μιας οντότητας (π.χ. μιας λέξης

πρόσβασης password) που επιβεβαιώνει την ταυτότητα ενός απομακρυσμένου
μέρους.
2. Το δεύτερο πραγματοποιεί την επαλήθευση της προέλευσης των δεδομένων που
επαληθεύει την ταυτότητα που ισχυρίζεται ότι έχει ένα τμήμα δεδομένων (π.χ. ένα
μήνυμα).

4. Μη αποκήρυξη (non repudiation).

Η υπηρεσία αυτή αποτρέπει μία οντότητα από το να αρνηθεί ότι μία επικοινωνία ή μία
συγκεκριμένη πράξη έχει ήδη πραγματοποιηθεί. Όταν μία πράξη αμφισβητείται από μία
οντότητα τότε χρειάζεται ένα μέσο προκειμένου να επιλύεται μία διαφωνία, όπου αυτή
προκύπτει. Έτσι υπάρχει προστασία έναντι μιας ανακριβούς άρνησης (μη παραδοχής)
ενός μέρους ότι μια συναλλαγή πράγματι έχει επισημοποιηθεί [9].

10
Ένας από τους βασικούς στόχους της κρυπτογραφίας είναι να εξασφαλίσει την
καλύτερη δυνατή ικανοποίηση των τεσσάρων προηγούμενων υπηρεσιών ασφαλείας
τόσο στη θεωρία όσο και στην πράξη. Αντικειμενικός της σκοπός είναι να ανακαλύψει
και να αποτρέψει οποιαδήποτε προσπάθεια εξαπάτησης ή κακόβουλη ενέργεια.

1.6 Ασφάλεια Κρυπτοσυστημάτων

Η ασφάλεια των κρυπτογραφικών συστημάτων, δηλαδή η ανθεκτικότητά τους σε

απόπειρες παραβίασης, είναι ένα από τα πρώτα ερωτήματα που τίθενται πριν
αποφασιστεί η χρησιμοποίησή τους σε πρακτικές εφαρμογές. Τα κρυπτογραφικά
συστήματα εμφανίζουν διάφορα επίπεδα ασφαλείας, ανάλογα με το πόσο δύσκολα
παραβιάζονται. Όλοι οι αλγόριθμοι (πλην του σημειωματάριου μίας χρήσης) είναι
θεωρητικά παραβιάσιμοι, δεδομένης επαρκούς υπολογιστικής ισχύος και
αποθηκευτικής χωρητικότητας. Μερικοί όμως αλγόριθμοι απαιτούν εκατομμύρια
χρόνια ανάλυσης ή απεριόριστους υπολογιστικούς πόρους προκειμένου να
παραβιαστούν. Αυτοί οι αλγόριθμοι είναι θεωρητικά παραβιάσιμοι, αλλά όχι και στην
πράξη. Ένας αλγόριθμος που δεν παραβιάζεται στην πράξη θεωρείται ασφαλής
(secure).

Ένας αλγόριθμος είναι απόλυτα ασφαλής (unconditionally secure), αν ανεξαρτήτως του

μεγέθους του κρυπτογραφημένου μηνύματος, των υπολογιστικών πόρων και του
χρόνου που μπορεί να διαθέτει ο κρυπταναλυτής, δεν υπάρχει δυνατότητα να
παραβιαστεί, δηλαδή να αποκαλυφθεί το αρχικό μήνυμα. Τα σημειωματάρια μίας
χρήσης, δεν μπορούν να παραβιασθούν, ακόμα και αν ο κρυπταναλυτής έχει στη
διάθεσή του άπειρους υπολογιστικούς και αποθηκευτικούς πόρους.

Ωστόσο, η σύγχρονη κρυπτογραφία ασχολείται κυρίως με κρυπτογραφικά συστήματα,

τα οποία δεν μπορούν να παραβιαστούν με τις δεδομένες υπολογιστικές δυνατότητες.
Ένας αλγόριθμος λέγεται υπολογιστικά ασφαλής (conditionally secure), ή δυνατός
(strong), αν είναι αδύνατη η παραβίασή του με τους διαθέσιμους (τωρινούς ή
μελλοντικούς) πόρους [10].

1.7 Εφαρμογές Κρυπτογραφίας

Η εξέλιξη της χρησιμοποίησης της κρυπτογραφίας ολοένα αυξάνεται καθιστώντας

πλέον αξιόπιστη τη μεταφορά της πληροφορίας για διάφορους λειτουργικούς σκοπούς.
Η ενσωμάτωση των μεθόδων της κρυπτογραφίας σε υλικό επιταχύνει σε μεγάλο βαθμό
την διεκπεραίωση της. Επίσης, οι χρήστες δεν γνωρίζουν, ούτε καν αντιλαμβάνονται
την παρουσία της και πραγματοποιούν ανενόχλητοι τις εργασίες τους. Το γεγονός ότι ο
χρήστης δεν ανακατεύεται καθόλου στις διαδικασίες της κρυπτογραφίας αυξάνει την
αποτελεσματικότητα του εργαλείου στην παρεχόμενη ασφάλεια. Παρ’ όλα αυτά, δεν
έχει καθιερωθεί η κρυπτογραφία σε υλικό λόγω του υψηλού κόστους της, που
απαγορεύει την αγορά και διατήρηση των ειδικών μηχανημάτων που χρειάζονται για
την εφαρμογή της. Τα ειδικά αυτά μηχανήματα βρίσκονται τοποθετημένα σε
στρατηγικά σημεία κάθε δικτύου. Η λογισμική κρυπτογραφία είναι φθηνότερη, πράγμα
που την κάνει ευρέως αποδεκτή και εύκολα πραγματοποιήσιμη. Βέβαια, δεν είναι το

11
ίδιο γρήγορη με την εκτέλεση της σε υλικό, αλλά η ολοένα αυξανόμενη ανάγκη για
διασφάλιση των επικοινωνιών εδραίωσε τη χρήση της [6].

Η κρυπτογραφία χρησιμοποιείται μεταξύ άλλων για:

1. Ασφάλεια συναλλαγών σε τράπεζες, δίκτυα - ΑΤΜ

2. Κινητή τηλεφωνία (GSM)
3. Σταθερή τηλεφωνία (cryptophones)
4. Διασφάλιση Εταιρικών πληροφοριών
5. Στρατιωτικά δίκτυα (Τακτικά συστήματα επικοινωνιών μάχης)
6. Διπλωματικά δίκτυα (Τηλεγραφήματα)
7. Ηλεκτρονικές επιχειρήσεις (πιστωτικές κάρτες, πληρωμές)
8. Ηλεκτρονική ψηφοφορία
9. Ηλεκτρονική δημοπρασία
10. Ηλεκτρονικό γραμματοκιβώτιο
11. Συστήματα συναγερμών
12. Συστήματα βιομετρικής αναγνώρισης
13. Έξυπνες κάρτες
14. Ιδιωτικά δίκτυα (VPN)
15. World Wide Web
16. Δορυφορικές εφαρμογές (δορυφορική τηλεόραση)
17. Ασύρματα δίκτυα (Hipperlan, Bluetooth, 802.11x)
18. Συστήματα ιατρικών δεδομένων και άλλων βάσεων δεδομένων
19. Τηλεσυνδιάσκεψη - Τηλεφωνία μέσω διαδικτύου (VOIP)

1.8 Κρυπτανάλυση

Προτού αναλυθούν οι διάφορες τεχνικές κρυπτογράφησης, παρουσιάζονται στην

παρούσα ενότητα οι τρόποι οι οποίοι χρησιμοποιούνται για την κρυπτανάλυση τους. Η
κρυπτανάλυση, όπως αναφέρθηκε και προηγουμένως, έχει ως στόχο την ανάπτυξη
τεχνικών και μεθόδων για την παραβίαση κρυπτογραφημένων μηνυμάτων ή
κρυπτογραφικών συστημάτων. Μία επιτυχής κρυπτανάλυση μπορεί να αποκαλύψει το
αρχικό από το κρυπτογραφημένο μήνυμα. Μπορεί συγχρόνως να εντοπίσει αδυναμίες
σε ένα κρυπτογραφικό σύστημα, οι οποίες οδηγούν τελικά στα παραπάνω
αποτελέσματα.

Στον Πίνακα 1. 2 παρουσιάζονται συνοπτικά διάφοροι τύποι επιθέσεων

κρυπτανάλυσης, οι οποίοι διαφοροποιούνται, μεταξύ άλλων, με βάση την ποσότητα και
το είδος της πληροφορίας που είναι γνωστή στον κρυπταναλυτή. Το πρόβλημα της
κρυπτανάλυσης παρουσιάζει σημαντικές δυσκολίες όταν είναι γνωστό στον
επιτιθέμενο μόνον το κρυπτογράφημα. Σε μερικές περιπτώσεις δεν είναι γνωστός ούτε
ο αλγόριθμος κρυπτογράφησης, αλλά στη γενική περίπτωση μπορεί να υποτεθεί ότι ο
αντίπαλος γνωρίζει τον αλγόριθμο που χρησιμοποιείται.

12
 Τύπος Επίθεσης Στοιχεία γνωστά στον κρυπταναλυτή
Επίθεση
• Αλγόριθμος κρυπτογράφησης
κρυπτογραφήματος
• Κρυπτογράφημα
(ciphertext – only attack)

Επίθεση γνωστού αρχικού
κειμένου (known – plaintext
attack)
• Αλγόριθμος κρυπτογράφησης
• Κρυπτογράφημα
• Ένα ή περισσότερα ζεύγη (αρχικού κειμένου,
κρυπτογραφήματος), παραγόμενα από το μυστικό
κλειδί

Επίθεση επιλεγμένου
αρχικού κειμένου
(chosen – plaintext attack)
Επίθεση επιλεγμένου
κρυπτογραφήματος
(chosen – ciphertext attack)
Επίθεση επιλεγμένου
κειμένου (chosen – text
attack)
• Αλγόριθμος κρυπτογράφησης
• Κρυπτογράφημα
• Αρχικό κείμενο επιλεγμένο από τον κρυπταναλυτή,
σε συνδυασμό με το αντίστοιχο κρυπτογράφημα
που παράγεται με το μυστικό κλειδί
• Αλγόριθμος κρυπτογράφησης
• Κρυπτογράφημα
• Επιλεγμένο απ’ τον κρυπταναλυτή κρυπτογράφημα,
μαζί με το αντίστοιχο αποκρυπτογραφημένο αρχικό
κείμενο, που παράχθηκε με το μυστικό κλειδί
• Αλγόριθμος κρυπτογράφησης
• Κρυπτογράφημα
• Επιλεγμένο από τον κρυπταναλυτή μήνυμα αρχικού
κειμένου, μαζί με το αντίστοιχο κρυπτογράφημα,
που παράχθηκε με το μυστικό κλειδί
• Επιλεγμένο από τον κρυπταναλυτή
κρυπτογράφημα, μαζί με το αντίστοιχο
αποκρυπτογραφημένο αρχικό κείμενο, που
παράχθηκε με το μυστικό κλειδί

Πίνακας 1. 2 Τύποι επιθέσεων σε κρυπτογραφημένα μηνύματα.

Μια κλασική επίθεση υπό αυτές τις περιστάσεις αποτελεί η προσέγγιση της
εξαντλητικής αναζήτησης κλειδιών (brute-force attack), όπου ο επιτιθέμενος δοκιμάζει
διαδοχικά όλα τα στοιχεία από το πεδίο όλων των πιθανών κλειδιών. Εάν το μέγεθος
του κλειδιού είναι μεγάλο, η επίθεση αυτού του είδους θεωρείται πρακτικά
ατελέσφορη. Κατά συνέπεια, ένας επιτιθέμενος για να είναι αποτελεσματικός θα πρέπει
να αξιοποιήσει ανάλυση του κρυπτογραφήματος εφαρμόζοντας διάφορες στατιστικές
δοκιμές σε αυτό. Ο επιτιθέμενος για να χρησιμοποιήσει αυτή την προσέγγιση θα πρέπει
να γνωρίζει τον τύπο του αρχικού κειμένου που χρησιμοποιείται, π.χ. ένα απλό κείμενο
σε συγκεκριμένη γλώσσα, ένα εκτελέσιμο αρχείο σε περιβάλλον συγκεκριμένου
λειτουργικού συστήματος, ένα αρχείο με πηγαίο κώδικα σε συγκεκριμένη γλώσσα
προγραμματισμού κλπ.

Η άμυνα σε επίθεση κρυπτογραφήματος (ciphertext only attack) αποτελεί γενικά

εύκολη υπόθεση, επειδή ο αντίπαλος διατηρεί μικρή ποσότητα πληροφοριών με την
οποία μπορεί να ασχοληθεί. Παρόλα αυτά, σε πολλές περιπτώσεις ο κρυπταναλυτής
μπορεί να διαθέτει και περισσότερες πληροφορίες. Ο κρυπταναλυτής μπορεί να έχει τη
δυνατότητα να καταγράψει ένα ή περισσότερα μηνύματα αρχικού κειμένου, καθώς
επίσης και τα αντίστοιχα κρυπτογραφήματα. Σε άλλη περίπτωση, μπορεί να γνωρίζει

13
ότι συγκεκριμένα πρότυπα αρχικού κειμένου θα εμφανιστούν σε ένα μήνυμα. Για
παράδειγμα, ένα αρχείο σε μορφή postscript αρχίζει πάντοτε με το ίδιο πρότυπο, ή
μπορεί να υπάρξει μία τυποποιημένη επικεφαλίδα ή ένα λογότυπο σε ένα ηλεκτρονικό
μήνυμα μεταφοράς κεφαλαίων. Τα προαναφερόμενα παραδείγματα αποτελούν
επιθέσεις γνωστών μηνυμάτων. Με αυτή τη γνώση ο αναλυτής μπορεί να είναι σε θέση
να συμπεράνει το κλειδί, με βάση τον τρόπο που μετασχηματίστηκε το γνωστό αρχικό
κείμενο.

Αντίστοιχη με την επίθεση γνωστών μηνυμάτων (known plaintext attack) είναι η

επίθεση πιθανής-λέξης (probable-word attack). Εάν ο επιτιθέμενος ασχολείται με την
κρυπτανάλυση κάποιου μηνύματος αγνώστου περιεχομένου μπορεί να μην κατανοεί
επακριβώς το περιεχόμενο του μηνύματος. Παρόλα αυτά, εάν ο επιτιθέμενος αναζητά
συγκεκριμένες πληροφορίες, τότε κάποια τμήματα του μηνύματος μπορούν να
θεωρηθούν γνωστά. Για παράδειγμα, εάν διαβιβάζεται ολόκληρο λογιστικό αρχείο, ο
επιτιθέμενος μπορεί να είναι σε θέση να γνωρίζει τη θέση κάποιων λέξεων-κλειδιών
στην επικεφαλίδα του αρχείου. Άλλο παράδειγμα αποτελεί ο πηγαίος κώδικας ενός
προγράμματος που αναπτύχθηκε από κάποια εταιρία και ο οποίος μπορεί να
περιλαμβάνει δήλωση πνευματικών δικαιωμάτων σε κάποια συγκεκριμένη θέση.

Εάν ο κρυπταναλυτής μπορεί με κάποιο τρόπο να παραπλανήσει το πηγαίο σύστημα

ώστε να παρεμβάλλει ένα μήνυμα που έχει επιλέξει ο ίδιος, τότε είναι πιθανή μία
επίθεση επιλεγμένων μηνυμάτων. Γενικά, εάν ο κρυπταναλυτής είναι σε θέση να
επιλέγει τα μηνύματα για κρυπτογράφηση τότε μπορεί σκόπιμα να επιλέγει πρότυπα
που αναμένεται να τον υποβοηθήσουν στην αποκάλυψη της δομής του κλειδιού.

Στον Πίνακα 1. 2 εμφανίζονται και άλλοι δύο τύποι επίθεσης, η επίθεση επιλεγμένου
κρυπτογραφήματος (chosen ciphertext attack) και η επίθεση επιλεγμένου κειμένου
(chosen text attack), επιθέσεις οι οποίες δεν επιχειρούνται συχνά ως τεχνικές
κρυπτανάλυσης, μπορούν όμως να αποτελέσουν δυνητικούς τρόπους επίθεσης [8].

14
 2.Κρυπτοσυστήματα και Αλγόριθμοι

2.1 Κατηγορίες Κρυπτοσυστημάτων

Τα κρυπτογραφικά συστήματα ταξινομούνται, γενικά, με βάση τρία ανεξάρτητα

κριτήρια.

• Τον τύπο των διαδικασιών που χρησιμοποιούνται για το μετασχηματισμό του

αρχικού κειμένου σε ένα κρυπτογράφημα

Το σύνολο των αλγορίθμων κρυπτογράφησης στηρίζεται σε δύο γενικές αρχές: στην

αντικατάσταση (substitution) σύμφωνα με την οποία κάθε στοιχείο του αρχικού
κειμένου, είτε είναι δυαδικό ψηφίο, είτε χαρακτήρας, είτε ομάδα δυαδικών ψηφίων ή
χαρακτήρων, αντικαθίσταται από άλλο στοιχείο και στη μετάθεση (permutation) στην
οποία τα στοιχεία του αρχικού κειμένου αναδιατάσσονται. Βασική προϋπόθεση
αποτελεί η μη απώλεια οποιασδήποτε πληροφορίας, ώστε όλες οι διαδικασίες να είναι
αντιστρέψιμες. Τα περισσότερα συστήματα, που είναι γνωστά ως συστήματα
παραγωγής (product systems), περιλαμβάνουν πληθώρα σταδίων αντικαταστάσεων
και μεταθέσεων.

• Τον αριθμό των κλειδιών που χρησιμοποιούνται

Εάν ο πομπός και ο δέκτης χρησιμοποιούν το ίδιο κλειδί, τότε το σύστημα αναφέρεται
ως συμμετρικό ή μοναδικού κλειδιού ή μυστικού κλειδιού ή συμβατικής
κρυπτογραφίας. Εάν, όμως, ο πομπός και ο δέκτης χρησιμοποιούν διαφορετικά κλειδιά,
τότε το σύστημα αναφέρεται ως ασύμμετρο, ή σύστημα ζεύγους κλειδιών, ή
κρυπτογραφίας δημοσίου κλειδιού.

• Τον τρόπο με τον οποίο επεξεργάζεται το αρχικό κείμενο

Ένας κωδικοποιητής τμημάτων (block cipher) επεξεργάζεται την είσοδο ενός τμήματος
στοιχείων κάθε φορά, παράγοντας ένα τμήμα εξόδου για κάθε συγκεκριμένο τμήμα
εισόδου. Αντίθετα, ένας κωδικοποιητής ροής (stream cipher) επεξεργάζεται κατά
συνεχή τρόπο τα στοιχεία εισόδου και κάθε φορά παράγεται ως έξοδος ένα στοιχείο, με
τη σειρά που καταφθάνουν τα δεδομένα[8].

15
 Κρυπτοσυστήματα

Κλασσικά Μοντέρνα
Κρυπτοσυστήματα Κρυπτοσυστήματα

Μετάθεσης Συμμετρικά

Πολυσταδιακές Μονοσταδιακές
Συμμετρικοί Ψευδοτυχαίες
κρυπταλγόριθμοι ακολουθίες

Αντικατάστασης
Συναρτήσεις Ψηφιακές
κατακερματισμού υπογραφές

Μονοαλφαβητικής Πολυαλφαβητικής
Ασύμμετρα

Πολυγραμματικής Ομοφωνικής
Συμμετρικοί Ψηφιακές
κρυπταλγόριθμοι υπογραφές

Σημειοματάριο μιας χρήσης

Ρότορες

Εικόνα 2. 1 Μπλοκ διάγραμμα Κρυπτοσυστημάτων.

2.2 Κλασσικά Κρυπτοσυστήματα

Κρυπτοσύστημα μετάθεσης.

Πρόκειται για μία απλή κρυπτογραφική μέθοδο κατά την οποία το κρυπτοκείμενο
προκύπτει με απλή αντιμετάθεση της διαδοχής των συμβόλων του αρχικού κειμένου.
Αυτό συνεπάγεται ότι το κρυπτοκείμενο αποτελείται από τα ίδια σύμβολα με αυτά του
αρχικού κειμένου και το μέγεθος του παραμένει σταθερό [11]. Υπάρχουν δύο τύποι
τέτοιων κρυπτοσυστημάτων:

• Τα μονοσταδιακά όπου η αντιμετάθεση των χαρακτήρων πραγματοποιείται

μόνο μία φορά.
• Τα πολυσταδιακά όπου εφαρμόζεται περισσότερες από μία φορές ο ίδιος ή
διαφορετικός αλγόριθμος αναδιάταξης.

Κρυπτοσύστημα αντικατάστασης.

Στην περίπτωση αυτή τμήματα του αρχικού κειμένου αντικαθίστανται από σύμβολα
του κρυπτογραφικού αλφαβήτου, σύμφωνα με κάποιους καθορισμένους κανόνες. Τα
τμήματα αυτά μπορεί να αποτελούνται από ένα ή περισσότερα γράμματα [12].
Διακρίνονται οι παρακάτω περιπτώσεις:

• Μονοαλφαβητική μετάθεση. Στην περίπτωση αυτή κάθε γράμμα ή σύμβολο

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

16
 • Πολυαλφαβητική μετάθεση. Όπως και στη μονοαλφαβητική μετάθεση κάθε
σύμβολο του αρχικού κειμένου αντικαθίσταται από ένα άλλο σύμβολο με τη
διαφορά ότι χρησιμοποιούνται για την κρυπτογράφηση περισσότερα του ενός
κρυπτογραφικά αλφάβητα. Παραδείγματα αποτελούν ο κώδικας του Vigenere
και το κρυπτογραφικό αλφάβητο που χρησιμοποιείται από τις μηχανές
κρυπτογράφησης που λειτουργούσαν με τροχούς, όπως η Enigma.
• Πολυγραφική ή πολυγραμματική μετάθεση. Πρόκειται για μια
κρυπτογραφική μέθοδο στην οποία, σε αντίθεση με τη μονοαλφαβητική
μετάθεση, δεν αντιστοιχίζεται κάθε γράμμα σε ένα διαφορετικό του
κρυπτογραφικού αλφαβήτου, αλλά η αντιστοιχία αφορά ομάδες γραμμάτων ή
συλλαβές. Συνήθως η κρυπτογράφηση γίνεται ανά δύο γράμματα (διγραφικός
κώδικας), γεγονός που παρέχει κάποια πλεονεκτήματα, όπως ότι η κατανομή
των πιθανοτήτων εμφάνισης των γραμμάτων είναι πολλαπλάσια αυτών από τα
άλλα είδη μετάθεσης και ότι λόγω του μεγαλύτερου αριθμού δυνατών
συνδυασμών γραμμάτων (για το λατινικό αλφάβητο 262 =676 δυνατοί
συνδυασμοί ανά δυάδα) απαιτείται για το σπάσιμο του κώδικα πληθώρα
κρυπτογραφημένων μηνυμάτων.
• Ομοφωνική μετάθεση. Αποτελεί μία πρώτη προσπάθεια να αυξηθεί η
δυσκολία της ανάλυσης του κρυπτοκειμένου που βασίζεται στη συχνότητα
εμφάνισης του κάθε συμβόλου. Σύμφωνα με την μέθοδο αυτή τα γράμματα του
αρχικού μηνύματος αντιστοιχίζονται σε περισσότερα από ένα σύμβολα του
κρυπτογραφικού αλφαβήτου. Συνήθως στα γράμματα με την μεγαλύτερη
συχνότητα εμφάνισης αντιστοιχίζονται περισσότερα κρυπτογραφικά σύμβολα
από ότι στα λιγότερο εμφανιζόμενα γράμματα. Με τον τρόπο αυτό η κατανομή
των συχνοτήτων εμφάνισης εξομαλύνεται δυσκολεύοντας ακόμη περισσότερο
τη διαδικασία αποκρυπτογράφησης.

2.2.1 Αλγόριθμος του Καίσαρα

Χαρακτηριστικό παράδειγμα κρυπτοσυστήματος αντικατάστασης είναι ο αλγόριθμος

του Καίσαρα. Σε αυτόν τον κρυπτογραφικό αλγόριθμο, το κλειδί αποτελεί μια μετάθεση
των γραμμάτων της αλφαβήτου. Η κρυπτογράφηση περιλαμβάνει αντικατάσταση κάθε
γράμματος με το αντίστοιχο γράμμα που προκύπτει από τη μετάθεση. Αντίστοιχα, η
αποκρυπτογράφηση γίνεται με χρήση της ανάστροφης μετάθεσης.

Στον κρυπτογραφικό αλγόριθμο του Καίσαρα (Caesar cipher) το μήνυμα (αρχικό

κείμενο) πρέπει να είναι μια ακολουθία από γράμματα. Κάθε γράμμα αντιστοιχίζεται με
έναν αριθμό. Το κλειδί k είναι ένας αριθμός από το 1 ως το 25. Ο ορισμός του
αλγορίθμου εκφράζεται ως εξής:

𝐿𝑒𝑡 𝑃 = 𝐶 = 𝐾 = 𝑍26 , 𝑥 ∈ 𝑃, 𝑦 ∈ 𝐶, 𝑘∈𝐾

𝐸𝑛𝑐𝑟𝑦𝑝𝑡𝑖𝑜𝑛: 𝑒𝑘 (𝑥) = 𝑥 + 𝑘 𝑚𝑜𝑑 26

𝐷𝑒𝑐𝑟𝑦𝑝𝑡𝑖𝑜𝑛: 𝑑𝑘 (𝑦) = 𝑦 − 𝑘 𝑚𝑜𝑑 26

17
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Πίνακας 2.1 Πίνακας αντιστοίχησης γραμμάτων και αριθμών.

Κατά την κρυπτογράφηση το κλειδί k προστίθεται στον αριθμό κάθε γράμματος του
μηνύματος και υπολογίζεται το υπόλοιπο της διαίρεσης του αθροίσματος με το πλήθος
των γραμμάτων της αλφαβήτου (για το λατινικό αλφάβητο έχουμε modulo 26 αφού το
πλήθος των γραμμάτων είναι 26). Έτσι, για παράδειγμα, εάν το κλειδί k είναι το 3, τότε
το μήνυμα “SECURE“ κρυπτογραφείται σε “VHFXUH”. Πιο συγκεκριμένα για το γράμμα
“S” προκύπτει το “V” γιατί το “S” έχει αντίστοιχο αριθμό το 18 και κρυπτογραφείται με
τον υπολογισμό 18 + 3 = 21 οπότε 21mod26 = 21, που αντιστοιχεί στο γράμμα “V”.

Ο κρυπτογραφικός αλγόριθμος του Καίσαρα είναι ουσιαστικά ένας συνηθισμένος τύπος

κρυπτογραφικού αλγορίθμου ροής. Είναι πολύ εύκολο να κρυπταναλυθεί. Η μέθοδος
της εκτεταμένης αναζήτησης θα δώσει αποτέλεσμα γιατί υπάρχουν μόνο 25
διαφορετικά κλειδιά, καθώς το σύνολο των κλειδιών είναι ίσο με το σύνολο των όλων
των δυνατών μεταθέσεων των γραμμάτων, ίσο δηλαδή με το πλήθος των γραμμάτων
του λατινικού αλφαβήτου.

Γενικότερα, παρά τον μεγάλο αριθμό κλειδιών, πράγμα που αποκλείει μια απλή επίθεση
εξαντλητικής αναζήτησης (exhaustive search attack), ένας κρυπτογραφικός αλγόριθμος
απλής αντικατάστασης είναι εύκολο να σπάσει. Ένας λόγος είναι ότι σε κάθε φυσική
γλώσσα τα γράμματα της αλφαβήτου παρουσιάζουν πολύ διαφορετικές συχνότητες
εμφάνισης στις διάφορες προτάσεις π.χ. στα Ελληνικά το γράμμα Α είναι πολύ πιο
συχνά επαναλαμβανόμενο σε σχέση με γράμματα όπως Ζ και το Ψ. Αυτή η πληροφορία
συνδυαζόμενη με συχνότητες εμφάνισης συνδυασμών δύο ή τριών γραμμάτων μπορεί
να χρησιμοποιηθεί για να εξαχθούν αντιστοιχίες μεταξύ του αρχικού και του
κρυπτογραφημένου κειμένου, από τις οποίες είναι δυνατόν στη συνέχεια να προκύψει η
τιμή του κλειδιού [13,14,15].

2.2.2 Αλγόριθμος Vigenere

O κώδικας του Vigenere αναπτύχθηκε από το διπλωμάτη Blaise de Vigenere (1523-

1596) και ανήκει στην κατηγορία των Κρυπτογραφικών Αλγορίθμων πολυαλφαβητικής
μετάθεσης. Σε αυτόν τα γράμματα αντιστοιχίζονται πάλι με τους αριθμούς από το 0 ως
το 25, όπως ακριβώς και με τον κρυπτογραφικό αλγόριθμο του Καίσαρα. Όμως το
μυστικό κλειδί, τώρα, δεν είναι ένας αριθμός αλλά μια μικρή ακολουθία γραμμάτων,
όπως για παράδειγμα μια λέξη. Ο αλγόριθμος του Καίσαρα είναι μια ειδική περίπτωση
του αλγορίθμου Vigenere για την περίπτωση που το μήκος της λέξης του κλειδιού είναι
ίσο με 1.

Κατά την κρυπτογράφηση προστίθεται το αριθμητικό ισοδύναμο κάθε γράμματος του

αρχικού κειμένου με το αριθμητικό ισοδύναμο ενός γράμματος του κλειδιού. Επειδή
συνήθως το μήκος του αρχικού κειμένου είναι μεγαλύτερο από το μήκος του κλειδιού,
τα γράμματα του κλειδιού ανακυκλώνονται και επαναλαμβάνεται η χρήση τους όσο
χρειάζεται.

18
Ο κρυπτογραφικός αλγόριθμος Vigenere είναι και αυτός μια ειδική μορφή
κρυπτογραφικού αλγορίθμου ροής. Ακριβώς όπως με τον κρυπτογραφικό αλγόριθμο
του Καίσαρα, χρησιμοποιεί πρόσθεση με υπολογισμό του modulo 26 αντί για πρόσθεση
με υπολογισμό του modulo 2 για να συνδυάσει το αρχικό κείμενο με την κλειδοροή. Η
κλειδοροή είναι απλά η λέξη κλειδί, η οποία επαναλαμβάνεται όσο χρειάζεται. Όμως
πάλι παραβαίνει τους κανόνες των γεννητριών κλειδοροής. Η περίοδος της ακολουθίας
κλειδοροής είναι μικρή. Έτσι προκύπτει φυσιολογικά ότι ο κρυπτογραφικός αλγόριθμος
Vigenere σπάζει εύκολα [13,14,15].

2.2.3 Αλγόριθμος σημειωματάριου μιας χρήσης

Ο αλγόριθμος του Vernam ή σημειωματάριο μίας χρήσης (One time pad)

αναπτύχθηκε το 1917 από τους Major Joseph Mauborgne και Gilbert Vernam της AT&T
(American Telephone & Telegraph Company) προκειμένου να αποφευχθεί η
δυνατότητα αποκρυπτογράφησης των κειμένων με τη μέθοδο της ανάλυσης
πιθανοτήτων. Αυτό είναι εφικτό αν χρησιμοποιηθεί για την κρυπτογράφηση μια λέξη-
κλειδί ίσου μεγέθους με αυτό του μηνύματος. Η κλασσική μορφή του σημειωματάριου
μίας χρήσης αποτελείται από μια μακρά σειρά τυχαία επιλεγμένων γραμμάτων-
κλειδιών, που αποτυπώνονται σε πολλαπλά φύλλα χαρτί και συγκροτούν ένα μπλοκ. Ο
αποστολέας κρυπτογραφεί ένα μήνυμα αποδίδοντας κάθε γράμμα του αρχικού
κειμένου σε ένα του κρυπτογραφικού, ενώ κάθε γράμμα-κλειδί χρησιμοποιείται μόνο
μία φορά και μόνο για την κρυπτογράφηση ενός μηνύματος. Μετά την κρυπτογράφηση
του μηνύματος οι σελίδες του μπλοκ με το μυστικό αλφάβητο καταστρέφονται. Ο
παραλήπτης διαθέτει το ίδιο μπλοκ, το οποίο συμβουλεύεται για την
αποκρυπτογράφηση. Ακολούθως καταστρέφει και αυτός το μπλοκ. Σε κάθε νέο μήνυμα
χρησιμοποιούνται νέα γράμματα-κλειδιά.

Ο παραπάνω κώδικας μοιάζει απολύτως ασφαλής. Και αυτό γιατί για την
αποκρυπτογράφηση του κειμένου είναι απαραίτητο το μπλοκ με τα γράμματα-κλειδιά
του σημειωματάριου μίας χρήσης, ενώ η μέθοδος ανάλυσης των πιθανοτήτων
εμφάνισης κάθε γράμματος αδυνατεί να συμβάλλει σε λύση του γρίφου, καθώς ένα
συγκεκριμένο κρυπτογραφημένο κείμενο μπορεί με τις ίδιες πιθανότητες να αντιστοιχεί
σε χιλιάδες αρχικά-μη κρυπτογραφημένα μηνύματα με την ίδια έκταση [13,14,15].

Το ότι ο κώδικας αυτός μολονότι ασφαλής δεν επικράτησε οφείλεται στα κάτωθι
μειονεκτήματα:

• Το μυστικό κλειδί πρέπει να έχει την αυτή έκταση με το αρχικό μήνυμα.

• Οι λέξεις κλειδιά πρέπει να είναι διαθέσιμες κάθε φορά στον παραλήπτη.
• Το μπλοκ κλειδιού είναι μοναδικό για κάθε κρυπτογραφημένο μήνυμα, οπότε
χρησιμοποιείται μόνο μια φορά και πρέπει σίγουρα να καταστρέφεται στο
τέλος, πράγμα πολυδάπανο και ασύμφορο οικονομικά.
• Τέλος, πρόβλημα αποτελεί και το πως θα μεταβιβαστεί το μπλοκ κλειδιού στον
παραλήπτη, ενώ η σωστή αποκρυπτογράφηση του μηνύματος εξαρτάται
αποκλειστικά από την ικανότητα του παραλήπτη χωρίς να αποκλείεται ο
αστάθμητος παράγων του ανθρώπινου λάθους.

19
2.3 Σύγχρονα Κρυπτοσυστήματα

Τα σύγχρονα κρυπτοσυστήματα χωρίζονται με βάση τα κλειδιά σε:

• Μυστικού ή Συμμετρικού Κλειδιού (Symmetric Key), χρησιμοποιούν το ίδιο

μυστικό κλειδί για κρυπτογράφηση και αποκρυπτογράφηση.
• Δημοσίου ή Ασύμμετρου Κλειδιού (Asymmetric Key), χρησιμοποιούν
διαφορετικό κλειδί για κρυπτογράφηση (δημόσιο κλειδί παραλήπτη) και
διαφορετικό για αποκρυπτογράφηση (προσωπικό κλειδί παραλήπτη).

2.3.1 Συμμετρικά Κρυπτοσυστήματα και Αλγόριθμοι

Ένα κρυπτοσύστημα ονομάζεται συμμετρικό, όταν το κλειδί της κρυπτογράφησης

είναι το ίδιο με αυτό της αποκρυπτογράφησης. Τα συμμετρικά κρυπτοσυστήματα είναι
και τα πιο διαδεδομένα χρονικά, καθότι τα ασύμμετρα κρυπτοσυστήματα
εμφανίστηκαν επίσημα το 1976. Ένα συμμετρικό κρυπτοσύστημα αποτελείται από
πέντε μέρη, όπως φαίνεται στην Εικόνα 2. 2.

Το απλό κείμενο εισάγεται μαζί με το κλειδί στον αλγόριθμο κρυπτογράφησης. Όπως

είναι φανερό στο παραπάνω σχήμα, το κλειδί είναι ανεξάρτητο του απλού κειμένου. Το
αποτέλεσμα του αλγόριθμου κρυπτογράφησης είναι το κρυπτοκείμενο. Για δεδομένο
απλό κείμενο, δύο διαφορετικά κλειδιά παράγουν δύο διαφορετικά κρυπτοκείμενα. Ο
αλγόριθμος αποκρυπτογράφησης δέχεται ως είσοδο το κρυπτοκείμενο και το κλειδί το
οποίο είναι το ίδιο με αυτό του αλγόριθμου κρυπτογράφησης. Ο αλγόριθμος
αποκρυπτογράφησης εφαρμόζει τους αντίστροφους μετασχηματισμούς από αυτούς
του αλγόριθμου κρυπτογράφησης και επαναφέρει το κείμενο στην αρχική του μορφή,
αυτήν του απλού κειμένου.

Η αδυναμία του συμμετρικού συστήματος φαίνεται στο μοντέλο επικοινωνίας, στην

Εικόνα 1. 4. Η απαίτηση του κρυπτοσυστήματος να χρησιμοποιείται το ίδιο κλειδί στην
κρυπτογράφηση και αποκρυπτογράφηση, προϋποθέτει ότι ο αποστολέας και ο
παραλήπτης έχουν κάποιον ασφαλή τρόπο να μοιραστούν αυτήν την πληροφορία. Η
υπόθεση που κάναμε ότι το κλειδί δημιουργείται και βρίσκεται αρχικά στον αποστολέα
είναι έγκυρη, καθώς η κρυπτογράφηση προηγείται της αποκρυπτογράφησης.

Εικόνα 2. 2 Ένα συμμετρικό κρυπτοσύστημα.

20
Επομένως, ο αποστολέας θα πρέπει να στείλει το κλειδί στον παραλήπτη, χωρίς να
πέσει στα χέρια του αντιπάλου. Ο λόγος που δεν αποστέλλεται απευθείας το κείμενο
μέσω ενός ασφαλούς καναλιού είναι ότι τα ασφαλή κανάλια δεν είναι πάντοτε
διαθέσιμα, απαιτούν σχετικά μεγάλη προσπάθεια για να δημιουργηθούν και η μορφή
τους είναι ανάλογα με την περίσταση. Για παράδειγμα ο αποστολέας και ο παραλήπτης
μπορεί να είχαν συναντηθεί κάποια στιγμή στο παρελθόν και να είχαν μοιραστεί το
κλειδί με την προοπτική να το χρησιμοποιήσουν σε μελλοντική επικοινωνία. Το
ασφαλές κανάλι ήταν η επαφή τους χωρίς τη μεσολάβηση κάποιου τρίτου (μιας
τηλεφωνικής εταιρείας για παράδειγμα). Ένας άλλος τρόπος για τη δημιουργία
ασφαλούς καναλιού, είναι να τεμαχιστεί το κλειδί και τα τεμάχια να διαβιβασθούν μέσω
διαφορετικών καναλιών, όπως τηλεφωνικά, ταχυδρομικά, ή με κούριερ, έτσι ώστε ο
αντίπαλος να μην είναι σε θέση να μπορεί να τα παρακολουθεί όλα και να συλλέξει όλα
τα τεμάχια για να χτίσει το κλειδί. Επίσης το κλειδί είναι πολύ μικρότερο σε μέγεθος
από το απλό κείμενο και επιπλέον μπορεί να επαναχρησιμοποιηθεί για την
κρυπτογράφηση πολλών κειμένων. Αυτό βέβαια είναι και μια πολύ σημαντική
κρυπτογραφική αδυναμία που μπορεί να εκμεταλλευτεί ο αντίπαλος και να σπάσει το
κρυπτοσύστημα.

Συνεπώς για την ασφαλή χρήση της συμμετρικής κρυπτογραφίας πρέπει να πληρούνται
οι ακόλουθες προϋποθέσεις:

• Απαιτείται η ύπαρξη ενός ισχυρού (strong) αλγορίθμου κρυπτογράφησης. Ως

ελάχιστη απαίτηση αναφέρεται η ύπαρξη αλγορίθμου για τον οποίο ο
επιτιθέμενος πρέπει να είναι αδύνατο να κρυπταναλύσει το κρυπτογράφημα ή
να ανακαλύψει το κλειδί, ακόμη και αν κατέχει κάποια κρυπτογραφήματα μαζί
με τα αντίστοιχα αρχικά μηνύματα, από τα οποία παράχθηκε καθένα από αυτά
τα κρυπτογραφήματα.
• Ο πομπός και ο δέκτης πρέπει να έχουν παραλάβει τα αντίγραφα του μυστικού
κλειδιού με ασφαλή τρόπο και να διαφυλάσσουν αυτό το μυστικό κλειδί σε
ασφαλές μέρος. Εάν κάποιος γνωρίζει τον αλγόριθμο και ανακαλύψει το κλειδί,
τότε όλη η επικοινωνία που χρησιμοποιεί αυτό το κλειδί είναι αναγνώσιμη,
συνεπώς παραβιάζεται η εμπιστευτικότητα.

Σημειώνεται ότι αδύναμο κρίκο στην ασφάλεια της συμμετρικής κρυπτογραφίας

αποτελεί μόνον η μυστικότητα του κλειδιού και όχι η μυστικότητα του αλγορίθμου που
χρησιμοποιείται. Αυτό θεωρείται δεδομένο, εάν υποτεθεί, ότι για τον επιλεγέντα
αλγόριθμο ισχύει η προφανής σχεδιαστική απαίτηση, να είναι αδύνατο να
αποκρυπτογραφηθεί ένα μήνυμα μόνο με γνώση του κρυπτογραφήματος και του
αλγορίθμου κρυπτογράφησης. Συνεπώς, δε χρειάζεται να παραμένει μυστικός ο
αλγόριθμος, αλλά μόνο το μυστικό κλειδί. Το χαρακτηριστικό αυτό γνώρισμα της
συμμετρικής κρυπτογραφίας την καθιστά κατάλληλη για ευρεία χρήση. Το γεγονός ότι
δε χρειάζεται να παραμένει μυστικός ο αλγόριθμος επιτρέπει στους κατασκευαστές να
αναπτύσσουν χαμηλού κόστους υλοποιήσεις, τόσο σε λογισμικό όσο και σε υλικό, για
εφαρμογές κρυπτογράφησης δεδομένων [16].

Οι συμμετρικοί κρυπτογραφικοί αλγόριθμοι ταξινομούνται σε δύο κατηγορίες με βάση

τον τρόπο με τον οποίο επεξεργάζεται ο αλγόριθμος το αρχικό μήνυμα:

• Αλγόριθμοι Τμήματος (block cipher), οι οποίοι χωρίζουν το μήνυμα σε

κομμάτια και κρυπτογραφούν κάθε ένα από τα κομμάτια αυτά χωριστά.
• Αλγόριθμους Ροής (stream cipher), οι οποίοι κρυπτογραφούν μία ροή
μηνύματος χωρίς να τη διαχωρίζουν σε τμήματα.

21
Ενδεικτικά αναφέρονται παρακάτω οι συμμετρικοί αλγόριθμοι κρυπτογράφησης.

Συμμετρικοί Αλγόριθμοι Τμήματος (Block Ciphers)

• Data Encryption Standard (DES)

• Triple-DES
• NewDES
• 3-Way
• Blowfish
• Twofish
• CAST
• CMEA
• IDEA
• MacGuffin
• Lucifer
• MARS
• RC2
• RC5
• RC6
• Rijndael
• Safer
• Serpent
• Tiny Encryption Algorithm

Συμμετρικοί Αλγόριθμοι Ροής (Stream Ciphers)

• ORYX
• RC4
• SEAL
• Ε0
• Α5/x

2.3.2 Αλγόριθμοι Ροής (Stream Ciphers)

Οι αλγόριθμοι ροής αποτελούν μια σημαντική κλάση τεχνικών συμμετρικής

κρυπτογραφίας. Λειτουργούν σε μικρές μονάδες, συνήθως bits, του αρχικού μηνύματος
και ο μετασχηματισμός αυτών των bits εξαρτάται από το χρόνο. Από τα πιο σημαντικά
χαρακτηριστικά των αλγορίθμων ροής είναι η ταχύτητα και η απλότητα. Με τον όρο
απλότητα, εννοούμε ότι οι σχεδιαστές έχουν ως κύριο στόχο το σχεδιασμό αλγορίθμων
οι οποίοι να έχουν ταχείς επιδόσεις όσον αφορά το κομμάτι λογισμικού ή να είναι
“μικροί” στο κομμάτι του υλικού. Τα χαρακτηριστικά αυτά έχουν σαν αποτέλεσμα την
ευρεία χρήση των αλγορίθμων ροής σε πολλές εφαρμογές. Παραδείγματα αποτελούν οι
αλγόριθμοι Ε0, Α5/x και RC4 οι οποίοι χρησιμοποιούνται σε δίκτυα Bluetooth, 2g
κυψελική τηλεφωνία, και ασύρματα δίκτυα 802.11a/b.

22
 Κλειδί k
Γεννήτρια
Κλειδοροής

01110...

Μήνυμα M
Μήνυμα M 01101
01101 XOR XOR

Κρυπτογραφημένο κείμενο C
00011

Εικόνα 2. 3 Κρυπτοσύστημα ροής.

Ένας κρυπτογραφικός αλγόριθμος ροής λειτουργεί ως εξής:

• Τα δεδομένα που πρόκειται να κρυπτογραφηθούν παριστάνονται ως μια

ακολουθία από δυαδικά ψηφία. Κατόπιν, ελέγχεται μια γεννήτρια κλειδοροής
(key stream generator) που δέχεται ως είσοδο ένα μυστικό κλειδί k και παράγει
στην έξοδο μια ψευδοτυχαία ακολουθία από bits που ονομάζεται κλειδοροή
(key stream). Η γεννήτρια κλειδοροής είναι ένας ειδικός τύπος γεννήτριας
ψευδοτυχαίων αριθμών.
• Στη συνέχεια, το αρχικό κείμενο κρυπτογραφείται με modulo 2 (XOR), δηλαδή
προσθέτοντας την κλειδοροή στο αρχικό κείμενο. Η ακολουθία από bits που
παράγεται με αυτόν τον τρόπο αποτελεί το κρυπτογραφημένο κείμενο.

Επομένως ένας συμβολισμός του κρυπτογραφικού αλγορίθμου ροής θα μπορούσε να

είναι:

ci = mi ⊕ ki , για i ≥ 0,

Όπου m0 , m1 , ... είναι τα bits του αρχικού κειμένου, k0 , k1 , ... είναι τα bits της
κλειδοροής και c0 ,c1 , ... είναι τα bits του κρυπτογραφημένου κειμένου. Το σύμβολο ⊕
συμβολίζει την πράξη της αποκλειστικής διάζευξης (exclusive – or) μεταξύ των bits.
Αντίστοιχα για την αποκρυπτογράφηση θα ισχύει :

mi = ci ⊕ ki , για i ≥ 0,

Δηλαδή, η αποκρυπτογράφηση γίνεται με τον ίδιο τρόπο που γίνεται η κρυπτογράφηση

ροής.

Για να είναι ασφαλής ένας κρυπτογραφικός αλγόριθμος ροής πρέπει η γεννήτρια

κλειδοροής να διαθέτει τις παρακάτω ιδιότητες:

• Η κλειδοροή πρέπει να έχει μεγάλη περίοδο επανάληψης. Πράγματι η ακολουθία

είναι αναγκαστικά περιοδική, δηλαδή μετά από κάποιον αριθμό bits χρειάζεται
να επαναλαμβάνεται ξεκινώντας από την αρχή, αφού παράγεται από κάποια
συνάρτηση με βάση ένα κλειδί. Αν η περίοδος επανάληψης είναι πολύ μικρή
τότε είναι εύκολο να υπολογιστεί το ακριβές μέγεθος της περιόδου
επιτρέποντας κατόπιν την αποκρυπτογράφηση του κρυπτοκειμένου.
• Η κλειδοροή πρέπει να είναι ψευδοτυχαία, δηλαδή να μοιάζει με μια πραγματικά
τυχαία ακολουθία. Αυτό συνήθως επαληθεύεται με εφαρμογή ελέγχων
τυχαιότητας (random tests), οι οποίοι ελέγχουν κατά πόσο είναι περίπου ίδιο το

23
 πλήθος των ψηφίων μηδέν (0) και των ψηφίων ένα (1), ή ότι κάθε μηδενικό
ψηφίο ακολουθείται από το ψηφίο ένα (1) τόσο συχνά όσο και το αντίστροφο.
• Η κλειδοροή θα πρέπει να έχει μεγάλη γραμμική ισοδυναμία (linear
equivalence). Οποιαδήποτε ακολουθία δυαδικών ψηφίων μπορεί να παραχθεί
με χρήση γραμμικών μεθόδων, για παράδειγμα με υπολογισμό της επόμενης
τιμής βάσει των προηγούμενων τιμών της ακολουθίας. Αν στον υπολογισμό
αυτό χρησιμοποιείται ένας μικρός σχετικά αριθμός προηγούμενων τιμών, τότε
λέμε πως η ακολουθία έχει μικρή γραμμική ισοδυναμία. Αντίθετα εάν στον
υπολογισμό χρησιμοποιείται ένας μεγάλος αριθμός προηγούμενων τιμών, τότε η
ακολουθία έχει μεγάλη γραμμική ισοδυναμία. Μία κλειδοροή με μεγάλη
γραμμική ισοδυναμία εγγυάται μεγαλύτερη ασφάλεια των κρυπτογραφημένων
δεδομένων απέναντι σε προσπάθειες κρυπτανάλυσης.

Οι παραπάνω συνθήκες είναι αναγκαίες για να εξασφαλίσουν έναν αξιόπιστο αλγόριθμο

ροής, όχι όμως επαρκείς. Γενικά για να είναι ένας κρυπτογραφικός αλγόριθμος ροής
αξιόπιστος θα πρέπει να εξασφαλίζει ότι ακόμη και εάν κάποιος αποκτήσει
οποιαδήποτε πληροφορία για κάποιο κομμάτι της ακολουθίας κλειδοροής, είναι
υπολογιστικά αδύνατο να συνάγει άλλα κομμάτια της ακολουθίας.
Οι μοντέρνοι κρυπτογραφικοί αλγόριθμοι ροής χρησιμοποιούν γεννήτριες κλειδοροών
που παράγουν ψευδοτυχαίες ακολουθίες με πολύ μεγάλες περιόδους, για παράδειγμα
264 bits ή και περισσότερα. Υπάρχουν ακόμη και υλικό γεννητριών κλειδοροής που
κατορθώνουν να τρέχουν σε πολύ μεγάλες ταχύτητες. Σήμερα οι υψηλές ταχύτητες
μπορούν να επιτυγχάνονται ακόμη και με λογισμικό παραγωγής κλειδοροών.

Η κρυπτογράφηση με αλγορίθμους ροής μπορεί να γίνεται πολύ γρήγορα, καθώς από τη

μια η λειτουργία της κρυπτογράφησης είναι πολύ απλή και από την άλλη είναι δυνατή η
υλοποίηση ασφαλών γεννητριών κλειδοροής που λειτουργούν με πολύ μεγάλες
ταχύτητες [17].

2.3.3 Αλγόριθμοι Τμήματος (Block Ciphers)

Οι αλγόριθμοι τμήματος συμμετρικού κλειδιού είναι οι πιο διάσημοι και πιο σημαντικοί
σε πολλά κρυπτογραφικά συστήματα. Από μόνoι τους προσφέρουν εμπιστευτικότητα
(confidentiality) αλλά λόγω της προσαρμοστικότητας τους συχνά χρησιμοποιούνται και
για την γεννήτρια παραγωγής ψευδοτυχαίων ακολουθιών, αλγορίθμους ροής,
συναρτήσεων κατακερματισμού (hash functions) και MACs (Message Authentication
Codes). Επίσης μπορούν να χρησιμοποιηθούν ως βασικό στοιχείο σε τεχνικές
αυθεντικοποίησης μηνύματος, σε μηχανισμούς ακεραιότητας μηνύματος, σε
πρωτόκολλα αυθεντικοποίησης οντότητας και σε ψηφιακές υπογραφές. Παρόλο που
προσφέρουν υψηλό επίπεδο ασφάλειας οι αλγόριθμοι τμήματος δεν μπορούν να
χρησιμοποιηθούν σε όλες τις εφαρμογές που απαιτούν κρυπτογραφικά συστήματα.
Αυτό ισχύει λόγω των απαιτήσεων ταχύτητας και περιορισμένης μνήμης ορισμένων
εφαρμογών [17].

2.3.3.1 Βασικές έννοιες και ορισμοί

Οι αλγόριθμοι τμήματος μπορεί να είναι συμμετρικού και δημοσίου κλειδιού. Κάθε

αλγόριθμος τμήματος είναι μια συνάρτηση η οποία αντιστοιχεί τμήματα μήκους n-bits

24
απλού κειμένου σε τμήματα μήκους n-bits κρυπτοκειμένου. Το n ονομάζεται μήκος
τμήματος. Μπορεί να θεωρηθεί ως ένα απλό κρυπτοσύστημα αντικατάστασης με
χαρακτήρες μεγάλου μεγέθους. Η συνάρτηση έχει ως παράμετρο το διάνυσμα κλειδί k
διάστασης n, k ∈ K όπου Κ είναι ένα υποσύνολο του συνόλου όλων των διανυσμάτων
διάστασης n.

Ένας αλγόριθμος τμήματος n-bits είναι ένα τμήμα (μπλοκ n-bits) αρχικού κειμένου, που
αντιμετωπίζεται σαν ένα σύνολο και χρησιμοποιείται για να παράγει ένα τμήμα
κρυπτογραφήματος ίσου μήκους. Η συνάρτηση κρυπτογράφησης Ε(Ρ, k) είναι μια
αντιστρέψιμη αντιστοιχία και συμβολίζεται Εk(P). Η αντίστροφη αντιστοιχία είναι η
συνάρτηση αποκρυπτογράφησης η οποία συμβολίζεται Dk(P). Η σχέση C= Εk(P)
συμβολίζει ότι το κρυπτοκείμενο C προκύπτει από την κρυπτογράφηση του απλού
κειμένου Ρ. Η διαδικασία κρυπτογράφησης και αποκρυπτογράφησης παρουσιάζονται
στην Εικόνα 2. 4.

Οι δύο σημαντικότερες παράμετροι των κωδικοποιητών τμήματος είναι το μήκος του

block και το μήκος του κλειδιού. Τα περισσότερα κρυπτοσυστήματα αυτού του είδους
έχουν μήκος block b=64 ή 128 και μήκος κλειδιού k=64 ή 128 ή 192 ή 256 bits. Όμως οι
αλγόριθμοι τμήματος μπορούν να θεωρηθούν ως μια αντιμετάθεση η οποία εξαρτάται
από το κλειδί (key dependent permutation) καθώς χρησιμοποιούν ένα μικρό σύνολο
από αντιμεταθέσεις εξαρτώμενες από τον αριθμό των πιθανών κλειδιών. Συγκεκριμένα,
έστω ότι #P=#C=2b και Κ=2k. Η διαδικασία τότε είναι:

Τότε ο αριθμός των πιθανών αντιμεταθέσεων b-bit blocks είναι (2b)!, αλλά τελικά
περιορίζεται από το κλειδί k και είναι 2k. Επομένως για ένα “καλό” αλγόριθμο τμήματος
θα πρέπει να ισχύουν οι εξής ιδιότητες:

• Το κλειδί επιλέγει μια τυχαία αντιμετάθεση

• Συγγενικά κλειδιά δίνουν μη-συγγενικές αντιμεταθέσεις

ώστε να είναι ανθεκτικό σε επιθέσεις κάθε είδους.

Εικόνα 2. 4 Κρυπτογράφηση/Αποκρυπτογράφηση αλγορίθμου τμήματος.

25
Το 1949 ο Shannon εισήγαγε τις έννοιες σύγχυση (Confusion) και διάχυση (Diffusion). Η
σύγχυση ορίζεται ως η λειτουργία η οποία κάνει τη σχέση μεταξύ κλειδιού και
κρυπτοκειμένου όσο το δυνατόν πολυπλοκότερη ενώ η διάχυση ορίζεται ως η
λειτουργία η οποία διαχέει την επιρροή των bits του απλού κειμένου έτσι ώστε τα bits
του κρυπτοκειμένου να εξαρτώνται από ολόκληρο το κείμενο. Η σύγχυση συνήθως
δίνεται από τη χρήση μιας αντικατάστασης η οποία ονομάζεται S-Box και η διάχυση
δίνεται από τη χρήση μιας αντιμετάθεσης.

Ένα δίκτυο αντικατάστασης - αντιμετάθεσης (substitution - permutation network)

Εικόνα 2. 5 είναι ένα επαναλαμβανόμενο κρυπτοσύστημα το οποίο αποτελείται από
έναν αριθμό από γύρους. Κάθε γύρος αποτελείται από αντικαταστάσεις και
αντιμεταθέσεις. Η αντικατάσταση η οποία καλείται και S-Box αντικαθιστά I-bits με ένα
άλλο σύνολο από I-bits ενώ η αντιμετάθεση, αντιμεταθέτει τα bits. Η λογική του
σχεδιασμού των δικτύων αντικατάστασης-αντιμετάθεσης είναι ότι οι αντικαταστάσεις
και οι αντιμεταθέσεις χρησιμοποιούνται με τέτοιο τρόπο ώστε το τελικό
κρυπτοσύστημα, μετά από ένα καθορισμένο αριθμό γύρων, είναι πιο ασφαλές από ότι
σε κάθε γύρο χωριστά.

Η άλλη μεγάλη κατηγορία για αλγόριθμους τμήματος είναι το δίκτυο Feistel. Στα
κρυπτοσυστήματα τύπου Feistel, το κείμενο χωρίζεται σε δύο μέρη και αφού το κάθε
ένα επιδέχεται διαφορετικές τροποποιήσεις στη συνέχεια συνδυάζονται με τέτοιο
τρόπο ώστε το ένα να “ενημερώνει” το άλλο. Οι τροποποιήσεις σε κάθε γύρο γίνονται
μέσο της συνάρτησης F η οποία συνήθως είναι ένα δίκτυο αντικατάστασης-
αντιμετάθεσης. Το κύριο χαρακτηριστικό του δικτύου Feistel είναι ότι η συνάρτηση F
μπορεί να είναι οποιαδήποτε συνάρτηση ακόμα και αν δεν είναι αντιστρέψιμη. Η δομή
του Feistel είναι τέτοια ώστε ο κάθε γύρος να είναι αντιστρέψιμος ακόμα και όταν η
συνάρτηση F δεν είναι. Όλα τα παραπάνω μπορούν να φανούν αναλυτικά στην Εικόνα
2. 6.

Εικόνα 2. 5 Δίκτυο αντικατάστασης – αντιμετάθεσης.

26
Η συνάρτηση F όπως ήδη αναφέραμε είναι συνήθως ένα δίκτυο αντικατάστασης-
αντιμετάθεσης. Αυτό είναι που θα δώσει στο κρυπτοσύστημα την απαιτούμενη
σύγχυση και διάχυση. Στη θεωρία ένας τρόπος να κατασκευάσει κάποιος ένα “καλό”
αλγόριθμο τμήματος είναι με το να επιλέξει για συνάρτηση F μια τυχαία συνάρτηση (Αν
η F είναι τυχαία συνάρτηση που αντιστοιχεί n-bits σε n-bits, τότε η δομή του Feistel
δίνει μια τυχαία συνάρτηση που αντιστοιχεί 2n-bits σε 2n-bits) και να χρησιμοποιήσει
τουλάχιστον τρείς γύρους ώστε να είναι ανθεκτικό σε συγκεκριμένους τύπους
επιθέσεων. Στη πράξη όμως είναι απαραίτητο να χρησιμοποιούνται διαφορετικά μέρη
του κλειδιού σε κάθε γύρο (στη διαδικασία κρυπτογράφησης). Επομένως υπάρχει η
ανάγκη για ένα Πρόγραμμα κλειδιού [17].

Εικόνα 2. 6 Δίκτυο Feistel.

27
2.3.3.2 Μέθοδοι Γεμίσματος

Όλες οι μέθοδοι λειτουργίας που θα δούμε παρακάτω, προϋποθέτουν ότι το απλό

κείμενο θα χωριστεί σε τμήματα καθορισμένου μήκους π.χ. j-bits. Αυτό γίνεται εύκολα
με το να θέσουμε τα πρώτα j-bits του απλού κειμένου να ορίζουν το πρώτο τμήμα, τα
επόμενα j-bits το δεύτερο τμήμα, κ.ο.κ. Αυτό όμως σημαίνει ότι το τελευταίο τμήμα θα
πρέπει να έχει ακριβώς j-bits δηλαδή το μήκος όλου του απλού κειμένου να είναι
πολλαπλάσιο του j. Για να λυθεί αυτό το πρόβλημα, τα επικοινωνούντα μέλη θα πρέπει
να συμφωνήσουν σε μια μέθοδο γεμίσματος. Μια τέτοια μέθοδος προσθέτει τον
απαραίτητο αριθμό bits σύμφωνα με τη συμφωνημένη φόρμουλα ώστε το τελικό
μήνυμα να έχει μήκος πολλαπλάσιο του j [19,15].

2.3.3.2.1 Μηδενικό Γέμισμα (Zero Padding)

Η διαγραφή του γεμίσματος από τον παραλήπτη είναι στοιχειώδης αν η δομή των
δεδομένων είναι τέτοια ώστε ο παραλήπτης μπορεί εύκολα να καταλάβει το τέλος του
string των δεδομένων. Κυρίως αυτό συμβαίνει σε περιπτώσεις όπου τα μηνύματα που
ανταλλάσσονται είναι καθορισμένου μήκους. Αλλιώς θα πρέπει να χρησιμοποιηθεί ένα
“ειδικό” string, το οποίο δεν εμφανίζεται πουθενά αλλού στο μήνυμα, για να δείχνει το
τέλος των δεδομένων. Σε αυτή τη περίπτωση μπορεί να χρησιμοποιηθεί οποιαδήποτε
μέθοδος γεμίσματος με την πιο απλή να είναι η πρόσθεση του ελάχιστου αριθμού από
μηδενικά στο τέλος του μηνύματος ώστε όλο το μήνυμα να είναι πολλαπλάσιο του j
[19,15].

2.3.3.2.2 Σαφές Γέμισμα (Unambiguous Padding)

Μια μέθοδος γεμίσματος μπορεί να σχεδιαστεί έτσι ώστε η διαγραφή του γεμίσματος
από τον παραλήπτη να γίνεται εύκολα ανεξάρτητα από το string δεδομένων. Μια τέτοια
μέθοδος είναι το Σαφές γέμισμα όπου προτείνει την προσθήκη ενός 1 στο τέλος του
μηνύματος, ακολουθούμενο από τον ελάχιστο αριθμό από μηδενικά ώστε το string που
έχει υποστεί γέμισμα να έχει μήκος πολλαπλάσιο του j. Αν ο παραλήπτης γνωρίζει ότι
έχει χρησιμοποιηθεί αυτή η μέθοδος, η αφαίρεση του γεμίσματος είναι κάτι τετριμμένο.

Το μειονέκτημα της μεθόδου αυτής είναι ότι μερικές φορές θα έχει ένα παραπάνω block
σε σχέση με το μηδενικό γέμισμα. Αυτό γίνεται στις περιπτώσεις όπου το τελευταίο
block έχει j-1 bits οπότε η μέθοδος θα προσθέσει ένα 1 και ένα ολόκληρο block με
μηδενικά [19,15].

2.3.3.3 Μέθοδοι Λειτουργίας

Μια μέθοδος λειτουργίας είναι ένας προτεινόμενος τρόπος να χρησιμοποιηθεί ένας

αλγόριθμος τμήματος για να κρυπτογραφήσει ένα string από bits, γνωστό και ως
μήνυμα ή απλό κείμενο και να παράγει το κρυπτοκείμενο. Μια τέτοια μέθοδος είναι
απαραίτητη καθώς οι αλγόριθμοι τμήματος προσφέρουν τρόπο να κρυπτογραφούμε

28
ένα string n-bits και όχι αυθαίρετου μήκους. Ακόμα και όταν κρυπτογραφούμε string n-
bits μια μέθοδος λειτουργίας θα αποτρέψει τη διαρροή πληροφορίας που προκύπτει
από επαναλαμβανόμενα n-bits στο απλό κείμενο.

Το 1980 στις Η.Π.Α. έγιναν πρότυπα τέσσερις μέθοδοι λειτουργίας ονόματι Electronic
Codebook (ECB), Cipher Block Chaining (CBC), Output Feedback (OFB), και Cipher
Feedback(CFB). Αυτές οι μέθοδοι περιγράφηκαν κυρίως για χρήση με το
κρυπτοσύστημα DES αλλά αργότερα εφαρμόστηκαν και σε άλλους αλγορίθμους
τμήματος. Οι τέσσερις μέθοδοι λειτουργίας αρχικά καθορίστηκαν στο Αμερικανικό
πρότυπο μεθόδων λειτουργίας, NBS FIPS Pub.81, και στη συνέχεια έγιναν κρατικό
πρότυπο στις Η.Π.Α., ANSI X3.106 το 1983. Το τελευταίο δεν είναι πλέον διαθέσιμο
καθώς αντικαταστάθηκε από ένα πρότυπο του διεθνούς οργανισμού ISO
[20,9,15,17,18].

2.3.3.3.1 Electronic Codebook (ECB) Mode

Για να χρησιμοποιηθεί αυτή η μέθοδος, το απλό κείμενο θα πρέπει να έχει τη μορφή

ακολουθίας n-bits blocks δηλαδή Ρ1, Ρ2, …, Ρq (για να το φέρουμε σε αυτή τη μορφή,
μπορεί να χρειαστεί μια μέθοδος γεμίσματος). Τότε το κρυπτοκείμενο ορίζεται να είναι
η ακολουθία από τα blocks C1, C2,…, Cq όπου Ci=Ek(Pi) για κάθε i (1≤i≤q). Η διαδικασία
κρυπτογράφησης φαίνεται στη Εικόνα 2. 7 και με τη διαδικασία αποκρυπτογράφησης
να λειτουργεί ανάλογα. Ισχύει δηλαδή Pi=Dk(Ci) για κάθε i (1≤i≤q).

Στην ECB μέθοδο, ίδια blocks απλού κειμένου καταλήγουν σε ίδια block
κρυπτοκειμένου. Αυτό είναι πρόβλημα όταν κρυπτογραφούνται μεγάλα μηνύματα
αφού η πιθανότητα να υπάρχουν δύο ίδια block είναι μεγάλη. Για παράδειγμα, αν το
απλό κείμενο είναι ένα κείμενο στα Αγγλικά τροποποιημένο σε δυαδική μορφή, τότε η
πιθανότητα να υπάρχουν δύο ίδια blocks είναι αρκετά μεγάλη αφού
επαναλαμβανόμενες λέξεις και φράσεις είναι κάτι το συνηθισμένο.

Επίσης η χρήση αυτής της μεθόδου έχει σαν αποτέλεσμα την εμφάνιση ενός φαινομένου
που ονομάζεται εξάπλωση σφάλματος (error propagation). Έτσι αν ένα απλό bit έχει
σφάλμα κατά τη μετάδοση του μηνύματος, κατά την αποκρυπτογράφηση θα είναι
λάθος ένα ολόκληρο block [9,15,17,18].

Εικόνα 2. 7 Electronic Codebook Mode.

29
2.3.3.3.2 Cipher Block Chaining (CBC) Mode

Όπως και στην ECB, έτσι και στη μέθοδο Αλυσιδωτής Κρυπτογράφησης Τμημάτων (CBC)
το απλό κείμενο πρέπει να γεμίσει με κάποια από τις μεθόδους γεμίσματος ώστε να έχει
μήκος πολλαπλάσιο του j και να χωριστεί σε μια ακολουθία τμημάτων j-bits: P0, P1, …,Pq.
Πρέπει να επιλεγεί ένα διάνυσμα αρχικοποίησης (IV) το οποίο θα γίνει XOR με το
πρώτο block και το αποτέλεσμα αυτό θα είναι είσοδος στη συνάρτηση
κρυπτογράφησης. Για κάθε επόμενο block η είσοδος στον αλγόριθμο κρυπτογράφησης
είναι το αποτέλεσμα XOR του τρέχοντος block και του προηγούμενου
κρυπτογραφήματος. Έτσι η κρυπτογράφηση (Εικόνα 2. 8) περιέχει τον υπολογισμό
τμημάτων κρυπτοκειμένου C0, C1, …, Cq ως εξής:

𝐶0 = 𝐸𝐾 [𝐼𝑉 ⊕ P0 ] και 𝐶𝑖 = 𝐸𝐾 [𝐶𝑖−1 ⊕ Pi ] ,(i >1)

Η αποκρυπτογράφηση λειτουργεί ως εξής:

𝑃0 = 𝐼𝑉 ⊕ 𝐷𝐾 [𝐶0 ] και 𝑃𝑖 = 𝐶𝑖−1 ⊕ 𝐷𝐾 [𝐶𝑖 ] ,(i >1)

Το διάνυσμα αρχικοποίησης IV πρέπει να είναι γνωστό τόσο στον πομπό όσο και στο
δέκτη. Για την επίτευξη μέγιστης ασφάλειας πρέπει να διασφαλίζεται η μυστικότητα
του διανύσματος αρχικοποίησης με τον ίδιο τρόπο που συμβαίνει και για το κλειδί.
Αυτό επιτυγχάνεται με την αποστολή του διανύσματος αρχικοποίησης
χρησιμοποιώντας τη μέθοδο ECB.

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

Το πλεονέκτημα της συγκεκριμένης μεθόδου έναντι της ECB είναι ότι ίδια blocks απλού
κειμένου δεν καταλήγουν σε ίδια block κρυπτοκειμένου. Τέλος, όσον αφορά την
εξάπλωση σφάλματος και αυτή η μέθοδος παρουσιάζει το φαινόμενο αυτό. Πιο
συγκεκριμένα, αν υποθέσουμε ότι το block κρυπτοκειμένου C1 έχει σφάλμα μετάδοσης
σε 1-bit, τότε επειδή κατά την αποκρυπτογράφηση το block απλού κειμένου P1
εξαρτάται από δύο blocks κρυπτοκειμένου (𝑃1 = 𝐶0 ⊕ 𝐷𝐾 [𝐶1 ] ) καταλήγουμε ότι το Ρ1
θα έχει τυχαίο αριθμό bits που είναι λάθος. Επίσης το block απλού κειμένου Ρ2 θα έχει
και αυτό σφάλμα κατά 1-bit, αφού (𝑃2 = 𝐶1 ⊕ 𝐷𝐾 [𝐶2 ] ) και το C1 είναι λάθος
[9,15,17,18].

Εικόνα 2. 8 Cipher Block Chaining Mode.

30
2.3.3.3.3 Cipher Feedback (CFB) Mode

Η μέθοδος Ανάδρασης Κρυπτογραφημάτων (Cipher Feedback – CFB) μπορεί να

χρησιμοποιηθεί και ως βασικό δομικό στοιχείο για την κατασκευή γεννήτριας
παραγωγής κλειδοροών για έναν αλγόριθμο ροής. Για τη χρήση της μεθόδου αρχικά
πρέπει να ορίσουμε δύο παραμέτρους: το k, (1≤k≤n) το οποίο ορίζει το μέγεθος της
μεταβλητής ανάδρασης και το j, (1≤j≤k) που ορίζει τον αριθμό των bits του απλού
κειμένου που κρυπτογραφούνται σε κάθε block. Στη πράξη, το πιο διαδεδομένο σχήμα
είναι αυτό όπου j=k=8.

Η CFB λειτουργεί ως εξής: Το αρχικό κείμενο διαιρείται σε μια σειρά από blocks μήκους
j-bits, τα P1, P2,…,Pq, όπου το Pq περιέχει t≤j bits. Κατά τη διαδικασία της
κρυπτογράφησης, η είσοδος της συνάρτησης κρυπτογράφησης είναι ένας καταχωρητής
ολίσθησης 64-bits που αρχικοποιείται με κάποιο διάνυσμα αρχικοποίησης IV. Στα j
αριστερά, δηλαδή στα j πλέον σημαντικά ψηφία της εξόδου της συνάρτησης
κρυπτογράφησης, εκτελείται η πράξη XOR με την πρώτη μονάδα του αρχικού κειμένου
P1, ώστε να παραχθεί η πρώτη μονάδα του κρυπτογραφήματος C1, η οποία μετά
αποστέλλεται(Εικόνα 2. 9). Ακολούθως, τα περιεχόμενα του καταχωρητή ολίσθησης
ολισθαίνουν αριστερά κατά j bit και το C1 τοποθετείται στα δεξιά, δηλαδή στα λιγότερο
σημαντικά j bit του καταχωρητή ολίσθησης. Η διαδικασία αυτή επαναλαμβάνεται
μέχρις ότου κρυπτογραφηθούν όλες οι μονάδες αρχικού κειμένου. Για την
αποκρυπτογράφηση χρησιμοποιείται το ίδιο σχήμα, αλλά στη λαμβανόμενη μονάδα
κρυπτογραφημάτων εκτελείται η πράξη XOR με την έξοδο της συνάρτησης
κρυπτογράφησης για την παραγωγή της μονάδας αρχικού κειμένου. Σημειώνεται ότι
χρησιμοποιείται η συνάρτηση κρυπτογράφησης και όχι η συνάρτηση
αποκρυπτογράφησης.

Όπως στην CBC mode, έτσι και στη CFB, αν το διάνυσμα αρχικοποίησης είναι το ίδιο για
κάθε μήνυμα, τότε η κρυπτογράφηση του ίδιου κειμένου καταλήγει στο ίδιο
κρυπτοκείμενο. Επομένως οι χρήστες θα πρέπει να χρησιμοποιούν διαφορετικά
διανύσματα αρχικοποίησης για κάθε ένα μήνυμα και αν γίνεται να τα κρατούν κρυφά.

Όσον αφορά την εξάπλωση σφάλματος και αυτή η μέθοδος παρουσιάζει το φαινόμενο
αυτό. Πιο συγκεκριμένα, αν υποθέσουμε ότι το block κρυπτοκειμένου Ci έχει σφάλμα
μετάδοσης σε 1-bit, τότε επειδή κατά την αποκρυπτογράφηση το block απλού κειμένου
Ρi εξαρτάται από δύο blocks κρυπτοκειμένου καταλήγουμε ότι ένα τουλάχιστον block
απλού κειμένου θα έχει τυχαίο αριθμό bits που είναι λάθος [9,15,17,18].

Εικόνα 2. 9 Cipher Feedback Mode.

31
2.3.3.3.4 Output Feedback (OFB) Mode

Η μέθοδος ανάδρασης εξόδου (Output Feedback – OFB) μπορεί επίσης να

χρησιμοποιηθεί και ως βασικό δομικό στοιχείο για την κατασκευή γεννήτριας
παραγωγής κλειδοροών για έναν αλγόριθμο ροής. Για τη χρήση της μεθόδου αρχικά
πρέπει να ορίσουμε το j, (1≤j≤k) που ορίζει τον αριθμό των bits του απλού κειμένου που
κρυπτογραφούνται σε κάθε block.

Ο τρόπος λειτουργίας της OFB είναι παρόμοιος, γενικά, με τη μέθοδο λειτουργίας CFB. Η
κύρια διαφορά τους έγκειται στο γεγονός ότι ο καταχωρητής ολίσθησης
επανατροφοδοτείται από την έξοδο της λειτουργίας κρυπτογράφησης (Εικόνα 2. 10),
ενώ στη μέθοδο CFB ο καταχωρητής ολίσθησης επανατροφοδοτείται από την
κρυπτογραφημένη ακολουθία.

Όπως και στις δύο προηγούμενες μεθόδους, έτσι και στη OFB, αν το διάνυσμα
αρχικοποίησης είναι το ίδιο για κάθε μήνυμα, τότε η κρυπτογράφηση του ίδιου
κειμένου καταλήγει στο ίδιο κρυπτοκείμενο. Επομένως οι χρήστες θα πρέπει να
χρησιμοποιούν διαφορετικά διανύσματα αρχικοποίησης για κάθε ένα μήνυμα και αν
γίνεται να τα κρατούν κρυφά.

Όσον αφορά την εξάπλωση σφάλματος αυτή η μέθοδος δεν παρουσιάζει το φαινόμενο
αυτό. Πιο συγκεκριμένα, αν υποθέσουμε ότι το block κρυπτοκειμένου Ci έχει σφάλμα
μετάδοσης σε 1-bit, τότε το block απλού κειμένου Pi θα έχει σφάλμα σε ένα bit
[9,15,17,18].

2.3.3.3.5 Counter Mode

Ένα κοινό πρόβλημα που παρουσιάζουν οι παραπάνω μέθοδοι, εκτός από την ECB είναι
πως πρέπει να γίνει αποκρυπτογράφηση όλων για να μπορούμε να διαβάσουμε ένα
κομμάτι δεδομένων. Αυτό αποτελεί σοβαρό πρόβλημα, ιδιαίτερα σε περιπτώσεις που η
πρόσβαση στα δεδομένα γίνεται με μη σειριακό τρόπο, όπως η πρόσβαση σε αρχεία
σκληρού δίσκου. Για να λυθεί το παραπάνω χρησιμοποιούμε την Counter Mode.

Εικόνα 2. 10 Output Feedback Mode

32
 Εικόνα 2. 11 Counter Mode.

Με τη μέθοδο αυτή το αρχικό κείμενο δεν κρυπτογραφείται άμεσα. Πρώτα

κρυπτογραφείται ένα διάνυσμα αρχικοποίησης (IV) και εκτελείται η λογική πράξη XOR
με το πρώτο κομμάτι κειμένου. Για κάθε νέο κομμάτι κειμένου το IV αυξάνεται κατά ένα
και η διαδικασία επαναλαμβάνεται. Έτσι κάθε block κειμένου μπορεί να
αποκρυπτογραφηθεί ανεξάρτητα από τα υπόλοιπα ανάλογα με τη θέση του
[9,15,17,18].

2.3.4 Συμμετρικοί Αλγόριθμοι Κρυπτογράφησης

Στο σημείο αυτό αξίζει να αναφερθούν ορισμένες πληροφορίες και μια συνοπτική
περιγραφή των πιο σημαντικών συμμετρικών αλγορίθμων κρυπτογράφησης. Στο
επόμενο κεφάλαιο θα γίνει μια εκτενής περιγραφή του συμμετρικού
κρυπτοσυστήματος AES.

2.3.4.1 Αλγόριθμος DES (Data Encryption Standard)

O DES εγκρίθηκε ως ομοσπονδιακό πρότυπο τον Νοέμβριο του 1976 και δημοσιεύθηκε
στις 15 Ιανουαρίου του 1977 ως FIPS PUB 46 και η χρήση του ήταν επιτρεπτή σε όλα τα
μη απόρρητα δεδομένα. Στη συνέχεια επιβεβαιώθηκε ως πρότυπο το 1983, το 1988
(αναθεωρήθηκε ως FIPS-46-1), το 1993 (ως FIPS-46-2) και πάλι το 1999 (ως FIPS-46-
3). Ο τελευταίος ορισμός ήταν ο Triple DES. Στις 26 Μαΐου του 2002 ο DES τελικά
εκτοπίστηκε από τον Advanced Encryption Standard (AES) κατόπιν δημόσιου
διαγωνισμού. Στις 19 Μαΐου του 2005 ο FIPS 46-3 είχε επισήμως αποσυρθεί, αλλά το
Εθνικό Ινστιτούτο Προτύπων και Τεχνολογίας (National Institute of Standards and
Technology - NIST) ενέκρινε τον Triple DES το έτος 2003 για τις ευαίσθητες
πληροφορίες της κυβέρνησης. Μια άλλη θεωρητική επίθεση, η γραμμική κρυπτανάλυση,
δημοσιεύθηκε το 1994, αλλά ήταν μια επίθεση εξαντλητικής αναζήτησης το 1998 που
απέδειξε ότι θα μπορούσε κάποιος πρακτικά να επιτεθεί στον DES και τονίστηκε η
ανάγκη για αντικατάσταση του αλγόριθμου.

33
Σύμφωνα με το πρότυπο DES το αρχικό κείμενο είναι μεγέθους 64-bit και το κλειδί έχει
μήκος 56-bit. Τα απλά κείμενα μεγαλύτερου μεγέθους επεξεργάζονται σε τμήματα των
64-bit.

Το αρχικό κείμενο έχει τρία στάδια επεξεργασίας. Στην αρχή, το κείμενο των 64-bit
ακολουθεί έναν αρχικό μετασχηματισμό (initial permutation - IP) στα πλαίσια του
οποίου τα bits αναδιατάσσονται για να παραχθεί η μετασχηματισμένη είσοδος.
Ακολουθεί ένα στάδιο που αποτελείται από 16 επαναλήψεις της ίδιας λειτουργίας. Η
έξοδος της τελευταίας επανάληψης, δηλαδή της δέκατης έκτης, αποτελείται από 64-bit
που αποτελούν συνάρτηση του αρχικού κειμένου και του κλειδιού. Το αριστερό μισό
τμήμα και το δεξί μισό τμήμα της εξόδου αντιμετατίθενται, ώστε να παραχθεί η αρχική
έξοδος. Η τιμή αυτή τροποποιείται με βάση ένα μετασχηματισμό που είναι o
αντίστροφος του αρχικού μετασχηματισμού (inverse initial permutation – IP-1), ώστε
να παραχθεί το κρυπτογράφημα των 64-bit.

To κλειδί των 56 - bit τροποποιείται από μια συνάρτηση μετασχηματισμού. Κατόπιν,

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

Η διαδικασία της αποκρυπτογράφησης με τον αλγόριθμο DES είναι ουσιαστικά ίδια με

τη διαδικασία κρυπτογράφησης, αφού ο κανόνας που ακολουθείται είναι: Το
κρυπτογράφημα χρησιμοποιείται ως είσοδος στον αλγόριθμο DES, αλλά τα κλειδιά Ki
τοποθετούνται σε αντίστροφη σειρά. Ουσιαστικά, το K16 χρησιμοποιείται στην πρώτη
επανάληψη, το K15 στη δεύτερη επανάληψη, κ.ο.κ.., έως ότου χρησιμοποιηθεί το K1 στη
δέκατη έκτη και τελευταία επανάληψη.

Η ανησυχία που υπήρχε για την ισχύ του αλγορίθμου DES βασιζόταν σε δύο αιτίες:
αιτίες σχετιζόμενες με τον ίδιο τον αλγόριθμο και αιτίες σχετιζόμενες με τη χρήση
κλειδιού με μέγεθος 56-bit.

Η πρώτη κατηγορία αιτιών ανησυχίας βασιζόταν στην πιθανότητα να καταστεί εφικτή

η κρυπτανάλυση του DES με εκμετάλλευση κάποιων χαρακτηριστικών του αλγορίθμου.
Παρόλα αυτά, αν και έχουν πραγματοποιηθεί πολλές απόπειρες για εύρεση και
εκμετάλλευση αδυναμιών του αλγορίθμου, δεν ανακαλύφθηκαν, ή τουλάχιστον δε
δημοσιεύτηκαν, σημαντικής κλίμακας αδυναμίες του DES, γεγονός που τον
ανακηρύσσει ως τον εκτενέστερα μελετημένο ρωμαλέο αλγόριθμο κρυπτογράφησης.

Η δεύτερη κατηγορία αιτιών ανησυχίας βασιζόταν στο μήκος του κλειδιού. Ήδη από τα
τέλη της δεκαετίας του '70 εμπειρογνώμονες σε θέματα ασφάλειας προειδοποιούσαν
ότι η χρονική διάρκεια κατά την οποία ο αλγόριθμος DES με μέγεθος κλειδιού 56 bit θα
θεωρείται ασφαλής αλγόριθμος, είναι ολοένα και μικρότερη, λαμβάνοντας υπόψη τις
διαφαινόμενες τάσεις αύξησης της ταχύτητας των επεξεργαστών και ταυτόχρονης
μείωσης των τιμών του υλικού. Τον Ιούλιο του 1998, το Ίδρυμα Electronic Frontier
Foundation - EFF ανακοίνωσε ότι κατάφερε εντός τριών ημερών την κρυπτανάλυση
ενός DES κρυπτομηνύματος χρησιμοποιώντας μία μηχανή ειδικού σκοπού
αποκαλούμενη DES cracker που κόστισε λιγότερο από 250.000 δολάρια. Το EFF
δημοσίευσε λεπτομερή περιγραφή της μηχανής, παρέχοντας τη δυνατότητα και σε
όποιον άλλον επιθυμούσε να δημιουργήσει αντίστοιχες ατομικές μηχανές
[5,8,9,15,17,18].

34
2.3.4.2 Αλγόριθμος Triple DES

O ΤDES ή TDEA ή συνηθέστερα 3DES προτάθηκε αρχικά από τον W. Tuchman και το
1985 προτυποποιήθηκε στο ANSI X9.17, ώστε να χρησιμοποιηθεί σε οικονομικές
εφαρμογές. Το 1999, με τη δημοσίευση του ως FIPS PUB 46-3, o TDES ενσωματώθηκε
ως τμήμα της προτυποποίησης κρυπτογράφησης δεδομένων DES. Ο TDES ακολούθησε
τον αλγόριθμο 2DES, ο οποίος δεν αξιοποιήθηκε ευρέως αφού θεωρήθηκε ευάλωτος
στις κρυπταναλυτικές επιθέσεις τύπου ενδιάμεσου (man in the middle attack).

Ο TDES χρησιμοποιεί τρία κλειδιά και τρεις εκτελέσεις του αλγορίθμου DES. Ο
αλγόριθμος ακολουθεί τη διαδοχή: κρυπτογράφηση, αποκρυπτογράφηση,
κρυπτογράφηση (EDE – encryption – decryption - encryption) (Εικόνα 2. 12 α):

C=EK3[DK2[EK1[P]]]
όπου:
C = κρυπτογράφημα
P = αρχικό κείμενο
EK[X] = κρυπτογράφηση του Χ με χρήση του κλειδιού Κ
DK[Y] = αποκρυπτογράφηση του Χ με χρήση του κλειδιού Κ

Η αποκρυπτογράφηση ακολουθεί ακριβώς την ίδια διαδικασία με τα κλειδιά σε

αντίστροφη χρήση (Εικόνα 2. 12 β):
P=DK1[EK2[DK3[P]]]

Αξίζει να σημειωθεί ότι η ύπαρξη της αποκρυπτογράφησης στο δεύτερο στάδιο της
κρυπτογράφησης TDES δεν παρουσιάζει κάποια κρυπτογραφική χρησιμότητα, απλώς
επιτρέπει στους χρήστες του TDES να αποκρυπτογραφήσουν τα στοιχεία που
κρυπτογραφούνται από τους χρήστες του απλού DES:

C=EK1[DK1[EK1[P]]]=EK1[P]

Ο TDES, με την υποστήριξη τριών διαφορετικών κλειδιών, διαθέτει κλειδί μήκους 168-
bit. Στα πλαίσια του FIPS 46-3 επιτρέπεται, επίσης, η χρήση δύο κλειδιών K1, K2, με K1
= K3. Το γεγονός αυτό εξασφαλίζει μήκος κλειδιού 112-bit. Το FIPS 46-3 περιλαμβάνει
τις ακόλουθες οδηγίες για το TDES:

• Ο TDES αποτελεί τον εγκεκριμένο συμβατικό αλγόριθμο κρυπτογράφησης ως

FIPS.
• Το DES, που χρησιμοποιεί μοναδικό κλειδί των 56-bit, επιτρέπεται στα
συστήματα διαχείρισης δικτύων για επίτευξη συμβατότητας προς τα κάτω. Τα
νέα συστήματα, όμως, πρέπει να υποστηρίζουν το TDES.
• Οι κυβερνητικές οργανώσεις των ΗΠΑ που χρησιμοποιούν DES ενθαρρύνονται
για τη μετάβαση σε TDES.
• Είναι αναμενόμενο ότι το TDES και το Advanced Encryption Standard – AES θα
συνυπάρξουν ως FIPS εγκεκριμένοι αλγόριθμοι, μέχρι την οριστική μετάβαση
στο AES.

Ο TDES αποτελεί έναν εξαιρετικό αλγόριθμο, ο οποίος επειδή προέρχεται από τον DES
παρουσιάζει την ίδια ρωμαλεότητα με αυτόν σε κρυπταναλυτικές επιθέσεις. Επιπλέον,
με μήκος κλειδιού 168-bit οι επιθέσεις τύπου εξαντλητικής αναζήτησης είναι πρακτικά
ατελέσφορες. Συνεπώς ο TDES αναμένεται ότι θα αξιοποιείται ολοένα και περισσότερο
τα επόμενα χρόνια, μέχρι την ολοκληρωτική μετάβαση στις επερχόμενες υλοποιήσεις
του AES [5,8,9,15,17,18].

35
 K1 K2 K3

P A B C
E D E

α)Κρυπτογράφηση

K3 K2 K1

B A
C P
D E D

β)Αποκρυπτογράφηση

Εικόνα 2. 12 TDES.

2.3.4.3 Αλγόριθμος AES (Advanced Encryption Standard)

Η ραγδαία αύξηση της υπολογιστικής ισχύος, σε συνδυασμό με τη μείωση του κόστους

των υπολογιστικών συστημάτων, κατέστησε τον DES ευάλωτο σε κρυπταναλυτικές
επιθέσεις. Ως προσωρινό μέτρο δημιουργήθηκε μία ασφαλέστερη παραλλαγή του DES, ο
Triple-DES, ο οποίος εξακολουθούσε να είναι ευάλωτος, παρ’ ότι ασφαλέστερος του
DES. Υπό τις συνθήκες αυτές, εκρίθη απαραίτητη η υιοθέτηση ενός νέου
κρυπτογραφικού προτύπου. Τον Ιανουάριο του 1997, το “Εθνικό Ινστιτούτο Προτύπων
& Τεχνολογίας” των ΗΠΑ (National Institute of Standards and Technology, NIST)
προκήρυξε διεθνή διαγωνισμό για την υιοθέτηση του νέου κρυπτογραφικού προτύπου
εμπορικής (μη κυβερνητικής) χρήσεως, του AES. Το πρότυπο AES θα πρέπει να
αποτελεί κωδικοποιητή τμημάτων με συμμετρικό σύστημα κρυπτογράφησης, μήκους
τμήματος 128 bit και να υποστηρίζει κλειδιά μήκους 128-bit, 192-bit και 256-bit.

Σε έναν πρώτο κύκλο αξιολόγησης έγιναν αποδεκτοί δεκαπέντε προτεινόμενοι

αλγόριθμοι και σε δεύτερο κύκλο ο αριθμός των αποδεκτών αλγορίθμων μειώθηκε σε
πέντε. Οι αλγόριθμοι αυτοί ήταν οι MARS, RC6, Rijndael, Serpent, Twofish. Τελικά
επιλέχθηκε επισήμως ως AES ο αλγόριθμος Rijndael, ο οποίος είχε υποβληθεί από τους
Βέλγους κρυπτογράφους J. Daemen και V. Rijmen και έλαβε την οριστική του
σχεδιαστική μορφή στο τέλος του καλοκαιριού του 2001.

Ο αλγόριθμος Rijndael περιλαμβάνει 10, 12 ή 14 κύκλους, ανάλογα με το μήκος του

μυστικού κλειδιού. Κάθε κύκλος περιλαμβάνει τέσσερις μετασχηματισμούς, τους:
SubByte, ShiftRow, MixColumn, AddRoyndKey. Ο SubByte μετασχηματισμός
εφαρμόζεται σε όλα τα bytes του τμήματος. Οι μετασχηματισμοί ShiftRow και
MixColumn υποστηρίζουν τη γραμμική ανάμειξη των δεδομένων του τμήματος. Ο
μετασχηματισμός AddRoundKey συσχετίζει τα bytes του τμήματος με τα bytes των
υποκλειδιών με την πράξη XOR. Επιπλέον, ο μετασχηματισμός AddRoundKey εκτελείται
μία ακόμη φορά στη φάση αρχικοποίησης πριν τον πρώτο κύκλο, ενώ στον τελευταίο
κύκλο παραλείπεται ο μετασχηματισμός MixColumn [5,8,9,15,17,18].

Περισσότερα όμως για το πρότυπο AES θα δούμε στο επόμενο κεφάλαιο όπου και
παρουσιάζεται αναλυτικά όλη η λειτουργία του.

36
2.3.4.4 Αλγόριθμος IDEA (International Data Encryption Algorithm)

Ο αλγόριθμος International Data Encryption Algorithm – IDEA αποτελεί έναν

συμμετρικό κωδικοποιητή τμημάτων, που αναπτύχθηκε από τους X. Lai και J. Massey,
στο Swiss Federal Institute of Technology, το 1991. Ο IDEA χρησιμοποιεί κλειδί μήκους
128-bit και διαφέρει από τον DES τόσο στη συνάρτηση F, όσο και στη συνάρτηση
παραγωγής των υποκλειδιών. Για τη συνάρτηση F, o IDEA δε χρησιμοποιεί S-boxes,
αλλά στηρίζεται σε τρεις διαφορετικές μαθηματικές λειτουργίες: τη δυαδική πράξη
XOR, τη δυαδική πρόσθεση ακεραίων των 16-bit και το δυαδικό πολλαπλασιασμό
ακεραίων των 16-bit.

Οι συναρτήσεις συνδυάζονται με τρόπον ώστε να αναπτυχθεί ένας πολύπλοκος

μετασχηματισμός που αναλύεται δύσκολα, ώστε να καθίσταται πολύ δύσκολη η
διαδικασία κρυπτανάλυσης. Ο αλγόριθμος παραγωγής δευτερευόντων κλειδιών
βασίζεται στη χρήση κυκλικών μετατοπίσεων, οι οποίες χρησιμοποιούνται με
πολύπλοκο τρόπο για να παραχθούν συνολικά έξι δευτερεύοντα κλειδιά, για καθέναν
από τους οκτώ γύρους του IDEA.

Παρόλο που δεν έχει την κατασκευή ενός αλγορίθμου Feistel, η αποκρυπτογράφηση
γίνεται με τον ίδιο τρόπο που γίνεται και η κρυπτογράφηση. Έχει σχεδιαστεί για να
είναι εύκολα εφαρμόσιμος τόσο σε υλικό όσο και σε λογισμικό. Μερικές όμως
αριθμητικές διεργασίες που χρησιμοποιεί ο IDEA καθιστούν τις λογισμικές εφαρμογές
αργές, παρόμοιες σε ταχύτητα με τον DES.

Ο IDEA ήταν ένας από τους προτεινόμενους 128-bit αντικαταστάτες του DES, έχει
υποβληθεί σε αξιοσημείωτη διερεύνηση και εμφανίζεται ανθεκτικός σε
κρυπταναλυτικές επιθέσεις. Ο IDEA χρησιμοποιείται στο προϊόν λογισμικού PGP, ως μία
από τις εναλλακτικές επιλογές, καθώς και σε διάφορα εμπορικά προϊόντα
[5,8,9,15,17,18].

2.3.4.5 Αλγόριθμος RC2

Ο κρυπτογραφικός αλγόριθμος RC2 αναπτύχθηκε από τον Ron Rivest της εταιρίας RSA
Security το 1987. Είναι ένας κρυπτογραφικός αλγόριθμος τμήματος με μέγεθος block 64
bits που χρησιμοποιεί 18 γύρους σε δίκτυο Feistel. Βασικό χαρακτηριστικό του είναι ότι
υποστηρίζει κλειδιά μεταβλητού μεγέθους από 8 έως 128 bits. Αν το μέγεθος του
κλειδιού είναι μεγαλύτερο από 56 bits είναι ανεκτικότερος από τον αλγόριθμο DES
[5,8,9,15,17,18].

2.3.4.5 Αλγόριθμος RC4

Ο RC4 είναι ένας αλγόριθμος ροής που σχεδιάστηκε από τον Ron Rivest της εταιρίας
RSA Security το 1987 και δημοσιεύτηκε το 1994. Έχει μεταβλητό μήκος κλειδιού από 40
έως 2048 bits και λειτουργεί σε επίπεδο byte. Χρησιμοποιεί 256 γύρους και θεωρείται
εξαιρετικά ασφαλής και οι υλοποιήσεις του σε λογισμικό τρέχουν πολύ γρήγορα.
Χρησιμοποιείται για κρυπτογράφηση τοπικά αποθηκευμένων αρχείων και για τη
διασφάλιση της επικοινωνίας μεταξύ δύο απομακρυσμένων σημείων μέσω του
πρωτοκόλλου SSL [5,8,9,15,17,18].

37
2.3.4.6 Αλγόριθμος RC5

Ο RC5 αναπτύχθηκε το 1994 από τον R. Rivest, έναν από τους σχεδιαστές του
αλγορίθμου δημοσίου κλειδιού RSA. Ο RC5 προσδιορίζεται στο RFC 2040 και
σχεδιάστηκε για να υποστηρίζει τα ακόλουθα χαρακτηριστικά:

• Κατάλληλος για υλοποίηση σε υλικό ή λογισμικό: O RC5 χρησιμοποιεί μόνο

βασικές υπολογιστικές λειτουργίες, που συνήθως περιλαμβάνονται στους
μικροεπεξεργαστές.
• Ταχύς: Προκειμένου να επιτευχθεί υψηλή ταχύτητα, ο RC5 είναι ένας απλός
αλγόριθμος που βασίζεται στη λέξη (word). Οι βασικές λειτουργίες του
στηρίζονται σε πλήρεις λέξεις δεδομένων ανά στιγμή.
• Προσαρμόσιμος σε επεξεργαστές διαφορετικών μηκών λέξης: Ο αριθμός των
δυαδικών ψηφίων σε μία λέξη αποτελεί παράμετρο του RC5, έτσι ώστε
διαφορετικά μήκη λέξης παράγουν διαφορετικούς αλγορίθμους.
• Μεταβλητό μήκος γύρων: Ο αριθμός των γύρων αποτελεί δεύτερη παράμετρο
του RC5. Αυτή η παράμετρος επιτρέπει την εναλλαγή μεταξύ υψηλότερης
ταχύτητας και υψηλότερης ασφάλειας.
• Μεταβλητό μήκος κλειδιού: Το μήκος κλειδιού αποτελεί την τρίτη παράμετρο
του RC5. Επίσης επιτρέπει την εναλλαγή μεταξύ υψηλότερης ταχύτητας και
υψηλότερης ασφάλειας.
• Απλός: Η απλή δομή του RC5 υλοποιείται εύκολα και διευκολύνει τον
υπολογισμό της ισχύος του αλγορίθμου.
• Χαμηλή απαίτηση μνήμης: Η χαμηλή απαίτηση μνήμης καθιστά τον αλγόριθμο
RC5 κατάλληλο για αξιοποίηση σε έξυπνες κάρτες και άλλες συσκευές
περιορισμένης μνήμης.
• Υψηλή ασφάλεια: Ο RC5 προορίζεται για να παρέχει υψηλή ασφάλεια με
προσδιορισμό των κατάλληλων παραμέτρων.
• Περιστροφές εξαρτώμενες από τα δεδομένα: Ο RC5 ενσωματώνει τις
περιστροφές, δηλαδή κυκλικές μετατοπίσεις δυαδικών ψηφίων, των οποίων ο
αριθμός είναι στοιχείο εξαρτώμενο από τα δεδομένα. Το γεγονός αυτό ενισχύει
τον αλγόριθμο ενάντια στην κρυπτανάλυση.

Ο RC5 χρησιμοποιείται σε διάφορα προϊόντα από την RSA Data Security, Inc
[5,8,9,15,17,18].

2.3.4.7 Αλγόριθμος RC6

Ο αλγόριθμος RC6 δημοσιεύτηκε το 1998 και περιλαμβάνει 20 κύκλους
μετασχηματισμών. Σε όλους τους κύκλους διεξάγεται μεταβλητή περιστροφή
δεδομένων και οι πράξεις που λαμβάνουν χώρα είναι πολλαπλασιασμός, πρόσθεση, XOR
και πρόσθεση υποκλειδιών. Έχει μέγεθος τμήματος 128 bits και μέγεθος κλειδιού 128,
192 ή 256 bits [5,8,9,15,17,18].

2.3.4.8 Αλγόριθμος MARS

Ο αλγόριθμος MARS περιλαμβάνει 32 κύκλους μετασχηματισμών. Από αυτούς, μόνον οι
16 κύκλοι βασίζονται στο μυστικό κλειδί και οι πράξεις που λαμβάνουν χώρα είναι ο
πολλαπλασιασμός, η πρόσθεση με κλειδιά των 32-bit και η ολίσθηση ή περιστροφή των

38
δεδομένων. Οι υπόλοιποι 16 κύκλοι αξιοποιούν 8 S-boxes των 32 bit με πράξεις
πρόσθεσης και XOR [5,8,9,15,17,18].

2.3.4.9 Αλγόριθμος Serpent

Ο αλγόριθμος Serpent περιλαμβάνει 32 κύκλους μετασχηματισμών. Στον αλγόριθμο

προσδιορίζεται μία αρχική και μία τελική μετάθεση, οι οποίες διευκολύνουν
εναλλακτικούς τρόπους λειτουργίας. Σε καθέναν από τους 32 κύκλους περιλαμβάνονται
τρία επιμέρους επίπεδα μετασχηματισμών: η πράξη XOR με το υποκλειδί, 32
παράλληλες εφαρμογές ενός από τα 8 S-boxes και ένας γραμμικός μετασχηματισμός
[5,8,9,15,17,18].

2.3.4.10 Αλγόριθμος Twofish

Ο αλγόριθμος Twofish περιλαμβάνει 16 κύκλους, σε καθέναν από τους οποίους

εφαρμόζονται 4 S-boxes τα οποία εξαρτώνται από το μυστικό κλειδί. Τα επόμενα
στάδια περιλαμβάνουν την αξιοποίηση σταθερών S-boxes, τη διενέργεια
μετασχηματισμού pseudo-Hadamard, καθώς και την πρόσθεση του υποκλειδιού
[5,8,9,15,17,18].

2.3.4.11 Αλγόριθμος Blowfish

Ο αλγόριθμος Blowfish αναπτύχθηκε το 1993 από τον επιφανή κρυπτογράφο B.

Schneier και καθιερώθηκε ως μία από τις δημοφιλέστερες εναλλακτικές λύσεις του DES.
Ο Blowfish σχεδιάστηκε ώστε να είναι εύκολος στην υλοποίηση και να παρουσιάζει
μεγάλη ταχύτητα εκτέλεσης. Πρόκειται για ένα συνεπτυγμένο αλγόριθμο που μπορεί να
εκτελεστεί σε μνήμη μικρότερη από 5K. Ενδιαφέρον χαρακτηριστικό γνώρισμα του
Blowfish αποτελεί το μήκος κλειδιού, το οποίο είναι μεταβλητό, μπορεί να λάβει τιμές
έως 448-bit, αν και πρακτικά χρησιμοποιούνται κλειδιά των 128-bit. Ο Blowfish
χρησιμοποιεί 16 γύρους.

Όπως ο αλγόριθμος DES, ο αλγόριθμος Blowfish χρησιμοποιεί S-boxes, XOR, καθώς και
δυαδική πρόσθεση. Αντίθετα από τον DES που χρησιμοποιεί σταθερά S-boxes, ο
Blowfish χρησιμοποιεί δυναμικά S-boxes που παράγονται ως συνάρτηση του κλειδιού.
Στον Blowfish, τα υποκλειδιά και τα S-boxes παράγονται από την επανειλημμένη
εφαρμογή του ίδιου του αλγορίθμου Blowfish στο κλειδί. Συνολικά απαιτούνται 521
εκτελέσεις του αλγορίθμου κρυπτογράφησης Blowfish για την παραγωγή των
υποκλειδιών και των S-boxes. Απόρροια των χαρακτηριστικών αυτών είναι το
συμπέρασμα ότι ο Blowfish δεν είναι κατάλληλος για εφαρμογές στις οποίες το μυστικό
κλειδί αλλάζει συχνά.

Ο Blowfish περιλαμβάνεται στους καλύτερους συμβατικούς αλγορίθμους

κρυπτογράφησης που έχουν εφαρμοστεί, αφού τα υποκλειδιά και τα S-boxes
παράγονται από διαδικασία επανειλημμένων εφαρμογών του Blowfish στον εαυτό του.
Οι επαναλήψεις αυτές τροποποιούν πλήρως τα δυαδικά ψηφία και καθιστούν την
κρυπτανάλυση εξαιρετικά δύσκολη. Οι μέχρι σήμερα δημοσιεύσεις των προσπαθειών
για κρυπτανάλυση του Blowfish δεν αναφέρουν πρακτικές αδυναμίες. Ο Blowfish
χρησιμοποιείται, επίσης, σε διάφορες εμπορικές εφαρμογές [5,8,9,15,17,18].

39
2.3.4.12 Αλγόριθμος CAST-128

Το CAST αποτελεί μία διαδικασία σχεδίασης συμμετρικών αλγορίθμων

κρυπτογράφησης, η οποία αναπτύχθηκε το 1997 από τους C. Adams και S. Tavares της
εταιρίας Entrust Technologies. Ένας συγκεκριμένος αλγόριθμος που αναπτύχθηκε ως
τμήμα του προγράμματος CAST είναι ο CAST-128 που ορίστηκε στο RFC 2144. Στον
αλγόριθμο αυτό χρησιμοποιείται μέγεθος κλειδιού που λαμβάνει τιμές μεταξύ 40-bit και
128-bit, με βήματα των 8-bit. Το CAST είναι το αποτέλεσμα μιας μακράς χρονικά
διαδικασίας έρευνας και ανάπτυξης και έχει ενσωματώσει σειρά σχολίων από
κρυπταναλυτές. Σε πρώτη φάση είχε χρησιμοποιηθεί σε διάφορα προϊόντα,
συμπεριλαμβανομένου και του PGP.

Το CAST χρησιμοποιεί σταθερά S-boxes, αλλά μόνον αυτά που είναι σημαντικά
μεγαλύτερα των S-boxes που χρησιμοποιούνται στο DES. Τα S-boxes σχεδιάστηκαν
προσεκτικά, ώστε να μην παρουσιάζουν γραμμικότητα στη σχέση εισόδου και εξόδου,
συνεπώς να είναι ανθεκτικά σε κρυπταναλυτικές επιθέσεις. Η διαδικασία παραγωγής
υποκλειδιών που χρησιμοποιείται στον CAST-128 είναι διαφορετική από αυτήν που
υιοθετείται σε άλλους συμβατικούς αλγορίθμους κρυπτογράφησης τμημάτων. Οι
σχεδιαστές του CAST προσπάθησαν να δημιουργήσουν υποκλειδιά με μεγαλύτερο
βαθμό ανθεκτικότητας σε γνωστές κρυπταναλυτικές επιθέσεις. Θεωρήθηκε ότι η χρήση
μη-γραμμικών S-boxes για παραγωγή κλειδιών από το βασικό κλειδί, παρείχε αυτή την
ισχύ. Αξιοσημείωτο χαρακτηριστικό γνώρισμα του CAST-128 αποτελεί η συνάρτηση
κύκλου F, η οποία διαφέρει από γύρο σε γύρο, καθιστώντας τον αλγόριθμο
κρυπταναλυτικά ανθεκτικότερο [5,8,9,15,17,18].

2.3.4.13 Σύγκριση συμμετρικών αλγορίθμων

Το μήκος κλειδιού είναι ένας από τους διάφορους παράγοντες που προσδιορίζουν το
βαθμό ασφαλείας που προσφέρει μια κρυπτογράφηση. Όπως και με όλα τα θέματα
ασφαλείας, το σημαντικότερο θέμα είναι η εξισορρόπηση του κόστους, του χρόνου και
άλλων στοιχείων. Κλειδιά των 56 bits που χρησιμοποιούνται, για παράδειγμα, στον DES,
δεν είναι ασφαλή ώστε να αποτρέψουν τους διάφορους εισβολείς.

Οι προγραμματιστές πρέπει να αξιολογήσουν τι είναι απαραίτητο, παράλληλα με το

κόστος ανάπτυξης, ταχύτητα της εκτέλεσης, πληρωμές δικαιωμάτων και
πλεονεκτήματα ασφάλειας για την επιλογή ενός αλγορίθμου κρυπτογράφησης. Για
αυτό το λόγο, είναι σαφώς λογικό να χρησιμοποιηθεί όσο το δυνατόν ισχυρότερη
ασφάλεια, υπολογιζόμενη όμως και με άλλους παράγοντες και λαμβάνοντας υπόψη την
αναμενόμενη διάρκεια ζωής της εφαρμογής. Για παράδειγμα σε ταχύτερους
υπολογιστές τα μεγαλύτερα κλειδιά θα επεξεργάζονται πιο γρήγορα αλλά επίσης, τα
μικρά κλειδιά σε παλαιού τύπου συστήματα μπορεί να είναι πιο εύκολα παραβιάσιμα.
Κατά την επιλογή ενός αλγορίθμου κρυπτογράφησης πρέπει να ληφθεί επίσης υπόψη η
πλατφόρμα πάνω στην οποία θα “χτιστεί” o αλγόριθμος (επεξεργαστή,
μικροεπεξεργαστή, smart cards, VLSI, FPGA) καθώς και το μέγεθος της εφαρμογής.
Γενικά κατά το σχεδιασμό ενός συστήματος θα πρέπει να λαμβάνονται υπόψη τα εξής:

• Ο αλγόριθμος πρέπει να παρέχει υψηλό επίπεδο ασφαλείας.

• Ο αλγόριθμος πρέπει να είναι πλήρως καθορισμένος και εύκολα κατανοητός.
• Η ασφάλεια του αλγορίθμου πρέπει να βρίσκεται στο κλειδί και να μην
εξαρτάται από το απόρρητο του αλγόριθμου.

40
 • Ο αλγόριθμος πρέπει να είναι διαθέσιμος σε όλους τους χρήστες.
• Ο αλγόριθμος πρέπει να είναι προσαρμόσιμος για χρήση σε διάφορες
εφαρμογές.
• Ο αλγόριθμος πρέπει να είναι οικονομικά υλοποιήσιμος σε ηλεκτρονικές
συσκευές.
• Ο αλγόριθμος πρέπει να είναι αποτελεσματικός στη χρήση.

Όλα τα παραπάνω έχουν ληφθεί υπόψη και έχουν εφαρμοστεί στους αλγορίθμους που
μελετήσαμε. Οι διαφορές τους βρίσκονται στο μέγεθος του κλειδιού που
χρησιμοποιούν, στο μέγεθος του τμήματος που επεξεργάζονται και στον τρόπο με τον
οποίο επεξεργάζονται τα δεδομένα. Βέβαια κάποιοι αλγόριθμοι έχουν υποστεί
κρυπταναλυτικές επιθέσεις και κάποιοι επίσης έχουν σπάσει. Στον Πίνακα 2. 1
παρουσιάζονται συνοπτικά τα χαρακτηριστικά των πιο δημοφιλών συμμετρικών
αλγορίθμων [21].

Αλγόριθμος Δημιουργοί Μέγεθος Μέγεθος Δομή αλγορίθμου Κύκλοι Έχει Υπάρχουσες

Τμήματος Κλειδιού Σπάσει? Επιθέσεις

DES IBM 1975 64 bits 56 bits Δίκτυο Feistel 16 Ναι Επίθεση ωμής βίας
(Brute force attack),
διαφορική
κρυπτανάλυση,
γραμμική
κρυπτανάλυση
επίθεση Davies
TDES IBM 1978 64 bits 112 bits ή Δίκτυο Feistel 48 Όχι Πιθανώς σε
168 bits θεωρητικό επίπεδο

AES Joan Daemen 128 bits 128 bits, Δίκτυο 10/12/14 Όχι Επιθέσεις πλευρικού
& Vincent 192 bits, αντικαταστάσεων- καναλιού
Rijmen 1998 256 bits αντιμεταθέσεων
Twofish Bruce 128 bits 128 bits, Δίκτυο Feistel 16 Όχι Κατατετμημένη
Schneier 192 bits, διαφορική
1993 256 bits κρυπτανάλυση
Blowfish Bruce 64 bits 32-448 bit Δίκτυο Feistel 16 Όχι Δεύτερης τάξης
Schneier 1993 σε βήματα διαφορική επίθεση
των 8 bits.
128 bits
προεπιλογή

RC2 Ron Rivest 64 bits 8-128 bit Δίκτυο Feistel 18 Ναι Σχετικές επιθέσεις
1987 σε βήματα κλειδιού
των 8 bits.
64 bits
προεπιλογή
RC4 Ron Rivest - 40-2048 Ροής 256 Ναι Διάκριση με βάση το
1987 bits χρονοδιάγραμμα
αδύναμου κλειδιού

Πίνακας 2. 1 Χαρακτηριστικά συμμετρικών αλγορίθμων.

41
2.3.5 Ασύμμετρα Κρυπτοσυστήματα

Η ασύμμετρη κρυπτογραφία ή κρυπτογραφία δημόσιου κλειδιού (public key

cryptography) λύνει το πρόβλημα της ανταλλαγής κλειδιών με ασφάλεια. Εφευρέθηκε
στο τέλος της δεκαετίας του 1970 από τους Whitfield Diffie και Martin Hellman με
σκοπό να παρέχει ένα τελείως διαφορετικό μοντέλο διαχείρισης των κρυπτογραφικών
κλειδιών. Χρησιμοποιούνται δύο αντιστρόφως συσχετιζόμενα κλειδιά, ένα δημόσιο
κλειδί που διανέμεται ελεύθερα και ένα ιδιωτικό που κρατείται από τον κάτοχό του
μυστικό. Επομένως κάθε μέρος μιας συναλλαγής έχει ένα ζεύγος κλειδιών, ένα δημόσιο
και ένα ιδιωτικό, τα οποία σχετίζονται μεταξύ τους με κάποια μαθηματική σχέση. Αν
χρησιμοποιηθεί το δημόσιο κλειδί για την κρυπτογράφηση ενός μηνύματος, μόνο το
αντίστοιχο ιδιωτικό κλειδί μπορεί να το αποκρυπτογραφήσει και αντιστρόφως.

Για την ασφαλή αποστολή ενός μηνύματος, ο αποστολέας χρησιμοποιεί για την
κρυπτογράφηση του το δημόσιο κλειδί του προβλεπόμενου παραλήπτη. Το μήνυμα
είναι δυνατόν να διαβαστεί μόνον από αυτόν (τον παραλήπτη), διότι η
αποκρυπτογράφησή του γίνεται με χρήση του μυστικού, ιδιωτικού του κλειδιού.
Επομένως, εξασφαλίζεται το απόρρητο του μηνύματος. Εξάλλου, είναι υπολογιστικά
ανέφικτο να εξαχθεί το ιδιωτικό κλειδί από το αντίστοιχο δημόσιο κλειδί. Στην Εικόνα
2. 13 που ακολουθεί παρουσιάζεται σχηματικά η παραπάνω διαδικασία.

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

Η δημιουργία του δημόσιου και του ιδιωτικού κλειδιού γίνεται από ειδικές συναρτήσεις
οι οποίες δέχονται ως είσοδο έναν μεγάλο τυχαίο αριθμό και στην έξοδο παράγουν το
ζεύγος των κλειδιών. Είναι προφανές ότι όσο πιο τυχαίος είναι ο αριθμός που παρέχεται
ως είσοδος στην γεννήτρια κλειδιών τόσο πιο ασφαλή είναι τα κλειδιά που παράγονται.

Εικόνα 2. 13 Ασύμμετρη κρυπτογραφία.

42
Οι κρυπτογραφικοί αλγόριθμοι δημοσίου κλειδιού μπορούν να εγγυηθούν
εμπιστευτικότητα (confidentiality), δηλαδή ότι το κρυπτογραφημένο μήνυμα που θα
σταλεί από τον αποστολέα μέσω του διαδικτύου στον παραλήπτη θα είναι αναγνώσιμο
από αυτόν και μόνο αφού μπορεί να αποκρυπτογραφηθεί μόνο από το ιδιωτικό του
κλειδί. Άρα λοιπόν με αυτόν τον τρόπο ο αποστολέας γνωρίζει ότι το κρυπτογραφημένο
μήνυμα μπορεί να αποκρυπτογραφηθεί μονάχα από τον παραλήπτη και έτσι
διασφαλίζεται η εμπιστευτικότητα του μηνύματος.

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

Χρησιμοποιώντας κατάλληλα τους κρυπτογραφικούς αλγορίθμους δημοσίου κλειδιού

μπορεί να επιτευχθεί πιστοποίηση (authentication), δηλαδή ο παραλήπτης να γνωρίζει
με ασφάλεια την ταυτότητα του αποστολέα. Για να επιτευχθεί αυτό θα πρέπει ο
αποστολέας να χρησιμοποιήσει το ιδιωτικό του κλειδί για την κρυπτογράφηση του
μηνύματος. Στην συνέχεια στέλνει το μήνυμα στον παραλήπτη και ο τελευταίος
χρησιμοποιεί το δημόσιο κλειδί του αποστολέα για την αποκρυπτογράφησή του.
Δεδομένου ότι το ιδιωτικό κλειδί του αποστολέα είναι γνωστό μονάχα στον ίδιο, ο
παραλήπτης μπορεί να είναι σίγουρος για την ταυτότητα του αποστολέα (Εικόνα 2. 14).

Παρόλο που η παραπάνω μέθοδος εγγυάται την ταυτοποίηση του αποστολέα, δεν
δύναται να εγγυηθεί και την εμπιστευτικότητα του μηνύματος. Πράγματι, το μήνυμα
μπορεί να το αποκρυπτογραφήσει ο οποιοσδήποτε διαθέτει το δημόσιο κλειδί του
αποστολέα. Όπως έχει ήδη ειπωθεί, το δημόσιο κλειδί είναι γνωστό σε όλη την
διαδικτυακή κοινότητα, άρα πρακτικά ο οποιοσδήποτε μπορεί να διαβάσει το
περιεχόμενο του μηνύματος.

Εικόνα 2. 14 Επαλήθευση ταυτότητας αποστολέα.

43
Συνδυάζοντας τις δύο τεχνικές που παρουσιάστηκαν παραπάνω είναι εφικτό να
επιτευχθεί και εμπιστευτικότητα του μηνύματος και πιστοποίηση του αποστολέα.
Δηλαδή αφενός το μήνυμα να παραμένει γνωστό μόνο στον αποστολέα και τον
παραλήπτη και αφετέρου ο παραλήπτης να γνωρίζει με ασφάλεια ποιος του έστειλε το
μήνυμα. Για να επιτευχθεί αυτό ο αποστολέας μπορεί να κρυπτογραφήσει το μήνυμα
πρώτα με το δικό του ιδιωτικό κλειδί και στην συνέχεια με το δημόσιο κλειδί του
παραλήπτη. Όταν ο παραλήπτης λάβει το μήνυμα θα πρέπει να χρησιμοποιήσει το
ιδιωτικό του κλειδί για να το αποκρυπτογραφήσει (εμπιστευτικότητα) και στην
συνέχεια να αποκρυπτογραφήσει το αποτέλεσμα χρησιμοποιώντας το δημόσιο κλειδί
του αποστολέα (πιστοποίηση) [6,16].

Ενδεικτικά αναφέρονται παρακάτω ορισμένοι ασύμμετροι αλγόριθμοι

κρυπτογράφησης και στη συνέχεια περιγράφονται συνοπτικά οι πιο σημαντικοί.

Ασύμμετροι Αλγόριθμοι Κρυπτογράφησης

• RSA
• Ανταλλαγή κλειδιού Diffie-Hellman
• DSA
• Paillier
• El Gamal
• Κρυπτογραφία ελλειπτικών καμπυλών (ECC)

2.3.5.1 Αλγόριθμος RSA

Ένα από τα πρώτα ασύμμετρα κρυπτοσυστήματα αναπτύχθηκε το 1977 από

τους R. Rivest, A. Shamir και L. Adleman στο ΜΙΤ και δημοσιεύτηκε για πρώτη
φορά το 1978. Από εκείνη τη στιγμή το RSA κυριάρχησε ως η πλέον αποδεκτή
και εύκολα υλοποιήσιμη προσέγγιση για ασύμμετρα κρυπτοσυστήματα. Ο RSA
είναι αλγόριθμος κρυπτογράφησης στον οποίο το αρχικό και το
κρυπτογραφημένο κείμενο είναι ακέραιοι αριθμοί με τιμές μεταξύ 0 και n-1, για
κάποιο n. Η κρυπτογράφηση και η αποκρυπτογράφηση για ένα κείμενο M και
για το αντίστοιχο κρυπτογραφημένο C συμβολίζονται ως ακολούθως:

C = Me mod n
M = C d mod n = (Me)d mod n = M e. d mod n

Τόσο ο αποστολέας όσο και ο παραλήπτης θα πρέπει να γνωρίζουν τις τιμές των n και e.
Αντιθέτως, την τιμή του d πρέπει να γνωρίζει μόνον ο παραλήπτης. Ουσιαστικά ο RSA
είναι ένας αλγόριθμος για ασύμμετρο κρυπτοσύστημα με δημόσιο κλειδί KU={e,n} και
ιδιωτικό κλειδί KR={d,n}. Για να είναι ικανοποιητικός ο αλγόριθμος αυτός θα πρέπει να
ικανοποιούνται οι ακόλουθες απαιτήσεις:

• Είναι δυνατό να βρεθούν τιμές για τα e, d, n, τέτοιες ώστε να ισχύει:

Med = Μ mod n, για κάθε Μ < n.
• Είναι σχετικά εύκολο να υπολογιστούν τα Me και C, για κάθε Μ < n.
• Είναι αδύνατο να προσδιοριστεί το d, δοθέντων των e και n.

44
Οι δύο πρώτες απαιτήσεις ικανοποιούνται εύκολα. Η τρίτη απαίτηση μπορεί να
ικανοποιηθεί μόνο για μεγάλες τιμές των e και n.
Αρχικά επιλέγονται δύο πρώτοι αριθμοί p, q και υπολογίζεται το γινόμενό τους n, το
οποίο είναι βασικός παράγοντας στη διαδικασία κρυπτογράφησης και
αποκρυπτογράφησης. Ακολούθως χρησιμοποιείται η τιμή της συνάρτησης φ(n),
γνωστή ως συνάρτηση του Euler για το n (φ(n) =(p-1)(q-1)), η οποία δείχνει το πλήθος
των θετικών ακεραίων που είναι μικρότεροι από n και πρώτοι με αυτόν. Επιλέγεται
ένας ακέραιος αριθμός e, ο οποίος είναι πρώτος αριθμός ως προς το φ(n), δηλαδή ο
μέγιστος κοινός διαιρέτης του e και του φ(n) να είναι το 1. Τελικά υπολογίζεται ο d, ως
ο φυσικός αντίστροφος αριθμός του e modulo φ(n), από τη σχέση d=e-1 mod φ(n).
Μπορεί να αποδειχθεί ότι το d και το e πληρούν τις απαιτούμενες ιδιότητες.

Υποθέτουμε ότι ο χρήστης Α έχει δημοσιεύσει το δημόσιο κλειδί του και ο χρήστης Β
επιθυμεί να αποστείλει ένα μήνυμα Μ στον Α. Τότε ο Β υπολογίζει την παράσταση
C=Memod n και μεταδίδει το C. Για την αποκρυπτογράφηση του μηνύματος, ο χρήστης
Α υπολογίζει την παράσταση M=Cd mod n.

Υπάρχουν δύο πιθανές προσεγγίσεις με τις οποίες είναι δυνατόν να προκληθεί

επιτυχημένη επίθεση στον RSA αλγόριθμο. Η πρώτη είναι η προσέγγιση της
εξαντλητικής αναζήτησης: δοκιμάζονται όλα τα πιθανά ιδιωτικά κλειδιά. Έτσι, όσο
μεγαλύτερο πλήθος bits χρησιμοποιείται για τα e, d τόσο πιο ασφαλής είναι ο
αλγόριθμος. Παρόλα αυτά, επειδή απαιτούνται πολύπλοκοι υπολογισμοί τόσο κατά τη
δημιουργία των κλειδιών όσο και κατά την κρυπτογράφηση και αποκρυπτογράφηση,
όσο μεγαλύτερο είναι το μέγεθος των κλειδιών τόσο βραδύτερος θα είναι ο ρυθμός
λειτουργίας του συστήματος.

Οι περισσότερες, όμως, συζητήσεις για την κρυπτανάλυση του RSA έχουν επικεντρωθεί
στη διαδικασία ανεύρεσης δύο πρώτων αριθμών που να είναι παράγοντες του n. Για
ένα μεγάλο αριθμό n, η διαδικασία αυτή αποτελεί δύσκολο πρόβλημα αλλά όχι σε τόσο
μεγάλο βαθμό όσο ήταν τα προηγούμενα χρόνια. Για παράδειγμα, τον Ιανουάριο του
1977 οι σχεδιαστές του RSA ζήτησαν από τους αναγνώστες του επιστημονικού
περιοδικού Scientific American να αποκρυπτογραφήσουν ένα κρυπτογραφημένο
μήνυμα που είχαν δημοσιεύσει σε στήλη του περιοδικού. Μάλιστα, προσέφεραν αμοιβή
100 δολαρίων για μία μόνο πρόταση του αποκρυπτογραφημένου κειμένου, γεγονός που
εκτιμούσαν πως δεν είναι δυνατό να συμβεί στα επόμενα 40 τετράκις εκατομμύρια
χρόνια. Όμως τον Απρίλιο του 1994, μία ερευνητική ομάδα που εργαζόταν
αξιοποιώντας την υπολογιστική ισχύ 1600 υπολογιστών στο Internet κέρδισε το
βραβείο μετά από 8 μήνες προσπάθειας. Στην περίπτωση αυτή, χρησιμοποιήθηκε
δημόσιο κλειδί μεγέθους 129 δεκαδικών ψηφίων (μήκος του n), δηλαδή περίπου 428
bits. Επιπλέον, το 1996 αναλύθηκε σε γινόμενο πρώτων παραγόντων ένας αριθμός 130
ψηφίων με 10 φορές λιγότερες πράξεις από όσες είχαν απαιτηθεί κατά την ανάλυση του
αριθμού με 129 ψηφία. Τα αποτελέσματα αυτά, βεβαίως, με κανένα τρόπο δε μειώνουν
τις δυνατότητες του RSA. Απλώς σημαίνουν ότι πρέπει να χρησιμοποιούνται
μεγαλύτερα μεγέθη κλειδιών. Ένα κλειδί μεγέθους 2048 bits θεωρείται ισχυρό για όλες
τις σημερινές τυπικές εφαρμογές[5,8,9,15,17,18].

2.3.5.2 Ανταλλαγή κλειδιών κατά Diffie-Hellman

Ο πρώτος αλγόριθμος για ασύμμετρο κρυπτοσύστημα δημοσιεύτηκε στην εργασία των

Diffie - Hellman που όριζε την κρυπτογραφία με ασύμμετρο κρυπτοσύστημα και είναι
γνωστός ως ανταλλαγή κλειδιών κατά Diffie-Hellman (Diffie-Hellman key exchange).

45
Σκοπός του αλγορίθμου είναι να καταστήσει εφικτή και ασφαλή μεταξύ δύο χρηστών
την ανταλλαγή ενός μυστικού κλειδιού, το οποίο ακολούθως θα χρησιμοποιηθεί για
κρυπτογράφηση μηνυμάτων. Ο αλγόριθμος περιορίζεται ακριβώς στην ανταλλαγή των
κλειδιών.

Η αποτελεσματικότητά του αλγορίθμου Diffie-Hellman βασίζεται στη δυσκολία

υπολογισμού διακριτών λογαρίθμων. Συνοπτικά, ο διακριτός λογάριθμος ορίζεται ως
εξής: Αρχικά προσδιορίζεται μία πρωτογενής ρίζα ενός πρώτου αριθμού p τέτοιου, ώστε
οι δυνάμεις του να παράγουν όλους τους ακέραιους από το 0 ως το p-1. Έτσι, αν a είναι
μία ρίζα του πρώτου αριθμού p, τότε οι αριθμοί a mod p, a2 mod p, …, a p-1 mod p
αποτελούν τους ακεραίους από το 1 έως το p-1 με κάποια μετάθεση.

Για οποιοδήποτε ακέραιο b και για μία πρωτογενή ρίζα a ενός πρώτου αριθμού p,
μπορεί να βρεθεί ένας μοναδικός πρώτος αριθμός i, τέτοιος, ώστε
b=a i mod p όπου 0≤ i ≤ (p-1)

Ο εκθέτης i αναφέρεται ως ο διακριτός λογάριθμος ή δείκτης (index) του b για βάση a,

mod p και συμβολίζεται i= ind a,p(b). Με βάση τα παραπάνω μπορεί να οριστεί η
ανταλλαγή κλειδιών κατά Diffie-Hellman. Για αυτήν την τεχνική απαιτείται να
υπάρχουν δύο δημοσίως γνωστοί αριθμοί. Ένας πρώτος αριθμός q και ένας ακέραιος a
που είναι η πρωτογενής ρίζα του q.

Έστω ότι οι Α και Β επιθυμούν να ανταλλάξουν ένα κλειδί. Ο Α επιλέγει ένα τυχαίο
ακέραιο XA με XA<q και υπολογίζει το YA =aXA mod q. Ομοίως, ο Β επιλέγει ανεξάρτητα
από τον Α έναν τυχαίο ακέραιο XB με XB <q και υπολογίζει το YB = aXB mod q. Κάθε
πλευρά κρατά μυστική την αντίστοιχη τιμή του Χ, δηλαδή τα XA, XB και θέτει την
αντίστοιχη ποσότητα Υ δημοσίως διαθέσιμη στην άλλη πλευρά. Ο Α υπολογίζει το κλειδί
σύμφωνα με τη σχέση K=(YB)XA mod q, όπως επίσης και ο Β σύμφωνα με τη σχέση
K=(YA)XB mod q.

Με τη διαδικασία αυτή, οι δύο πλευρές επιτυγχάνουν την ανταλλαγή ενός μυστικού

κλειδιού. Εφόσον τα XA και XB είναι μυστικά, ένας επιτιθέμενος έχει μόνον τα ακόλουθα
στοιχεία για να αποπειραθεί να κρυπταναλύσει τον αλγόριθμο: q, a, YA, YB. Έτσι είναι
αναγκασμένος να υπολογίσει ένα διακριτό λογάριθμο, για να κατορθώσει να υπολογίσει
το κλειδί. Για παράδειγμα, αν επιτεθεί στην πλευρά του Β θα πρέπει να υπολογίσει την
ποσότητα XB = ind a,q (YB). Ο επιτιθέμενος στη συνέχεια, θα μπορεί να υπολογίσει το
κλειδί Κ με τον ίδιο τρόπο που το υπολογίζει και ο Β.

Η ασφάλεια της ανταλλαγής κλειδιού κατά Diffie-Hellman έγκειται στο γεγονός ότι ενώ
είναι υπολογιστικά εύκολο να υπολογιστεί η ποσότητα δύναμη mod πρώτου αριθμού,
είναι πολύ δύσκολο να υπολογιστούν οι διακριτοί λογάριθμοι. Και για μεγάλους
πρώτους αριθμούς το πρόβλημα θεωρείται ανέφικτο να επιλυθεί [5,8,9,15,17,18].

2.3.5.3 Κρυπτογραφία Ελλειπτικής καμπύλης (ECC)

Τα περισσότερα προϊόντα και πρότυπα, που χρησιμοποιούν ασύμμετρα

κρυπτοσυστήματα για κρυπτογράφηση και ψηφιακή υπογραφή, χρησιμοποιούν τον
αλγόριθμο RSA. Το πλήθος των bits που χρησιμοποιείται για ασφαλή χρήση του RSA
έχει αυξηθεί σημαντικά τα τελευταία χρόνια και το γεγονός αυτό έχει επιβαρύνει τις
αντίστοιχες εφαρμογές με σημαντικό επεξεργαστικό φόρτο. Το πρόβλημα εντείνεται σε

46
περιβάλλον ιστοσελίδων εφαρμογών ηλεκτρονικού εμπορίου, όπου πραγματοποιούνται
πολλές ασφαλείς δοσοληψίες. Τα τελευταία χρόνια έχει αρχίσει να αναπτύσσεται ένα
ανταγωνιστικό σύστημα του RSA. Πρόκειται για την Κρυπτογραφία Ελλειπτικής
Καμπύλης (Elliptic Curve Cryptography - ECC). Ήδη, το ECC κινείται στα πλαίσια
προτυποποίησής του, αφού το έχει συμπεριλάβει το πρότυπο για ασύμμετρα
κρυπτοσυστήματα IEEE P1363.

Ο κύριος λόγος που καθιστά ελκυστικό το ECC συγκρινόμενο με τον αλγόριθμο RSA,
είναι ότι προσφέρει το ίδιο επίπεδο ασφάλειας για μικρότερο πλήθος bits, μειώνοντας
κατ’ αυτόν τον τρόπο τον απαιτούμενο υπολογιστικό χρόνο και φόρτο εργασίας.
Σύμφωνα με σχετικά πρόσφατες επιστημονικές ανακοινώσεις, έγινε κατορθωτό να
κρυπταναλυθεί το ECC με μέγεθος κλειδιού 109 bits αξιοποιώντας αδιάκοπα την
επεξεργαστική ισχύ 10.000 υπολογιστών επί 549 ημέρες. Στην παρούσα φάση ο
αλγόριθμος θεωρείται ασφαλής αν το μέγεθος του κλειδιού διατηρεί μήκος τουλάχιστον
163 bits. Από την άλλη πλευρά, αν και η θεωρία του ECC ήταν γνωστή για αρκετό καιρό,
μόλις πρόσφατα έχουν ξεκινήσει να εμφανίζονται προϊόντα που χρησιμοποιούν ECC. Το
γεγονός αυτό δικαιολογεί το χαμηλό επίπεδο εμπιστοσύνης προς το ECC, σχετικά με το
RSA.

Το ECC σε θεωρητική βάση είναι πιο δύσκολο να εξηγηθεί, συγκριτικά με τους

αλγορίθμους RSA και Diffie-Hellman. Η αξιοποιηθείσα τεχνική βασίζεται στη χρήση ενός
μαθηματικού μοντέλου, γνωστού ως ελλειπτική καμπύλη [5,8,9,15,17,18].

2.3.5.4 Εφαρμογές Κρυπτογραφίας δημοσίου κλειδιού

Όπως προαναφέρθηκε, τα συστήματα δημοσίου κλειδιού χαρακτηρίζονται από τη

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

Υπάρχουν τρεις περιπτώσεις στις οποίες χρησιμοποιείται το ζεύγος κλειδιών σε αυτά

τα συστήματα:

• Κρυπτογράφηση/Αποκρυπτογράφηση (Encryption/Decryption): Ο αποστολέας

κρυπτογραφεί ένα μήνυμα με το δημόσιο κλειδί του παραλήπτη και ο
παραλήπτης αποκρυπτογραφεί με το ιδιωτικό κλειδί του.
• Ψηφιακή υπογραφή (Digital Signature): Ο αποστολέας χρησιμοποιεί το ιδιωτικό
του κλειδί για να υπογράψει ένα μήνυμα. Όπως θα αναλυθεί σε επόμενη
παράγραφο, η υπογραφή δημιουργείται με την εφαρμογή ενός αλγορίθμου
κρυπτογράφησης στο μήνυμα ή συνηθέστερα στη σύνοψη (hash) του μηνύματος.
Ο παραλήπτης αυθεντικοποιεί τον αποστολέα με χρήση του δημόσιου κλειδιού
του.
• Ανταλλαγή κλειδιών (Key Exchange): Δύο οντότητες συνεργάζονται ώστε να
ανταλλάξουν ένα κλειδί συνόδου (session key). Για την υλοποίηση της
ανταλλαγής κλειδιών είναι πιθανόν να λάβουν χώρα διάφορες ενέργειες, που
αξιοποιούν το ιδιωτικό κλειδί της μιας ή και των δύο οντοτήτων που
συμμετέχουν.

47
 Αλγόριθμος Κρυπτογράφηση/ Ψηφιακή Ανταλλαγή
Αποκρυπτογράφηση Υπογραφή κλειδιών
RSA x x x
Diffie-Hellman - - x
ECC x x x

Πίνακας 2. 2 Αλγόριθμοι δημοσίου κλειδιού και υποστηριζόμενες εφαρμογές.

Κάποιοι αλγόριθμοι είναι κατάλληλοι και για τις τρεις εφαρμογές, άλλοι μόνο για δύο ή
μία από αυτές. Στον Πίνακα 2. 2 αναφέρονται οι εφαρμογές που υποστηρίζονται από
τους αλγορίθμους που επεξηγήσαμε.

2.3.5.4.1 Ψηφιακές Υπογραφές

Η ψηφιακή υπογραφή είναι ένας εύκολος, αποδοτικός και ασφαλής τρόπος υπογραφής
ηλεκτρονικών εγγράφων. Είναι το ηλεκτρονικό ισοδύναμο της γραπτής υπογραφής. Επί
της ουσίας είναι ψηφιακά δεδομένα τα οποία βρίσκονται συνημμένα σε άλλα
ηλεκτρονικά δεδομένα ή συσχετίζονται λογικά με αυτά και αποδεικνύουν την
γνησιότητά τους.

Οι ψηφιακές υπογραφές χρησιμοποιούν την κρυπτογραφία δημοσίου κλειδιού. Ο

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

Στη διαδικασία της δημιουργίας και επαλήθευσης της υπογραφής εμπλέκεται και η
έννοια της συνάρτησης κατακερματισμού (hash function). Με την εφαρμογή της
συνάρτησης κατακερματισμού, από ένα μήνυμα ανεξαρτήτου του μεγέθους του,
παράγεται η “σύνοψή του”, η οποία είναι μία σειρά από bits συγκεκριμένου μεγέθους
(π.χ. 128 ή 160 bits). Η σύνοψη του μηνύματος (fingerprint ή message digest) είναι μία
ψηφιακή αναπαράσταση του μηνύματος, είναι μοναδική για το μήνυμα και το
αντιπροσωπεύει.

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

Η ηλεκτρονική υπογραφή, στην ουσία είναι η κρυπτογραφημένη με το ιδιωτικό κλειδί

του αποστολέα σύνοψη. Δηλαδή, η ψηφιακή υπογραφή (σε αντίθεση με την ιδιόχειρη
υπογραφή) είναι διαφορετική για κάθε μήνυμα.

48
Θεωρώντας ότι ο αποστολέας έχει ένα συγκεκριμένο ζευγάρι κλειδιών και το ιδιωτικό
του κλειδί είναι στην πλήρη κατοχή του, τότε το γεγονός ότι ο αποστολέας χρησιμοποιεί
το ιδιωτικό του κλειδί για να κρυπτογραφήσει το μήνυμα, πιστοποιεί στον παραλήπτη
που το αποκρυπτογραφεί με το αντίστοιχο δημόσιο κλειδί (του αποστολέα) την
ταυτότητα του αποστολέα (αυθεντικότητα). Η ψηφιακή υπογραφή είναι ένας τρόπος
πιστοποίησης της ταυτότητας του αποστολέα ενός μηνύματος [7,8,13,15,16,22].

Για τη δημιουργία μιας ηλεκτρονικής υπογραφής ο αποστολέας του μηνύματος

προβαίνει στις εξής ενέργειες (Εικόνα 2. 15):

• Ο αποστολέας χρησιμοποιώντας κάποιον αλγόριθμο κατακερματισμού (one

way hash) δημιουργεί τη σύνοψη του μηνύματος που θέλει να στείλει.
Ανεξάρτητα από το μέγεθος του μηνύματος, αυτό που θα παραχθεί θα είναι μία
συγκεκριμένου μήκους σειρά ψηφίων.
• Χρησιμοποιεί το ιδιωτικό του κλειδί προκειμένου να κρυπτογραφήσει το
αποτέλεσμα που προέκυψε από την εφαρμογή της συνάρτησης
κατακερματισμού και με τον τρόπο αυτό δημιουργεί την ψηφιακή υπογραφή
του μηνύματος.
• Το αρχικό μήνυμα κρυπτογραφείται (εφόσον αυτό απαιτείται) με το δημόσιο
κλειδί του παραλήπτη και μαζί με την ψηφιακή υπογραφή (η οποία
προσαρτάται στο συγκεκριμένο μήνυμα) αποστέλλεται στον επιθυμητό
παραλήπτη.

Εικόνα 2. 15 Διαδικασία δημιουργίας ψηφιακής υπογραφής.

49
 Εικόνα 2. 16 Διαδικασία επαλήθευσης ψηφιακής υπογραφής.

Ο παραλήπτης προκειμένου να επιβεβαιώσει την ακεραιότητα του μηνύματος και την

ταυτότητα του αποστολέα (Εικόνα 2. 16):

• Χρησιμοποιεί το δημόσιο κλειδί του αποστολέα για να αποκρυπτογραφήσει την

ψηφιακή υπογραφή που βρίσκεται προσαρτημένη στα ηλεκτρονικά δεδομένα
του μηνύματος. Έτσι αποκαλύπτει την τιμή της σύνοψης.
• Εάν το μήνυμα είχε κρυπτογραφηθεί τότε χρησιμοποιεί το ιδιωτικό του κλειδί
προκειμένου να το αποκρυπτογραφήσει.
• Εφαρμόζοντας στο μήνυμα που έλαβε τον ίδιο αλγόριθμο κατακερματισμού,
δημιουργεί τη σύνοψη του μηνύματος. Συγκρίνονται οι τιμές από τις δύο
συνόψεις και αν βρεθούν ίσες, αυτό σημαίνει ότι το μήνυμα που έλαβε ο
παραλήπτης είναι ακέραιο. Αν το μήνυμα έχει μεταβληθεί, η σύνοψη που θα
παράγει ο παραλήπτης θα είναι διαφορετική από τη σύνοψη που
περιλαμβάνεται στην ψηφιακή υπογραφή του μηνύματος.

2.3.5.4.2 Ψηφιακά Πιστοποιητικά

Για την αποτελεσματική λειτουργία του ασύμμετρου κρυπτοσυστήματος, το δημόσιο

κλειδί πρέπει να μπορεί να είναι γνωστό σε όσους δυνητικά ενδιαφέρονται. Έτσι,
υποθέτοντας ότι υπάρχει ένας ευρέως αποδεκτός αλγόριθμος κρυπτογράφησης και
αποκρυπτογράφησης όπως ο RSA, οποιοσδήποτε μπορεί να αποστείλει το δημόσιο
κλειδί του σε κάποιον άλλο ή να το μεταδώσει προς όλους. Η μέθοδος αυτή είναι αρκετά
χρήσιμη, αλλά έχει μία σημαντική αδυναμία: την αδυναμία διασφάλισης της

50
ακεραιότητας και της αυθεντικοποίησης του αποστολέα κατά την αποστολή του
μηνύματος που περιέχει το δημόσιο κλειδί. Οποιοσδήποτε μπορεί να πραγματοποιήσει
μία τέτοια μετάδοση. Με τον τρόπο αυτό, κάποιος Χ μπορεί να προσποιηθεί ότι είναι ο Α
και να στείλει ένα δημόσιο κλειδί σε τρίτον ή να το μεταδώσει προς περισσότερες
οντότητες. Μέχρι τη στιγμή που ο Α θα αντιληφθεί ότι βρίσκεται σε εξέλιξη μία απάτη, ο
Χ θα έχει διαβάσει όλα τα κρυπτογραφημένα μηνύματα που προορίζονταν για τον Α,
ενώ έχει τη δυνατότητα να υπογράφει και να αυθεντικοποιείται ως Α.

Λύση σε αυτό το πρόβλημα αποτελεί η χρήση του ψηφιακού πιστοποιητικού (digital

certificate) ή απλώς πιστοποιητικού (certificate) δημοσίου κλειδιού. Συγκεκριμένα, ένα
πιστοποιητικό περιλαμβάνει το δημόσιο κλειδί του χρήστη και έναν κωδικό (userID)
του κατόχου του κλειδιού, υπογεγραμμένα ψηφιακά από μία Έμπιστη Τρίτη Οντότητα
(Trusted Third Party - TTP), η οποία συνήθως αποκαλείται Πάροχος Υπηρεσιών
Πιστοποίησης (Certification Service Provider - CSP). Ο χρήστης παρουσιάζει το δημόσιο
κλειδί του στον CSP με έναν αξιόπιστο τρόπο και λαμβάνει ένα πιστοποιητικό που το
περιέχει ή, στη γενική περίπτωση, ο CSP παράγει, αποθηκεύει, διανέμει και ανακαλεί,
όταν απαιτείται, τα πιστοποιητικά. Οποιοσδήποτε επιθυμεί να χρησιμοποιήσει το
δημόσιο κλειδί του χρήστη μπορεί να λάβει το πιστοποιητικό και να είναι σίγουρος για
την ορθότητα του δημόσιου κλειδιού.

Το πιο διαδεδομένο σύστημα πιστοποιητικού είναι το πρότυπο ISO/ITU-T Χ.509, το

οποίο χρησιμοποιείται σε πολλές περιπτώσεις, όπως στην ασφάλεια IP, στο TLS/SSL,
στο SET, στο S/MIME κλπ. [7,8,13,15,16,22].

2.3.5.4.3 Διανομή μυστικών κλειδιών με Ασύμμετρο Κρυπτοσύστημα

Όπως αναφέρθηκε σε προηγούμενες παραγράφους, σε ένα συμμετρικό κρυπτοσύστημα

προκειμένου να επικοινωνήσουν δύο χρήστες πρέπει να διαμοιράζονται τη γνώση ενός
μυστικού κλειδιού. Για παράδειγμα, έστω ότι ο Β θέλει να δημιουργήσει μία εφαρμογή
που θα του παρέχει τη δυνατότητα να ανταλλάσσει μηνύματα με χρήση υπηρεσίας
ηλεκτρονικού ταχυδρομείου με τον Α, χρησιμοποιώντας συμμετρικό κρυπτοσύστημα.
Θα πρέπει να βρεθεί ένας τρόπος να αποστείλει ο Β στον Α το μυστικό κλειδί.

Ένας πολύ διαδεδομένος τρόπος είναι η αξιοποίηση ψηφιακού φακέλου (digital

envelope), δηλαδή να χρησιμοποιήσει ο Β ασύμμετρο κρυπτοσύστημα για την
αποστολή του μυστικού κλειδιού. Προφανώς απαιτείται η χρήση πιστοποιητικών και η
λειτουργία Υποδομής Δημόσιων Κλειδιών, ώστε να εξασφαλίζεται η αυθεντικότητα του
αποστολέα Α και η ακεραιότητα του μηνύματος. Τα γενικά βήματα που θα πρέπει να
ακολουθηθούν σε μία τέτοια περίπτωση είναι τα ακόλουθα:

• Ο Β ετοιμάζει το προς αποστολή μήνυμα.

• Ο Β κρυπτογραφεί το μήνυμα με συμβατικό κρυπτοσύστημα, χρησιμοποιώντας ένα
μυστικό κλειδί που ο ίδιος δημιούργησε.
• Ο Β κρυπτογραφεί το μυστικό κλειδί με το δημόσιο κλειδί του Α.
• Ο Β επισυνάπτει το κρυπτογραφημένο κλειδί στο μήνυμα και το αποστέλλει στον
Α.

Ο Α είναι ο μόνος που μπορεί να αποκρυπτογραφήσει το μήνυμα και να αναγνώσει το

αρχικό κείμενο. Αν ο Β έχει ανακτήσει το δημόσιο κλειδί του Α μέσω πιστοποιητικού
από κάποια Έμπιστη Τρίτη Οντότητα, τότε ο Β είναι σίγουρος ότι το μυστικό κλειδί
είναι ορθό [7,8,13,15,16,22].

51
2.3.6 Σύγκριση Συμμετρικών - Ασύμμετρων Κρυπτοσυστημάτων

Το μεγαλύτερο πρόβλημα της συμμετρικής κρυπτογραφίας είναι η συνεννόηση και

ανταλλαγή του κλειδιού, χωρίς κάποιος τρίτος να μπορέσει να το υποκλέψει. Η
μετάδοση μέσα από το Διαδίκτυο δεν είναι ασφαλής γιατί οποιοσδήποτε γνωρίζει για
την συναλλαγή και έχει τα κατάλληλα μέσα μπορεί να καταγράψει όλη την επικοινωνία
μεταξύ αποστολέα και παραλήπτη και να αποκτήσει το κλειδί. Έπειτα, μπορεί να
διαβάσει, να τροποποιήσει και να πλαστογραφήσει όλα τα μηνύματα που
ανταλλάσσουν οι δύο ανυποψίαστοι χρήστες. Βέβαια, μπορούν να βασισθούν σε άλλο
μέσο επικοινωνίας για την μετάδοση του κλειδιού (π.χ. τηλεφωνία), αλλά ακόμα και
έτσι δεν μπορεί να εξασφαλιστεί ότι κανείς δεν παρεμβάλλεται μεταξύ της γραμμής
επικοινωνίας των χρηστών. Η ασύμμετρη κρυπτογραφία δίνει λύση σε αυτό το
πρόβλημα αφού σε καμία περίπτωση δεν βρίσκονται εκτεθειμένες στο δίκτυο οι εν
λόγω ευαίσθητες πληροφορίες.

Άλλο ένα πλεονέκτημα των ασύμμετρων κρυπτοσυστημάτων είναι ότι μπορούν να

παρέχουν ψηφιακές υπογραφές που δεν μπορούν να αποκηρυχθούν από την πηγή τους.
Η πιστοποίηση της ταυτότητας μέσω συμμετρικής κρυπτογράφησης απαιτεί την κοινή
χρήση του ίδιου κλειδιού ενώ πολλές φορές τα κλειδιά αποθηκεύονται σε υπολογιστές
που κινδυνεύουν από εξωτερικές επιθέσεις. Σαν αποτέλεσμα, ο αποστολέας μπορεί να
αποκηρύξει ένα πρωτύτερα υπογεγραμμένο μήνυμα, υποστηρίζοντας ότι το μυστικό
κλειδί είχε κατά κάποιον τρόπο αποκαλυφθεί. Στην ασύμμετρη κρυπτογραφία δεν
επιτρέπεται κάτι τέτοιο αφού κάθε χρήστης έχει αποκλειστική γνώση του ιδιωτικού
του κλειδιού και είναι δικιά του ευθύνη η φύλαξη του.

Μειονέκτημα της ασύμμετρης κρυπτογραφίας είναι η ταχύτητα. Κατά κανόνα, οι

διαδικασίες κρυπτογράφησης και πιστοποίησης ταυτότητας με συμμετρικό κλειδί είναι
σημαντικά ταχύτερες από την κρυπτογράφηση και ψηφιακή υπογραφή με ζεύγος
ασύμμετρων κλειδιών. Επίσης, τεράστιο μειονέκτημα της ασύμμετρης κρυπτογραφίας
είναι η ανάγκη για πιστοποίηση και επαλήθευση των δημόσιων κλείδων από
οργανισμούς (Certificate Authority) ώστε να διασφαλίζεται η κατοχή τους από
νόμιμους χρήστες. Όταν κάποιος κακόβουλος κατορθώσει και ξεγελάσει τον οργανισμό,
μπορεί να συνδέσει το όνομα του με το δημόσιο κλειδί ενός νόμιμου χρήστη και να
προσποιείται την ταυτότητα αυτού του νόμιμου χρήστη.

Σε μερικές περιπτώσεις, η ασύμμετρη κρυπτογραφία δεν είναι απαραίτητη και η

συμμετρική κρυπτογραφία από μόνη της είναι αρκετή. Τέτοιες περιπτώσεις είναι
περιβάλλοντα κλειστά, που δεν έχουν σύνδεση με το Διαδίκτυο. Ένας υπολογιστής
μπορεί να κρατά τα μυστικά κλειδιά των χρηστών που επιθυμούν να εξυπηρετηθούν
από αυτόν, μια και δεν υπάρχει ο φόβος για κατάληψη της μηχανής από εξωτερικούς
παράγοντες. Επίσης, στις περιπτώσεις που οι χρήστες μπορούν να συναντηθούν και να
ανταλλάξουν τα κλειδιά ή όταν η κρυπτογράφηση χρησιμοποιείται για τοπική
αποθήκευση κάποιων αρχείων, η ασύμμετρη κρυπτογραφία δεν είναι απαραίτητη. Τα
δύο κρυπτοσυστήματα μπορούν να εφαρμοστούν μαζί, συνδυάζοντας τα καλά τους
χαρακτηριστικά και εξαλείφοντας τα μειονεκτήματα τους.

Γενικά η ανθεκτικότητα της κρυπτογράφησης εξαρτάται περισσότερο από το μέγεθος

των κλειδιών παρά από τους αλγορίθμους κρυπτογράφησης. Το μέγεθος των κλειδιών
όπως αναφέραμε και παραπάνω μετριέται σε bits. Κλειδιά μεγάλου μήκους παρέχουν
ανθεκτικότερη κρυπτογράφηση. Για παράδειγμα, η κρυπτογράφηση 128 bit RC4 είναι
3078 φορές ανθεκτικότερη από την 40 bit RC4. Διαφορετικοί αλγόριθμοι απαιτούν

52
διαφορετικά μήκη κλειδιών για να πετύχουν το ίδιο επίπεδο ανθεκτικότητας. Για
παράδειγμα, ένας αλγόριθμος συμμετρικής κρυπτογράφησης με κλειδί μεγέθους 128
bits παρέχει ανθεκτικότερη κρυπτογράφηση από τον αλγόριθμο RSA με το ίδιο μέγεθος
κλειδιού. Για το λόγο αυτό πρέπει να χρησιμοποιούμε κλειδί μεγέθους τουλάχιστον 512
bits προκειμένου η κρυπτογράφηση RSA να είναι ανθεκτική, ενώ οι συμμετρικοί
αλγόριθμοι πετυχαίνουν το ίδιο επίπεδο ανθεκτικότητας με κλειδί 56 bits. Όμως ακόμη
και αυτά τα επίπεδα ανθεκτικότητας αρχίζουν να αποδεικνύονται ευπαθή σε επιθέσεις
[23,24].

Συνοπτικά μπορούμε να πούμε πως τα σύγχρονα συμμετρικά κρυπτοσυστήματα

χρησιμοποιούνται γιατί παρέχουν:

• Ασφάλεια
• Γρήγορη λειτουργία
• Εύκολη υλοποίηση σε λογισμικό
• Αποδοτική υλοποίηση σε υλικό

Όμως μειονεκτούν:

• Δύσκολη ανταλλαγή κλειδιού χωρίς τη γνωστοποίηση του.

• Κλιμάκωση.

Αντίθετα τα ασύμμετρα πλεονεκτούν:

• Υψηλή ασφάλεια
• Ψηφιακές υπογραφές

Πρακτικά, η ασύμμετρη κρυπτογραφία χρησιμοποιείται για τη φύλαξη και διανομή

κλειδιών συνόδου (session keys). Τα κλειδιά συνόδου χρησιμοποιούνται με τη σειρά
τους για να κρυπτογραφήσουν τα μηνύματα. Αυτό μερικές φορές καλείται υβριδικό
κρυπτοσύστημα (hybrid cryptosystem).

Σε ένα υβριδικό κρυπτοσύστημα ο χρήστης Α στέλνει στο χρήστη Β το δημόσιο κλειδί

του (ΚΡ). Στη συνέχεια ο χρήστης Β δημιουργεί ένα τυχαίο κλειδί συνόδου, K, το
κρυπτογραφεί χρησιμοποιώντας το δημόσιο κλειδί του χρήστη Α, και το στέλνει σ’
αυτόν (ΕΚΡ[Κ]). Ο χρήστης Α αποκρυπτογραφεί το μήνυμα του Β, χρησιμοποιώντας το
ιδιωτικό του κλειδί, και αποκτά το κλειδί συνόδου (DKR[EKP[K]]=K). Με αυτόν τον τρόπο
και οι δύο κρυπτογραφούν τα μηνύματά τους χρησιμοποιώντας το ίδιο κλειδί συνόδου.
Έτσι το υβριδικό κρυπτοσύστημα εκμεταλλεύεται τα πλεονεκτήματα των δύο
κρυπτοσυστημάτων παρέχοντας υψηλή ασφάλεια και ταχύτητα.

53
54
 3.Το πρότυπο AES

3.1 Ιστορική αναδρομή

Πρόγονος του κρυπτογραφικού αλγόριθμου AES (Advanced Encryption Standard)

θεωρείται ο DES (Data Encryption Standard), που αναπτύχθηκε από την IBM στις
αρχές της δεκαετίας του 1970 και υιοθετήθηκε τον Ιανουάριο του 1977 από την
κυβέρνηση των ΗΠΑ ως πρότυπο κρυπτογράφησης των μη διαβαθμισμένων
πληροφοριών. Ο DES ήταν ένα τυπικό δίκτυο Feistel, με κλειδί μήκους 56 bits. Την
εποχή της υιοθέτησης του, o DES παρείχε ένα ικανοποιητικό επίπεδο ασφαλείας. Στις
αρχές της δεκαετίας του 1990, ωστόσο, η ραγδαία αύξηση της υπολογιστικής ισχύος, σε
συνδυασμό με την μείωση του κόστους των υπολογιστικών συστημάτων, κατέστησε
τον DES ευάλωτο σε κρυπταναλυτικές επιθέσεις. Ως προσωρινό μέτρο δημιουργήθηκε
μία ασφαλέστερη παραλλαγή του DES, ο Triple-DES, ο οποίος εξακολουθούσε να είναι
ευάλωτος, παρ’ ότι ασφαλέστερος του DES. Υπό τις συνθήκες αυτές, εκρίθη απαραίτητη
η υιοθέτηση ενός νέου κρυπτογραφικού προτύπου.

Τον Ιανουάριο του 1997, το “Εθνικό Ινστιτούτο Προτύπων & Τεχνολογίας” των ΗΠΑ
(National Institute of Standards and Technology, NIST) προκήρυξε διεθνή διαγωνισμό
για την υιοθέτηση του νέου κρυπτογραφικού προτύπου εμπορικής (μη κυβερνητικής)
χρήσεως, του AES. Το αξιοσημείωτο είναι ότι για πρώτη φορά στα χρονικά της
σύγχρονης κρυπτογραφίας οι διαδικασίες αξιολόγησης και επιλογής των υποψηφίων
προτάσεων θα ήταν ανοικτές.

Τον Σεπτέμβριο του 1997 δημοσιοποιήθηκαν η τελική προκήρυξη, καθώς και οι

προδιαγραφές που έπρεπε να πληροί ο AES. Οι βασικότερες εξ αυτών ήταν:

1. Ο αλγόριθμος έπρεπε να είναι συμμετρικός, τμήματος (block cipher).

2. Η πλήρης σχεδίαση θα έπρεπε να δημοσιοποιηθεί.
3. Ο αλγόριθμος έπρεπε να υποστηρίζει μήκη κλειδιών 128, 192 και 256 bits.
4. Έπρεπε να είναι εφικτή – και σχετικώς απλή – η υλοποίηση του
αλγορίθμου τόσο σε λογισμικό, όσο και σε υλικό.
5. Η χρήση του αλγορίθμου θα ήταν ελεύθερη, χωρίς να απαιτείται κάποια
συγκεκριμένη άδεια χρήσεως.

Κατατέθηκαν 15 συνολικά προτάσεις οι οποίες υποβλήθηκαν σε δύο γύρους

αξιολογήσεων. Ο πρώτος γύρος ξεκίνησε με το Α΄ συνέδριο για το πρότυπο AES
(Αύγουστος 1998) και κατέληξε στην απόρριψη των 5 εκ των 15 υποψηφίων
προτάσεων. Τον Μάρτιο του 1999 ξεκίνησε ο δεύτερος γύρος με το Β΄ συνέδριο για το
πρότυπο AES για να καταλήξουμε στην απόρριψη άλλων 5 προτάσεων, τον Αύγουστο
του 1999. Τελικώς από τις 5 εναπομείνασες προτάσεις ως πρότυπο AES επελέγη ο
αλγόριθμος Rijndael, που αναπτύχθηκε από τους Βέλγους ερευνητές Joan Daemen και
Vincent Rijmen. Η επίσημη ανακοίνωση της επιλογής του Rijndael έγινε στις 2
Οκτωβρίου 2000. Αναλυτικά οι 15 προτάσεις για το πρότυπο AES παρουσιάζονται στον
Πίνακα 3. 1 (με έντονα γράμματα οι 5 επικρατέστερες, που προέκυψαν μετά το δεύτερο
γύρο):

55
Αλγόριθμος Δημιουργός Χώρα
CAST-256 Entrust Καναδάς
Crypton Future Systems Ν. Κορέα
DEAL Outerbridge, Knudsen * ΗΠΑ, Δανία
DFC ENS-CNRS * Γαλλία
E2 NTT Ιαπωνία
Frog TecApro Κροατία
HPC Schroeppel * ΗΠΑ
LOKI97 Brown et al. * Αυστραλία
Magenta Deutsche Telekom Γερμανία
MARS IBM ΗΠΑ
RC6 RSA Laboratories ΗΠΑ
Rijndael Daemen, Rijmen * Βέλγιο
SAFER+ Cylink ΗΠΑ
Serpent Anderson, Biham, Knudsen * Αγγλία, Ισραήλ, Δανία
Twofish Counterpane ΗΠΑ
* Οι συγκεκριμένοι συμμετάσχοντες στον διαγωνισμό δεν ήταν εταιρείες, αλλά
ανεξάρτητοι ερευνητές.
Πίνακας 3. 1 Υποψήφιοι για το πρότυπο AES.

3.2 Κριτήρια αξιολόγησης υποψήφιων αλγορίθμων

Τα κριτήρια αξιολόγησης των υποψήφιων αλγορίθμων διαμορφώθηκαν και

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

Η ασφάλεια των αλγορίθμων αποτέλεσε τον πιο σημαντικό παράγοντα αξιολόγησης. Τα

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

Η δεύτερη ομάδα κριτηρίων, αυτή του κόστους, αναφέρεται στις απαιτήσεις

υπολογιστικής ισχύος και μνήμης του αλγορίθμου (πολυπλοκότητα), καθώς και σε
απαιτήσεις πνευματικών δικαιωμάτων. Οι απαιτήσεις σε υπολογιστική ισχύ (ταχύτητα)
και σε μνήμη των αλγορίθμων εξετάστηκαν σε διάφορες αρχιτεκτονικές υπολογιστικών
συστημάτων, όπως επεξεργαστές 8, 32 και 64 bits. Η ταχύτητα των αλγορίθμων
εξετάστηκε για κρυπτογραφικά κλειδιά μήκους 128, 192 και 256 bits. Επίσης, το NIST
επεδίωξε το υπό ανάπτυξη πρότυπο να είναι αξιοποιήσιμο ευρέως και παγκόσμια,
προσέχοντας για αυτό το λόγο να μην υπάρχουν οποιαδήποτε προβλήματα σχετικά με
πνευματικά δικαιώματα.

Στην τρίτη ομάδα κριτηρίων συγκαταλέγονται η ευελιξία και η απλότητα του

αλγορίθμου, καθώς και η καταλληλότητα υλοποίησης σε λογισμικό και σε υλικό. Πιο
συγκεκριμένα, με τον όρο ευελιξία εννοούμε την ικανότητα του αλγορίθμου να
χειρίζεται μεγέθη κρυπτογραφικών κλειδιών και τμημάτων του αρχικού κειμένου, τα
οποία είναι μεγαλύτερα από τα ελάχιστα που πρέπει να υποστηρίζει. Επίσης, να μπορεί

56
να υλοποιηθεί με ασφαλή και αποτελεσματικό τρόπο σε διάφορα περιβάλλοντα, καθώς
και να μπορεί να υλοποιηθεί ως κωδικοποιητής ροής (stream cipher), ως αλγόριθμος
κατακερματισμού (hashing algorithm) και να προσφέρει και επιπρόσθετες
κρυπτογραφικές λειτουργίες. Ακόμα, να είναι εφικτή η υλοποίηση του αλγορίθμου και
σε υλικό και σε λογισμικό, καθώς και σε firmware. Και η απλότητα του αλγορίθμου
αποτέλεσε έναν παράγοντα αξιολόγησης [26].

3.3 AES - Γενικά

Ο AES είναι ένας επαναληπτικός κρυπταλγόριθμος τμήματος. Το απλό κείμενο

χωρίζεται σε τμήματα (blocks) των 128 bits (16 bytes), ενώ το κλειδί μπορεί να έχει
μήκος 128, 192 ή 256 bits (16, 24 ή 32 bytes), αναλόγως με το επιθυμητό επίπεδο
ασφαλείας. Να σημειωθεί ότι εδώ παρατηρείται και η μοναδική διαφοροποίηση του
AES σε σχέση προς το αρχικό πρότυπο Rijndael, το οποίο υπεστήριζε μεταβλητά μήκη
τόσο για το κλειδί, όσο και για τα τμήματα του απλού κειμένου. Τα μήκη αυτά
μπορούσαν να λάβουν οποιαδήποτε τιμή, πολλαπλάσια του 32, μεταξύ 128 και 256 (σε
bits).

Τα βασικά σχεδιαστικά κριτήρια, τα οποία έλαβαν υπόψη οι δημιουργοί του Rijndael,

είναι η ανθεκτικότητα σε όλες τις γνωστές κρυπταναλυτικές μεθόδους, υψηλή
ταχύτητα και συμπαγείς κώδικες σε ένα ευρύ πεδίο αρχιτεκτονικών υπολογιστών,
καθώς και σχεδιαστική απλότητα. Ο αλγόριθμος Rijndael δεν εμφανίζει τη δομή Feistel,
σύμφωνα με την οποία, σε κάθε κύκλο, μέρος των bits μιας ενδιάμεσης κατάστασης
απλά μετατίθενται χωρίς κάποια επεξεργασία σε άλλη θέση.

Στον αλγόριθμο AES, κάθε κύκλος αποτελείται από τρείς ομοιόμορφους

μετασχηματισμούς, οι οποίοι ονομάζονται επίπεδα (layers). Ο χαρακτηρισμός
“ομοιόμορφο” αναφέρεται στο ότι κάθε bit αντιμετωπίζεται με τον ίδιο τρόπο. Το
επίπεδο γραμμικής ανάμιξης (linear mixing layer) διασφαλίζει υψηλή διάχυση σε
πολλαπλούς κύκλους. Το μη γραμμικό επίπεδο (non linear layer) αναφέρεται στην
παράλληλη εφαρμογή κουτιών αντικατάστασης (S-Boxes), τα οποία εμφανίζουν
άριστες μη γραμμικές ιδιότητες (optimum worst case nonlinearity properties). Το τρίτο
επίπεδο, αυτό της πρόσθεσης του κλειδιού (key addition layer), αναφέρεται στη
συσχέτιση του ενδιάμεσου αποτελέσματος με το αντίστοιχο υποκλειδί του κύκλου
μέσω της πράξης της αποκλειστικής διάζευξης (XOR).

Το επίπεδο της πρόσθεσης (XOR) του υποκλειδιού εφαρμόζεται ήδη πριν από τον
πρώτο κύκλο μετασχηματισμού, επειδή, σε άλλη περίπτωση, όλες οι άλλες πράξεις
μετασχηματισμού, που προηγούνται της πρώτης εκτέλεσης αυτού του επιπέδου ή που
ακολουθούν την τελευταία του εκτέλεση, δεν συμβάλουν στην ασφάλεια του
κρυπτογραφικού συστήματος αφού μπορούν να αφαιρεθούν από τον κρυπταναλυτή
χωρίς γνώση του κλειδιού (όπως η αρχική και τελική μετάθεση στον DES). Σε πολλούς
κρυπτογραφικούς αλγορίθμους προβλέπονται αντίστοιχες αρχικές ή τελικές πράξεις
μετασχηματισμού βασισμένες στο κλειδί, όπως στον IDEA ή τον Blowfish. Το επίπεδο
γραμμικής ανάμιξης στον τελευταίο κύκλο είναι διαφορετικό σε σύγκριση με τους
άλλους κύκλους. Αυτή η διαφορά σχεδιάστηκε έτσι ώστε να προκύπτουν περισσότερες
ομοιότητες στη δομή της κρυπτογράφησης και της αποκρυπτογράφησης. Μια ανάλογη
διαφορά για παρόμοιο σκοπό είναι η έλλειψη της ανταλλαγής των υποτμημάτων στον
τελευταίο κύκλο του DES [26].

57
3.4 Μαθηματικό υπόβαθρο του AES

3.4.1 Το πεδίο (ή Σώμα) GF(28)

Τα στοιχεία ενός πεπερασμένου πεδίου μπορούν να αναπαρασταθούν κατά διάφορους

τρόπους. Για κάθε δύναμη πρώτου αριθμού υπάρχει ένα και μόνο πεπερασμένο πεδίο,
έτσι όλες οι παραστάσεις του GF(28) είναι ισομορφικές. Όμως, η παράσταση του
πεπερασμένου πεδίου επηρεάζει την υλοποίηση του αλγορίθμου. Στον αλγόριθμο AES
επελέγη η κλασσική παράσταση με πολυώνυμα.

Έτσι ένα byte b, αποτελούμενο από τα bits b7b6b5b4b3b2b1b0, θεωρείται ως ένα

πολυώνυμο με συντελεστές στο σύνολο {0, 1}:

b7 x7+ b6 x6 + b5 x5 + b4 x4 + b3 x3 + b2 x2 + b1 x +b0

Για παράδειγμα, το byte με δεκαεξαδική τιμή “57” (ή δυαδική τιμή “01010111”)

αντιστοιχεί στο πολυώνυμο x6 + x4 + x2 + x + 1.

3.4.2 Πρόσθεση στο GF(28)

Στην πολυωνυμική παράσταση, το άθροισμα δύο στοιχείων του πεπερασμένου πεδίου

είναι το πολυώνυμο με συντελεστές το άθροισμα των αντίστοιχων συντελεστών των
δύο πολυωνύμων (mod 2 ), τα οποία προστίθενται ( 1+1=0, 0+0=0, 0+1=1, 1+0=1).

Παράδειγμα

Σε πολυωνυμική μορφή:
(x6 + x4 + x2 + x + 1)+(x7 + x4 + x3 + 1)= x7 + x6 + x3 + x2 + x

Σε δυαδική μορφή:
“01010111” + “10011001” = “11001110”

Σε δεκαεξαδική μορφή:
“57” +”99” = “CE”

3.4.3 Πολλαπλασιασμός στο GF(28)

Η πράξη του πολλαπλασιασμού στο πεπερασμένο πεδίο αντιστοιχεί στον

πολλαπλασιασμό των πολυωνύμων modulo ένα μη αναγόμενο (irreducible) πολυώνυμο
8ου βαθμού. Ένα πολυώνυμο χαρακτηρίζεται μη αναγόμενο αν δεν έχει άλλους διαιρέτες
εκτός από το 1 και τον εαυτό του. Στην περίπτωση του AES έχει επιλεγεί το μη
αναγόμενο πολυώνυμο m(x)=x8 + x4 + x3 + x + 1 ή σε δυαδική μορφή “000100011011” ή
“11B” σε δεκαεξαδική μορφή.

58
Παράδειγμα

“57” × “83” = “C1”

Ή (x6 + x4 + x2 + x + 1)×(x7 + x + 1)= (x13 + x11 + x9 + x8 + x7) + (x7 + x5 + x3 + x2 + x) + (x6 + x4
+ x2 + x + 1) = (x13 + x11 + x9 + x8 + x6 + x5 + x4 + x3 + 1)mod(x8 + x4 + x3 + x + 1) = x7 + x6 + 1.

Δεν υπάρχει κάποιος απλός τρόπος υπολογισμού του πολλαπλασιασμού πολυωνύμων,

όπως στην περίπτωση της πρόσθεσης που είδαμε ανωτέρω. Το στοιχείο “01” είναι το
ουδέτερο στοιχείο του πεδίου, δηλαδή πολλαπλασιαζόμενο με οποιοδήποτε πολυώνυμο
δίνει πάλι το πολυώνυμο αυτό. Με τη βοήθεια του γενικευμένου αλγορίθμου του
Ευκλείδη (όπου αντί για ακεραίους έχουμε πολυώνυμα) μπορεί να υπολογιστεί ο
αντίστροφος ενός πολυωνύμου mod m(x). Δηλαδή, για κάθε πολυώνυμο b(x), βαθμού
μικρότερου του 8, μπορούν να υπολογιστούν τα πολυώνυμα a(x) και c(x), τέτοια ώστε
b(x) a(x) + c(x)m(x) = 1. Επομένως, b(x) a(x) mod m(x) = 1 ή b-1(x)= a(x) mod m(x) .

Επίσης, ισχύει a(x) × (b(x) + c(x))= a(x) × b(x) + a(x) × c(x). Από τα προηγούμενα
συνάγεται ότι το σύνολο των 256 δυνατών τιμών των bytes, με την πράξη XOR ως
πρόσθεση και την πράξη του πολλαπλασιασμού, όπως ορίστηκε παραπάνω, έχει τη
δομή του πεπερασμένου πεδίου GF(28).

3.4.4 Πολλαπλασιασμός πολυωνύμου με το x

Αν πολλαπλασιάσουμε ένα πολυώνυμο b(x) με το πολυώνυμο x λαμβάνουμε:

x × b(x) = (b7 x8+ b6 x7 + b5 x6 + b4 x5 + b3 x4 + b2 x3 + b1 x2 +b0x)mod m(x).

Αν b7 = 0, τότε το αποτέλεσμα του γινομένου έχει βαθμό μικρότερο του 8 και η πράξη
mod m(x) δεν το επηρεάζει. Δηλαδή, σε δυαδική παράσταση το αποτέλεσμα λαμβάνεται
με την ολίσθηση κατά μια θέση προς τα αριστερά της δυαδικής παράστασης του b(x).
Αν b7 = 1, τότε ο βαθμός του γινομένου είναι 8, ίσος με αυτόν του m(x) και επομένως το
m(x) πρέπει να αφαιρεθεί από το γινόμενο x × b(x).

Επομένως ο πολλαπλασιασμός ενός πολυωνύμου b(x) με το πολυώνυμο x υπολογίζεται

πολύ εύκολα με την ολίσθηση κατά μια θέση προς τα αριστερά της δυαδικής
παράστασης του b(x), ακολουθούμενη από την αφαίρεση του m(x) εφόσον b7 = 1.

Παράδειγμα

“01010111”× “00000010” = “10101110” ή “57” × “02” = “AE”.

“10101110”× “00000010” = “01001111” ή “AE” × “02” = “47”.

Για τον πολλαπλασιασμό ενός πολυωνύμου b(x) με υψηλότερες δυνάμεις του x, ο

υπολογισμός επιτυγχάνεται με την επανειλημμένη εκτέλεση του ανωτέρου
πολλαπλασιασμού.

59
3.4.5 Πολλαπλασιασμός με συντελεστές στο GF(28)

Τα πολυώνυμα μπορούν να οριστούν και με συντελεστές στο πεπερασμένο πεδίο

GF(28). Στην περίπτωση αυτή, ένα διάνυσμα τεσσάρων bytes αντιστοιχεί σε ένα
πολυώνυμο βαθμού μικρότερου του 4. Η πρόσθεση των πολυωνύμων αυτών
επιτυγχάνεται με απλή πρόσθεση των αντίστοιχων συντελεστών , δηλαδή με την
συσχέτιση των συντελεστών μέσω της πράξης αποκλειστικής διάζευξης αφού στη
περίπτωση του GF(28) η πρόσθεση είναι αποκλειστική διάζευξη ανά bit.

Ωστόσο, ο πολλαπλασιασμός είναι πιο σύνθετος. Αν έχουμε δύο πολυώνυμα a(x) = a3 x3

+ a2 x2 + a1 x1 + a0 και b(x) = b3 x3 + b2 x2 + b1 x1 + b0 με συντελεστές στο GF(28), τότε το
γινόμενο τους δίνεται από :

c(x) = a(x) b(x) = c6 x6 + c5 x5 + c4 x4 + c3 x3 + c2 x2 + c1 x1 + c0 , όπου

c0 = a0× b0, c1 = a1× b0 ⊕ a0× b1, c2 = a2× b0 ⊕ a1× b1 ⊕ a0× b2, c3 = a3× b0 ⊕ a2× b1 ⊕
a1×b2⊕ a0× b3, c4 = a3× b1 ⊕ a2× b2 ⊕ a1×b3, c5 = a3× b2 ⊕ a2× b3, και c6 = a3× b3.

Έτσι, δεν μπορεί το πολυώνυμο c(x) να αναπαρασταθεί από ένα διάνυσμα τεσσάρων
bytes. Μπορεί όμως να περιοριστεί μέσω της πράξης modulo ένα πολυώνυμο τετάρτου
βαθμού που θα οδηγήσει το c(x) σε βαθμό μικρότερο του 4. Στον AES επελέγη το
πολυώνυμο M(x) = x4 + 1, το οποίο είναι μη αναγόμενο και επομένως ο
πολλαπλασιασμός με ένα σταθερό πολυώνυμο τεσσάρων όρων δεν είναι πάντοτε
αντιστρέψιμος. (Στον AES καθορίστηκε ένα τέτοιο σταθερό πολυώνυμο a(x) = “03”x3 +
“01”x2 + “01”x + “02” το οποίο έχει όμως αντίστροφο πολυώνυμο a-1 (x) = “0B”x3 + “0D”x2
+ “09”x + “0E”.) Επειδή x j mod(x4 +1) = x j mod4 , το γινόμενο των πολυωνύμων a(x) και
c(x) δίνεται από :

d(x)= a(x) ⊗ b(x) = d3 x3 + d2 x2 + d1 x + d0 , όπου

d0 = (a0× b0) ⊕ (a3× b1) ⊕ (a2× b2) ⊕ (a1×b3),
d1 = (a1× b0) ⊕ (a0× b1) ⊕ (a3× b2) ⊕ (a2×b3),
d2 = (a2× b0) ⊕ (a1× b1) ⊕ (a0× b2) ⊕ (a3×b3),
d3 = (a3× b0) ⊕ (a2× b1) ⊕ (a1× b2) ⊕ (a0×b3).

Επομένως, οι υπολογισμοί των συντελεστών μπορούν να περιγραφούν και ως πράξεις

πινάκων, όπου η πρόσθεση αντιστοιχεί στην αποκλειστική διάζευξη:

𝒅𝟎 𝒂𝟎 𝒂𝟑 𝒂𝟐 𝒂𝟏 𝒃𝟎
𝒅𝟏 𝒂𝟏 𝒂𝟎 𝒂𝟑 𝒂𝟐 𝒃𝟏
� �=�𝒂 𝒂𝟏 𝒂𝟎 𝒂𝟑 � . �𝒃𝟐 �
𝒅𝟐 𝟐
𝒅𝟑 𝒂𝟑 𝒂𝟐 𝒂𝟏 𝒂𝟎 𝒃𝟑

3.4.6 Πολλαπλασιασμός πολυωνύμων με συντελεστές στο GF(28) με το x

Αν πολλαπλασιάσουμε ένα πολυώνυμο b(x) με το πολυώνυμο x λαμβάνουμε :

x ⊗ b(x) = b3 x4 + b2 x3 + b1 x2 + b0 x mod (x4 + 1) = b2 x3 + b1 x2 + b0 x + b3.

Ο υπολογισμός των συντελεστών είναι ισοδύναμος με τον ανωτέρω υπολογισμό

πινάκων, όπου όλοι οι συντελεστές του a(x) είναι “00” εκτός του a1 = “01”.

60
3.5 Κρυπτογράφηση

Οι διάφορες πράξεις του αλγορίθμου εφαρμόζονται στο ενδιάμεσο αποτέλεσμα του

αλγορίθμου, το επονομαζόμενο και κατάσταση (state). Η κατάσταση περιγράφεται με
έναν πίνακα, του οποίου τα στοιχεία είναι bytes. Ο πίνακας αυτός έχει τέσσερις γραμμές
και στήλες τόσες όσες αντιστοιχούν στο μήκος του block του αρχικού κειμένου. Επειδή
στον AES το μήκος του τμήματος εισόδου, της κατάστασης και της εξόδου είναι 128
bits, είναι και το πλήθος των στηλών ίσο με 4. (Στον Rijndael το πλήθος των στηλών
μπορούσε να είναι 4 ή 6 ή 8 αφού προέβλεπε μήκος τμήματος εισόδου, κατάστασης και
εξόδου ίσο με 128, 192 και 256 bits.) Κατά την έναρξη της εκτέλεσης της
κρυπτογράφησης ή της αποκρυπτογράφησης, τα 128 bits της εισόδου αντιγράφονται
στον πίνακα κατάστασης. Η τελική τιμή του πίνακα κατάστασης αποτελεί την έξοδο της
κρυπτογράφησης ή της αποκρυπτογράφησης.

Με πίνακα τεσσάρων γραμμών παριστάνεται και το (υπο)κλειδί κάθε κύκλου. Όσο για
το πλήθος των στηλών, αυτό εξαρτάται από το μήκος του κλειδιού. Αν το μήκος είναι
128 bits, τότε ο αριθμός των στηλών του πίνακα είναι 4, ενώ αν το μήκος του κλειδιού
είναι 192 ή 256 bits, ο αριθμός των στηλών του πίνακα είναι 6 ή 8 αντίστοιχα.

Τον αριθμό των στηλών του πίνακα κατάστασης τον συμβολίζουμε με Nb και του
κλειδιού με Nk. Στην Εικόνα 3. 1 φαίνεται ένα παράδειγμα πίνακα κατάστασης για Nb=4
και πίνακα κλειδιού για Nk = 6.

Το πλήθος των κύκλων (Nr), που εκτελούνται κάθε φορά, εξαρτάται από το μήκος του
κλειδιού. Κυμαίνεται δε από 10 έως 14. Στον AES ισχύουν οι ακόλουθοι συνδυασμοί
μήκους κλειδιού, τμήματος και πλήθους κύκλων (Πίνακας 3. 2).

Εικόνα 3. 1 Πίνακας κατάστασης (Nb=4) και πίνακας κλειδιού (Nk=6).

61
 Μήκος κλειδιού Μήκος Τμήματος Πλήθος Κύκλων
(Nk) (Nb) (Nr)
AES-128 4 4 10
AES-192 6 4 12
AES-256 8 4 14

Πίνακας 3. 2 Το πλήθος των κύκλων (Nr) ως συνάρτηση του Nk.

Τα τρία επίπεδα μετασχηματισμού, που αποτελούν κάθε κύκλο του αλγορίθμου,

συγκεκριμενοποιούνται στους εξής τέσσερις επιμέρους μετασχηματισμούς:

• SubBytes(), που είναι η μη γραμμική αντικατάσταση.

• ShiftRows(), που αναφέρεται στην ολίσθηση γραμμών του πίνακα
αντικατάστασης (επίπεδο γραμμικής ανάμιξης, διάχυση μεταξύ των στηλών)
• MixColumns(), που εφαρμόζεται σε κάθε στήλη του πίνακα κατάστασης
ξεχωριστά (επίπεδο γραμμικής ανάμιξης, διάχυση μεταξύ των bytes μιας στήλης).
• AddRoundKey(), που είναι το επίπεδο της πρόσθεσης του (υπο)κλειδιού του
κύκλου.

Στην Εικόνα 3. 2 παρουσιάζεται η λειτουργία κρυπτογράφησης του AES. Είσοδος της

λειτουργίας κρυπτογράφησης του αλγορίθμου είναι το block αρχικού κειμένου και το
κρυπτογραφικό κλειδί.

Εικόνα 3. 2 Η λειτουργία κρυπτογράφησης του AES.

62
Ακολουθεί η περιγραφή της λειτουργίας της κρυπτογράφησης σε μορφή ψευδοκώδικα.

Cipher (byte in [4*Nb], byte out [4*Nb], word w [Nb*(Nr+1)])

Begin
byte state[4,Nb]
state= in
AddRoundKey (state, w [0, Nb-1])
for round = 1 step 1 to Nr–1
SubBytes (state)
ShiftRows (state)
MixColumns (state)
AddRoundKey (state, w [Nr*Nb, Nr+1)*Nb-1]
end for
SubBytes (state)
ShiftRows (state)
AddRoundKey (state, w [Nr*Nb, (Nr+1)*Nb-1])
out = state
End

Στη συνέχεια θα δούμε τους τέσσερις βασικούς μετασχηματισμούς του AES: SubBytes(),
ShiftRows(), MixColumns(), και AddRoundKey().

3.5.1 Μετασχηματισμός SubBytes()

Η συνάρτηση SubBytes είναι ένα κουτί αντικατάστασης και συμβολίζεται ως SRD. Η SRD
επιδρά σε μεμονωμένα bytes. Το αξιοσημείωτο είναι πως είναι ίδια για κάθε byte που
δέχεται στην είσοδό της, ενώ πολλοί κρυπταλγόριθμοι κάνουν χρήση διαφορετικών S-
boxes, αναλόγως της εισόδου τους.

Η SRD ορίζεται από την σύνθεση δύο συναρτήσεων g και f , που αμφότερες ενεργούν επί
του GF(28). Η συνάρτηση g είναι υπεύθυνη για την μη γραμμικότητα του SRD και
ορίζεται ως εξής:

g : b⇾ b’=b-1 ή b ⊗ g(b)=1

όπου ο πολλαπλασιασμός εκτελείται με αναγωγή modulo m(x).

Επειδή, εξ ορισμού, η αλγεβρική έκφραση της g είναι αρκετά απλή, ώστε να διευκολύνει
κρυπταναλυτικές επιθέσεις που στοχεύουν στα S-Boxes του AES, το αποτέλεσμα της g
αποτελεί όρισμα για την συνάρτηση f , η οποία είναι ένας αντιστρεπτός γραμμικός
μετασχηματισμός στο GF(28). Για την επιλογή της f ελήφθησαν υπ’ όψη τα ακόλουθα
κριτήρια:

1. Η f έπρεπε να έχει απλή αλγεβρική έκφραση.

2. Από τον συνδυασμό της f με την g να προκύπτει πολύπλοκη αλγεβρική
έκφραση.
3. Η γραμμικότητα της f δεν έπρεπε να επηρεάζει την μη γραμμικότητα της g.
4. Η σύνθετη συνάρτηση fog ≡ SRD δεν έπρεπε να έχει σταθερά σημεία (fixed
points).

Δηλαδή: SRD(b)⊕ b ≠ “00” και SRD(b)⊕ b ≠ “FF” για κάθε b.

63
Σύμφωνα με τα παραπάνω, τα βήματα που πραγματοποιούνται για τον υπολογισμό του
SubBytes μετασχηματισμό είναι τα εξής:

• Πρώτα υπολογίζεται ο πολλαπλασιαστικός αντίστροφος του byte που

πρόκειται να αντικατασταθεί στο πεπερασμένο πεδίο GF(28).
• Το αποτέλεσμα του προηγούμενου βήματος υποβάλλεται στον ακόλουθο
(affine) μετασχηματισμό GF(2). (Ένας μετασχηματισμός χαρακτηρίζεται affine
αν συνίσταται στον πολλαπλασιασμό με έναν πίνακα ακολουθούμενο από την
πρόσθεση με ένα διάνυσμα.)

𝑠′ 𝑠0
⎡ 0⎤ 10001111 1
⎡1 1 0 0 0 1 1 1⎤ ⎡𝑠1 ⎤ ⎡1⎤
⎢𝑠′1 ⎥
⎢𝑠′2 ⎥ ⎛ ⎢1 1 1 0 0 0 1 1⎥ ⎢𝑠 ⎥ ⎞ ⎢0⎥
2
⎢𝑠′3 ⎥ ⎜⎢ ⎥ ⎢𝑠 ⎥ ⎟ ⎢ ⎥
⎢𝑠′ ⎥ = ⎜ ⎢1 1 1 1 0 0 0 1⎥ ⊗ ⎢ 3 ⎥ ⎟ ⊕ ⎢0⎥
4 ⎜ ⎢1 1 1 1 1 0 0 0⎥ ⎢𝑠4 ⎥ ⎟ ⎢0⎥
⎢ ⎥ ⎜ ⎢0 1 1 1 1 1 0 0⎥ ⎢𝑠5 ⎥ ⎟ ⎢1⎥
𝑠′
⎢ 5⎥ ⎢0 0 1 1 1 1 1 0⎥ ⎢𝑠6 ⎥ ⎢1⎥
⎢𝑠′6 ⎥
⎝ ⎣0 0 0 1 1 1 1 1⎦ ⎣𝑠7 ⎦ ⎠ ⎣0⎦
⎣𝑠′7 ⎦

Με τη βοήθεια του ανωτέρου μετασχηματισμού ένα byte a, αφού υπολογιστεί ο

αντίστροφος του s στο πεπερασμένο πεδίο GF(28), αντικαθιστάται από το byte s’. Για
τον υπολογισμό του s από το s’, δηλαδή για την αντιστροφή του ανωτέρου
μετασχηματισμού που είναι απαραίτητη στην αποκρυπτογράφηση, χρησιμοποιείται ο
αντίστροφος πίνακας. Ο υπολογισμός του αντιστρόφου ενός byte στο πεπερασμένο
πεδίο GF(28) και κατ’ επέκταση και του ανωτέρου πίνακα επιτυγχάνεται με τη βοήθεια
του γενικευμένου αλγορίθμου του Ευκλείδη, θεωρώντας τα bits ως συντελεστές
πολυωνύμων.

Για παράδειγμα έστω ότι έχουμε το δεκαεξαδικό αριθμό {95}. Ο πολλαπλασιαστικός του
αντίστροφος στο GF(28) είναι “95”-1 = “8A”, δηλαδή “10001010” στο δυαδικό. Συνεπώς:

10001111 0 1 1 1 0
⎡1 1 0 0 0 1 1 1⎤ ⎡1⎤ ⎡1⎤ ⎡ 0⎤ ⎡1⎤ ⎡1⎤
⎛ ⎢1 1 1 0 0 0 1 1⎥ ⎢ ⎥ ⎞ ⎢0⎥ ⎢ 0⎥ ⎢0⎥ ⎢0⎥
0
⎜⎢ ⎥ ⎢ ⎥⎟ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥
⎜⎢ 1 1 1 1 0 0 0 1⎥ ⊗ ⎢1⎥ ⎟ ⊕ ⎢0⎥ = ⎢1⎥ ⊕ ⎢0⎥ = ⎢1⎥
⎜ ⎢1 1 1 1 1 0 0 0⎥ ⎢0⎥ ⎟ ⎢0⎥ ⎢ 0⎥ ⎢0⎥ ⎢0⎥
⎜ ⎢0 1 1 1 1 1 0 0⎥ ⎢0⎥ ⎟ ⎢1⎥ ⎢ 0⎥ ⎢1⎥ ⎢1⎥
⎢0 0 1 1 1 1 1 0⎥ ⎢0⎥ ⎢1⎥ ⎢ 1⎥ ⎢1⎥ ⎢0⎥
⎝ ⎣0 0 0 1 1 1 1 1⎦ ⎣1⎦ ⎠ ⎣0⎦ ⎣ 0⎦ ⎣0⎦ ⎣0⎦

δηλαδή, “2Α".

Το παρακάτω κουτί αντικατάστασης που χρησιμοποιείται στο μετασχηματισμό

SubBytes() μπορεί να παρουσιαστεί με τη βοήθεια του ακόλουθου πίνακα πολύ πιο
απλά σε δεκαεξαδική μορφή (Πίνακας 3. 3).

64
 Εικόνα 3. 3 Εφαρμογή SubBytes() σε κάθε byte της κατάστασης.

y
0 1 2 3 4 5 6 7 8 9 A B C D E F
0 63 7C 77 7B F2 6B 6F C5 30 01 67 2B FE D7 AB 76
1 CA 82 C9 7D FA 59 47 F0 AD D4 A2 AF 9C A4 72 C0
2 B7 FD 93 26 36 3F FA CC 34 A5 E5 F1 71 D8 31 15
3 04 C7 23 C3 18 96 05 9A 07 12 80 E2 EB 27 B2 75
4 09 83 2C 1A 1B 6E 5A A0 52 3B D6 B3 29 E3 2F 84
5 53 D1 00 ED 20 FC B1 5B 6A CB BE 39 4A 4C 58 CF
6 D0 EF AA FB 43 4D 33 85 45 F9 02 7F 50 3C 9F A8
x
7 51 A3 40 8F 92 9D 38 F5 BC B6 DA 21 10 FF F3 D2
8 CD 0C 13 EC 5F 97 44 17 C4 A7 7E 3D 64 5D 19 73
9 60 81 4F DC 22 2A 90 88 46 EE B8 14 DE 5E 0B DB
A E0 32 3A 0A 49 06 24 5C C2 D3 AC 62 91 95 E4 79
B E7 C8 37 6D 8D D5 4E A9 6C 56 F4 EA 65 7A AE 08
C BA 78 25 2E 1C D6 B4 C6 E8 DD 74 1F 4B BD 8B 8A
D 70 3E B5 66 48 03 F6 0E 61 35 57 B9 86 C1 1D 9E
E E1 F8 98 11 69 D9 8E 94 9B 1E 87 E9 CE 55 28 DF
F 8C A1 89 0D BF E6 42 68 41 99 2D 0F B0 54 BB 16

Πίνακας 3. 3 Τιμές αντικατάστασης για byte xy σε δεκαεξαδική μορφή.

Με τη βοήθεια του παραπάνω πίνακα μπορούμε πολύ εύκολα να βρούμε την έξοδο του
κουτιού αντικατάστασης για μια δεδομένη είσοδο. Έτσι, αν το byte της εισόδου είναι
“xy” , σε δεκαεξαδική μορφή, αυτό αντικαθίσταται από το byte που βρίσκεται στη σειρά
“x” και τη στήλη “y” του παραπάνω πίνακα. Για παράδειγμα, το byte “95”
αντικαθίσταται από το byte που βρίσκεται στη γραμμή {9} και τη στήλη {5}, δηλαδή
από το byte “2Α".

Ένας πίνακας κατάστασης λοιπόν, μετά τον μετασχηματισμό SubBytes θα είναι :

Εικόνα 3. 4 Πίνακας κατάστασης μετά από το μετασχηματισμό SubBytes.

65
 Εικόνα 3. 5 Κατασκευή ενός SBox.

3.5.2 Μετασχηματισμός ShiftRows()

Όπως αναφέρθηκε και σε προηγούμενη ενότητα, τα bytes κάθε τμήματος απλού

κειμένου και κρυπτοκειμένου, καθώς και οι καταστάσεις διατάσσονται, στον AES, σε
έναν πίνακα 4x4. Η συνάρτηση ShiftRows() είναι ένα P-κουτί που επιδρά στη διάταξη
των bytes στον πίνακα αυτόν. Συγκεκριμένα, σε κάθε γραμμή του πίνακα κατάστασης
πραγματοποιείται αριστερή κυκλική ολίσθηση (LS) των bytes κατά τόσες θέσεις
σύμφωνα με τη σχέση:

s’ r,c = sr, (c+shift(r,Nb))modNb για 0<r<4 και 0≤c≤Nb,

όπου r είναι ο αριθμός της γραμμής και c ο αριθμός της στήλης και η τιμή shift(r,Nb) να
εξαρτάται από τη γραμμή (υπενθυμίζουμε πως Nb= 4).

shift (1,4)=1 shift(2,4)=2 shift(3,4)=3

Συνοπτικά οι θέσεις ολίσθησης παρουσιάζονται στον Πίνακα 3. 4, ο πίνακας

καταστάσεως μετασχηματίζεται σύμφωνα με την Εικόνα 3. 6 και παρουσιάζεται ένα
παράδειγμα Εικόνα 3. 7.

Γραμμή πίνακα 1 2 3 4
Θέσεις ολίσθησης 0 1 2 3

Πίνακας 3. 4 Αριθμός ολισθήσεων ανά γραμμή.

Εικόνα 3. 6 Εφαρμογή της ShiftRows() στον πίνακα κατάστασης.

66
 Εικόνα 3. 7 Πίνακας κατάστασης μετά από το μετασχηματισμό ShiftRows.

3.5.3 Μετασχηματισμός MixColumns()

Ο μετασχηματισμός MixColumns() εφαρμόζεται σε κάθε στήλη του πίνακα κατάστασης.

Σύμφωνα με τον μετασχηματισμό αυτό, οι στήλες αντιμετωπίζονται ως πολυώνυμα με
συντελεστές στο πεπερασμένο πεδίο GF(28) και πολλαπλασιάζονται με ένα δεδομένο
πολυώνυμο, το c(x)= “03”x3 + “01”x2 + “01”x + “02”, modulo (x4 + 1). Όπως αναφέραμε
και στην υποενότητα 3.4.5, παρόλο που το πολυώνυμο (x4 + 1) είναι μη αναγόμενο, το
c(x) επελέγη έτσι ώστε ο πολλαπλασιασμός του με ένα άλλο πολυώνυμο να είναι
αντιστρέψιμος. Οι συντελεστές του πολυωνύμου που αντιστοιχεί στη στήλη με το c(x)
modulo (x4 + 1), αποτελούν τη νέα στήλη (Εικόνα 3. 8). Στην ακόλουθη σχέση, το ⊗
συμβολίζει τον πολλαπλασιασμό modulo (x4 + 1).

s’(x) = c(x) ⊗ s(x) :

𝑠′ 02 03 01 01 𝑠0,𝑐
⎡ 0,𝑐 ⎤
⎢𝑠′1,𝑐 ⎥ 01 02 03 01 𝑠1,𝑐
⎢𝑠′ ⎥ = � � ⊗ �𝑠 � για 0≤c≤Nb
01 01 02 03 2,𝑐
⎢ 2,𝑐 ⎥ 𝑠3,𝑐
⎣𝑠′3,𝑐 ⎦ 03 01 01 02

Ως αποτέλεσμα αυτού του μετασχηματισμού τα τέσσερα byte κάθε στήλης

αντικαθιστώνται από τα ακόλουθα:

s’ 0,c = (“02” × s 0,c) ⊕ (“03” × s 1,c) ⊕ s 2,c ⊕ s 3,c

s’ 1,c = s 0,c ⊕ (“02” × s 1,c) ⊕ (“03” × s 2,c) ⊕ s 3,c
s’ 2,c = s 0,c ⊕ s 1,c ⊕ (“02” × s 2,c) ⊕ (“03” × s 3,c)
s’ 2,c = (“03” × s 0,c) ⊕s 1,c ⊕ s 2,c ⊕ (“02” × s 3,c)

Εικόνα 3. 8 Εφαρμογή της MixColumns() στον πίνακα κατάστασης.

67
 Εικόνα 3. 9 Πίνακας κατάστασης μετά από το μετασχηματισμό MixColumns.

Στην Εικόνα 3. 9 παρουσιάζεται ένα παράδειγμα σε πίνακα κατάστασης με την

εφαρμογή του μετασχηματισμού MixColumns. Αναλυτικά, όπως είδαμε στην
παράγραφο 3.4, η πρόσθεση στο GF(28) είναι η πράξη της αποκλειστικής διάζευξης και
ο πολλαπλασιασμός ανάγεται σε ολίσθηση ενός bit και πραγματοποιώντας XOR με
“00011011” αν το πιο σημαντικό bit είναι “1”. Συνεπώς για τη πρώτη στήλη του
παραδείγματος ο μετασχηματισμός δίνει:

(“02” × “87”) ⊕ (“03” × “6E”) ⊕ “46” ⊕ “A6” = “47”

“87” ⊕ (“02” × “6E”) ⊕ (“03” × “46”) ⊕ “A6” = “37”
“87” ⊕ “6E” ⊕ (“02” × “46”) ⊕ (“03” × “A6”) = “94”
(“03” × “87”) ⊕”6E” ⊕ “46” ⊕ (“02” × “A6”) = “ED”

Για την πρώτη εξίσωση έχουμε “02” × “87” = (00001110) ⊕ (00011011) = (00010101)
και “03” × “6E” = “6E” ⊕ (“02” × “6E”) = (01101110) ⊕ (11011100) = (10110010).
Δηλαδή:

“02” × “87” = 00010101

“03” × “6E” = 10110010
“46” = 01000110
“A6” = 10100110
01000111 = “47”

Όμοια υπολογίζονται και τα υπόλοιπα.

3.5.4 Μετασχηματισμός AddRoundKey()

Η συνάρτηση αυτή είναι η πράξη XOR που πραγματοποιείται σε κάθε γύρο μεταξύ των
bits της κατάστασης και του κλειδιού γύρου. Η AddRoundKey() δεν απαιτεί ορισμό
αντίστροφης διαδικασίας, καθώς η πράξη XOR είναι αντιστρεπτή αφ’ εαυτής.

Στην Εικόνα 3. 10 παρουσιάζεται ένα παράδειγμα με την εφαρμογή του

μετασχηματισμού AddRoundKey στον πίνακα κατάστασης.

Εικόνα 3. 10 Πίνακας κατάστασης μετά από το μετασχηματισμό AddRoundKey.

68
3.6 Επέκταση κλειδιού

Τα κλειδιά των γύρων (ή υποκλειδιά), τα οποία χρησιμοποιούνται στο μετασχηματισμό

AddRoundKey(), εξάγονται από το αρχικό κλειδί k. Το πλήθος των υποκλειδιών, τα
οποία απαιτούνται για κρυπτογράφηση ή αποκρυπτογράφηση, εξαρτάται από την
επιλογή του αλγορίθμου (AES-128 απαιτεί 10 υποκλειδιά, AES-192 12 και AES-256 14).

Το αρχικό κλειδί k επεκτείνεται σε ένα μήκος ικανό να καλύψει όλες τις εκτελέσεις του
μετασχηματισμού AddRoundKey() (παρακάτω φαίνεται ο ψευδοκώδικας για την
επέκταση του κλειδιού). Αν συμβολίσουμε με Expanded_Key το αποτέλεσμα της
επέκτασης του αρχικού κλειδιού, τότε οι πρώτες Nk λέξεις του (των 4 bytes) είναι το
αρχικό κλειδί k. Οι υπόλοιπες λέξεις του Expanded_Key υπολογίζονται από τις πρώτες
αυτές λέξεις σύμφωνα με μία συνάρτηση, η οποία εξαρτάται από την τιμή του Nk. Από
τα bytes ki, 0≤i≤4⋅Nk του αρχικού κλειδιού, προκύπτουν τα bytes wi 0≤i≤Nw του
επεκτεταμένου κλειδιού, όπου Nw = 4⋅(Nr + 1). Τα ki και wi διατάσσονται σε πίνακες
διαστάσεων 4×Νκ και 4×Νw αντίστοιχα. Έτσι τα κλειδιά γύρου προκύπτουν από το
επεκτεταμένο κλειδί όπως φαίνεται στην Εικόνα 3. 11. Επειδή οι υπολογισμοί
βασίζονται στους δείκτες των bytes κλειδιού k και των λέξεων του Expanded_Key, θα
ορίσουμε δύο πίνακες-διανύσματα, τον key[i], με στοιχεία τα bytes του αρχικού κλειδιού
k και τον W[j] με στοιχεία τις λέξεις του Expanded_Key.

KeyExpansion (byte key[4*Nk], word W[Nb*(Nr+1)], Nk)

begin
word temp

i = 0

while (i < Nk)

W[i] = word(key[4*i], key[4*i+1], key[4*i+2], key[4*i+3])
i = i+1
end while

i = Nk

while (i < Nb * (Nr+1)]

temp = W[i-1]
if (i mod Nk = 0)
temp = SubWord(RotWord(temp)) xor Rcon[i/Nk]
else if (Nk > 6 and i mod Nk = 4)
temp = SubWord(temp)
end if
W[i] = W[i-Nk] xor temp
i = i + 1
end while
end

69
 Εικόνα 3. 11 Επέκταση κλειδιού.

Βασικός παράγοντας στην επέκταση κλειδιού είναι η ενσωμάτωση της μη

γραμμικότητας, η οποία επιτυγχάνεται με τη χρησιμοποίηση της συναρτήσεως
SubWord(). Η συνάρτηση SubWord() μετατρέπει την είσοδό της, η οποία είναι λέξη των
4 bytes, σε έξοδο, η οποία είναι επίσης λέξη των 4 bytes και της οποίας τα bytes
προκύπτουν με τον γνωστό μετασχηματισμό SubBytes() των αντίστοιχων bytes της
εισόδου. Η συνάρτηση RotWord() μεταθέτει κυκλικά τα bytes εισόδου (a, b, c, d) έτσι
ώστε να προκύπτει στην έξοδό της η λέξη (b, c, d, a).

Στην επέκταση κλειδιού συμμετέχουν, επίσης, για την απαλοιφή πιθανών συμμετριών
κάποιες σταθερές, οι οποίες ονομάζονται σταθερές γύρου (round constants ή RCon)
και ορίζονται ως εξής:

RCon(1)= x0 = 01(16)
RCon(2)= x1 = 02(16)
Για i>2:
RCon(i)= xi-1 =x ⊗ RCon(i-1)= 02(16) ⊗ RCon(i-1)

Λόγω του τρόπου χρήσης των σταθερών γύρου στην επέκταση κλειδιού, είναι αδύνατον
να χρειασθεί σταθερά RCon(i) με i >10 . Οι δυνατές τιμές των σταθερών γύρου,
επομένως, είναι οι:

i RCon(i) RCon(i)
[HEX] [DEC]
1 01 1
2 02 2
3 04 4
4 08 8
5 10 16
6 20 32
7 40 64
8 80 128
9 1B 27
10 36 54

Πίνακας 3. 5 Δυνατές τιμές της σταθεράς γύρου.

70
Παρατηρούμε στην παραπάνω περιγραφή της KeyExpansion ότι μετά τις πρώτες Nk
λέξεις του Expanded_Key, οι οποίες είναι ακριβώς το δεδομένο κλειδί k, κάθε λέξη W[i]
του Expanded_Key που ακολουθεί είναι ίση με το αποτέλεσμα της συσχέτισης μέσω της
αποκλειστικής διάζευξης (XOR) της προηγούμενης λέξης W[i-1] με την λέξη W[i-Nk]. Για
λέξεις των οποίων οι θέσεις είναι πολλαπλάσια του Nk, στη λέξη W[i-1] εφαρμόζεται
ένας σύνθετος μετασχηματισμός πριν την πράξη της αποκλειστικής διάζευξης
ακολουθούμενος από την εκτέλεση της πράξης αποκλειστικής διάζευξης με τη σταθερά
κύκλου RCon[i]. Ο σύνθετος αυτός μετασχηματισμός αποτελείται από μια κυκλική
ολίσθηση των bytes μιας λέξης (RotWord()), ακολουθούμενος από την αντικατάσταση
όλων των bytes της λέξης (SubWord()).

Σημειώνεται ακόμα, ότι η ανωτέρω ρουτίνα επέκτασης κλειδιού διαφοροποιείται

κάπως στην περίπτωση κλειδιού μήκους 256 bits. Συγκεκριμένα, για Nk>6 αν το (i-4)
είναι πολλαπλάσιο του Nk, πριν την πράξη της αποκλειστικής διάζευξης εφαρμόζεται η
SubWord() στη λέξη W[i-1].

3.7 Αποκρυπτογράφηση

Ο αλγόριθμος για την κρυπτογράφηση ή αλλιώς ευθεία αποκρυπτογράφηση

(straightforward decryption) προκύπτει από την αναστροφή του αλγορίθμου
κρυπτογραφήσεως και την αντικατάσταση των συναρτήσεών του από τις αντίστροφές
τους (InvShiftRows(), InvSubBytes(), InvMixColumns() και AddRoundKey()). Η
αρίθμηση των γύρων στην αποκρυπτογράφηση γίνεται αντιστρόφως (ακολουθώντας
φθίνουσα πορεία), ώστε να ισχύει η αντιστοιχία με τα κλειδιά γύρου. Στη συνέχεια
περιγράφεται η λειτουργία της αποκρυπτογράφησης σε μορφή ψευδοκώδικα και στην
Εικόνα 3. 12 παρουσιάζεται η λειτουργία αποκρυπτογράφησης του AES.

InvCipher(byte in[4*Nb], byte out[4*Nb], word w[Nb*(Nr+1)])

begin
byte state[4,Nb]

state = in

AddRoundKey(state, w[Nr*Nb, (Nr+1)*Nb-1])

for round = Nr-1 step -1 downto 1

InvShiftRows(state)
InvSubBytes(state)
AddRoundKey(state, w[round*Nb, (round+1)*Nb-1])
InvMixColumns(state)
end for

InvShiftRows(state)
InvSubBytes(state)
AddRoundKey(state, w[0, Nb-1])
out = state
end

71
 Εικόνα 3. 12 Η λειτουργία ευθείας αποκρυπτογράφησης του AES.

3.7.1 Μετασχηματισμός InvSubBytes()

Η InvSubBytes() είναι η αντίστροφη διαδικασία της SubBytes και σχετίζεται με τον

υπολογισμό του αντιστρόφου S-κουτιού : SRD-1 . Για τον υπολογισμό αυτόν είναι
απαραίτητο να ορισθεί η αντίστροφη συνάρτηση της f .

𝑠′ 𝑠0
⎡ 0⎤ 00100101 1
⎡1 0 0 1 0 0 1 0⎤ ⎡𝑠1 ⎤ ⎡0⎤
⎢𝑠′1 ⎥
⎢𝑠′2 ⎥ ⎛ ⎢0 1 0 0 1 0 0 1⎥ ⎢𝑠 ⎥ ⎞ ⎢1⎥
2
⎢𝑠′ ⎥ ⎜⎢ ⎥ ⎢𝑠 ⎥ ⎟ ⎢ ⎥
1 0 1 0 0 1 0 0⎥ ⊗ ⎢ 3 ⎥ ⎟ ⊕ ⎢0⎥
f-1(s) => ⎢ 3 ⎥ = ⎜⎢
𝑠′4 ⎜ ⎢0 1 0 1 0 0 1 0⎥ ⎢𝑠4 ⎥ ⎟ ⎢0⎥
⎢ ⎥ ⎜ ⎢0 0 1 0 1 0 0 1⎥ ⎢𝑠5 ⎥ ⎟ ⎢0⎥
⎢𝑠′5 ⎥ ⎢1 0 0 1 0 1 0 0⎥ ⎢𝑠6 ⎥ ⎢0⎥
⎢𝑠′6 ⎥
⎝ ⎣0 1 0 0 1 0 1 0⎦ ⎣𝑠7 ⎦ ⎠ ⎣0⎦
⎣𝑠′7 ⎦

Το παραπάνω κουτί αντικατάστασης που χρησιμοποιείται στο μετασχηματισμό

InvSubBytes() μπορεί να παρουσιαστεί με τη βοήθεια του ακόλουθου πίνακα πολύ πιο
απλά σε δεκαεξαδική μορφή και μπορούμε πολύ πιο εύκολα να βρούμε την έξοδο του
κουτιού αντικατάστασης για μια δεδομένη είσοδο (Πίνακας 3. 6).

72
 y
0 1 2 3 4 5 6 7 8 9 A B C D E F
0 52 09 6A D5 30 36 A5 38 BF 40 A3 9E 81 F3 D7 FB
1 7C E3 39 82 9B 2F FF 87 34 8E 43 44 C4 DE E9 CB
2 54 7B 94 32 A6 C2 23 3D EE 4C 95 0B 42 FA C3 4E
3 08 2E A1 66 28 D9 24 B2 76 5D A2 49 6D 8B D1 25
4 72 F8 F6 64 86 68 98 16 D4 A4 5C CC 5D 65 B6 92
5 6C 70 48 50 FD ED B9 DA 5E 15 46 57 A7 8D 9D 84
6 90 D8 AB 00 8C BC D3 0A F7 E4 58 05 B8 B3 45 06
x
7 D0 2C 1E 8F CA 3F 0F 02 C1 AF BD 03 01 13 8A 6B
8 3A 91 11 41 4F 67 DC EA 97 F2 CF CE F0 B4 E6 73
9 96 AC 74 22 E7 AD 35 85 E2 F9 37 E8 1C 75 DF 6E
A 47 F1 1A 71 1D 29 C5 89 6F B7 62 0E AA 18 BE 1B
B FC 56 3E 4B C6 D2 79 20 9A DB C0 FE 78 CD 5A F4
C 1F DD A8 33 88 07 C7 31 B1 12 10 59 27 80 EC 5F
D 60 51 7F A9 19 B5 4A 0D 2D E5 7A 9F 93 C9 9C EF
E A0 E0 3B 4D AE 2A F5 B0 C8 EB BB 3C 83 53 99 61
F 17 2B 04 7E BA 77 D6 26 E1 69 14 63 55 21 0C 7D

Πίνακας 3. 6 Τιμές αντικατάστασης για byte xy σε δεκαεξαδική μορφή.

3.7.2 Μετασχηματισμός InvShiftRows()

Η συνάρτηση InvShiftRows() είναι η αντίστροφη της συνάρτησης ShiftRows. Τα bytes,

σε κάθε γραμμή του πίνακα κατάστασης ολισθαίνουν δεξιά (RS) πλέον κατά τον ίδιο
σταθερό αριθμό θέσεων όπως και στο μετασχηματισμό ShiftRows.

s’ r,c = sr, (c+shift(r,Nb))modNb για 0<r<4 και 0≤c≤Nb

Έτσι, ο πίνακας καταστάσεως γίνεται:

Εικόνα 3. 13 Εφαρμογή της InvShiftRows() στον πίνακα κατάστασης.

73
3.7.3 Μετασχηματισμός InvMixColumns()

Ο μετασχηματισμός αυτός είναι ο αντίστροφος του MixColumns(). Κάθε στήλη του

πίνακα κατάστασης αντιμετωπίζεται ως ένα πολυώνυμο τεσσάρων όρων με
συντελεστές στο πεπερασμένο πεδίο GF(28) και πολλαπλασιάζονται με ένα δεδομένο
πολυώνυμο, το d(x)= “0B”x3 + “0D”x2 + “09”x + “0e”, modulo (x4 + 1). Το d(x) είναι ο
αντίστροφος του c(x) που χρησιμοποιείται στον μετασχηματισμό MixColumns(), δηλαδή
c(x) ⋅ d(x) = “01” mod(x4 + 1).

Έτσι λοιπόν ο πολλαπλασιασμός γίνεται:

s’(x) = d(x) ⊗ s(x) :

𝑠′ 0𝐸 0𝐵 0𝐷 09 𝑠0,𝑐
⎡ 0,𝑐 ⎤
⎢𝑠′1,𝑐 ⎥ 09 0𝐸 0𝐵 0𝐷 𝑠1,𝑐
⎢𝑠′ ⎥ = � � ⊗ �𝑠 � για 0≤c≤Nb
0𝐷 09 0𝐸 0𝐵 2,𝑐
⎢ 2,𝑐 ⎥ 𝑠3,𝑐
⎣𝑠′3,𝑐 ⎦ 0𝐵 0𝐷 09 0𝐸

Ως αποτέλεσμα αυτού του μετασχηματισμού τα τέσσερα byte κάθε στήλης

αντικαθιστώνται από τα ακόλουθα:

s’ 0,c =(“0E” × s 0,c) ⊕ (“0B” × s 1,c) ⊕ (“0D” × s 2,c) ⊕ (“09” × s 3,c)

s’ 1,c =(“09” × s 0,c) ⊕ (“0E” × s 1,c) ⊕ (“0B” × s 2,c) ⊕ (“0D” × s 3,c)
s’ 2,c =(“0D” × s 0,c) ⊕ (“09” × s 1,c) ⊕ (“0E” × s 2,c) ⊕ (“0B” × s 3,c)
s’ 2,c =(“0B” × s 0,c) ⊕ (“0D” × s 1,c) ⊕ (“09” × s 2,c) ⊕ (“0E” × s 3,c)

3.7.4 Αντίστροφος μετασχηματισμός AddRoundKey()

Όπως αναφέραμε και στην παράγραφο 3.5.4 ο αντίστροφος μετασχηματισμός της

AddRoundKey() είναι η ίδια η συνάρτηση καθώς η πράξη XOR είναι αντιστρεπτή από
μόνη της.

3.7.5 Αλγόριθμος ισοδύναμης Αποκρυπτογράφησης

Η κατασκευή των συναρτήσεων του AES είναι τέτοια, που επιτρέπει τον ορισμό
αλγορίθμου για ισοδύναμη αποκρυπτογράφηση (equivalent decryption). Αυτός ο
αλγόριθμος έχει την δομή του αλγορίθμου κρυπτογραφήσεως. Διαφοροποιείται,
ωστόσο στη χρήση των αντιστρόφων συναρτήσεων και στην αρίθμηση των γύρων, η
οποία γίνεται αντιστρόφως, όπως και στην ευθεία αποκρυπτογράφηση. Διαφορετική
είναι και η επέκταση κλειδιού. Το επεκτεταμένο κλειδί στην περίπτωση αυτή προκύπτει
από το κανονικό επεκτεταμένο κλειδί, αφού επενεργήσει στα κλειδιά των ενδιαμέσων
γύρων (εκτός, δηλαδή, των γύρων 0 και Nr ) η συνάρτηση InvMixColumns. Παρακάτω
παρουσιάζεται ο ψευδοκώδικας του ισοδύναμου αλγόριθμου κρυπτογραφήσεως και
έπειτα το μπλοκ διάγραμμα του (Εικόνα 3. 14). Αξίζει να σημειωθεί πως η
InvMixColumns() εφαρμόζεται όπως είδαμε σε έναν πίνακα δύο διαστάσεων ενώ τα
κλειδιά του κάθε γύρου χρησιμοποιούνται σαν ένας πίνακας από λέξεις. Για το λόγο
αυτό πρέπει να γίνουν κατάλληλες τροποποιήσεις στον τύπο των δεδομένων.

74
EqInvCipher(byte in[4*Nb], byte out[4*Nb], word dw[Nb*(Nr+1)])
begin
byte state[4,Nb]

state = in

AddRoundKey(state, dw[Nr*Nb, (Nr+1)*Nb-1])

for round = Nr-1 step -1 downto 1

InvSubBytes(state)
InvShiftRows(state)
InvMixColumns(state)
AddRoundKey(state, dw[round*Nb, (round+1)*Nb-1])
end for

InvSubBytes(state)
InvShiftRows(state)
AddRoundKey(state, dw[0, Nb-1])

out = state
end

Για τον ισοδύναμο αλγόριθμο αποκρυπτογράφησης θα πρέπει να προστεθεί

ο ακόλουθος ψευδοκώδικας στο τέλος του κώδικα επέκτασης κλειδιού:

for i = 0 step 1 to (Nr+1)*Nb-1

dw[i] = w[i]
end for

for round = 1 step 1 to Nr-1

InvMixColumns(dw[round*Nb, (round+1)*Nb-1])
end for

Εικόνα 3. 14 Η λειτουργία ισοδύναμης αποκρυπτογράφησης του AES.

75
3.8 Παρουσίαση διαδικασίας κρυπτογραφήσεως μέσω
παραδείγματος

Με το τέλος της περιγραφής των συναρτήσεων του AES και των διαδικασιών
κρυπτογράφησης και αποκρυπτογράφησης, κρίνεται σκόπιμο, για την εμπέδωση και
καλύτερη κατανόηση των προηγουμένων, να γίνει αναλυτική παρουσίαση των δύο
πρώτων γύρων της διαδικασίας κρυπτογράφησης (γύροι 0 και 1), βήμα προς βήμα,
μέσω παραδείγματος (όλες οι τιμές του παραδείγματος είναι στο δεκαεξαδικό σύστημα
αρίθμησης).

Έστω το αρχικό κείμενο:

p = [00 01 02 03 04 05 06 07 08 09 10 20 30 40 50 60]

Και το αρχικό κλειδί των 128 bits (Νκ = 4):

k = [30 70 97 1a b7ce 45 06 3f d2 57 3f 49 f5 42 0d]

1. Μετατροπή εισόδων (αρχικό κείμενο και κλειδί) από διανύσματα σε πίνακες

00 01 02 03 30 70 97 1𝑎
04 05 06 07 𝑏7 𝑐𝑒 45 06
𝑝= � � 𝑘 = �3𝑓 𝑑2 57 3𝑓 �
08 09 10 20
30 40 50 60 49 𝑓5 42 0𝑑

2. Επέκταση κλειδιού

Αρχικά χωρίζεται το κλειδί σε λέξεις w[i] με τις τέσσερις πρώτες να αποτελούν το

αρχικό κλειδί και τις υπόλοιπες να υπολογίζονται από αυτό.

w[0] = 30 70 97 1a
w[1] = b7 ce 45 06
w[2] = 3f d2 57 3f
w[3] = 49 f5 42 0d

Βάση του i mod Nk = 0 (για i=4 και Nk=4) το w[3] τίθεται σαν temp και εφαρμόζονται σε
αυτό οι υπόλοιπες συναρτήσεις. Έτσι έχουμε:

RotWord(temp) = f5 42 0d 49
SubWord(temp) = e6 2c d7 3b // μπορούμε να το ελέγξουμε και από το πίνακα SBox
temp ⊕ RCon = e7 2c d7 3b // το RCon στο πρώτο γύρο είναι 01

Στη συνέχεια εφαρμόζεται η πράξη w[i] = w[i-Nk] xor temp οπότε για i=4 έχουμε w[4] =
w[0] xor temp και το i αυξάνεται κατά ένα. Συνεπώς:

w[4] = d7 5c 40 21

76
Πλέον η συνθήκη του i mod Nk = 0 (για i=5 και Nk=4) δεν ισχύει οπότε το temp παίρνει
την τιμή w[4] και βάση της w[i] = w[i-Nk] xor temp για i=5 έχουμε w[5] = w[1] xor temp .
Δηλαδή:

w[5] = 60 92 05 27

Παρόμοια υπολογίζονται και τα w[6] και w[7] ώσπου για i=8 ισχύει πάλι η συνθήκη i
mod Nk = 0 και τίθεται σαν temp το w[7] με τις συναρτήσεις RotWord()και SubWord()
να εφαρμόζονται πάνω του και τη διαδικασία να συνεχίζεται μέχρι το w[43] καθώς ο
βρόγχος επαναλαμβάνεται για i < Nb x (Nr +1) με Nr=10 και Nb=4.

Συνοπτικά τα επιμέρους κλειδιά είναι:

w[4] = d7 5c 40 21 w[8] = 00 96 19 66 w[12] = a5 ce 30 c3

w[5] = 60 92 05 27 w[9] = 60 04 1c 41 w[13] = c5 ca 2c 82
w[6] = 5f 40 52 18 w[10] = 3f 44 4e 59 w[14] = fa 8e 62 db
w[7] = 16 b5 10 15 w[11] = 29 f1 5e 4c w[15] = d3 7f 3c 97

w[16] = 7f 25 b8 a5 w[20] = 1d 51 c7 79 w[24] = 45 f9 1a eb

w[17] = ba ef 94 27 w[21] = a7 be 53 5e w[25] = e2 47 49 b5
w[18] = 40 61 f6 fc w[22] = e7 df a5 a2 w[26] = 05 98 ec 17
w[19] = 93 1e ca 6b w[23] = 74 c1 6f c9 w[27] = 71 59 83 de

w[28] = ce 15 07 48 w[32] = 92 e8 1f 22 w[36] = 98 5d 63 a8

w[29] = 2c 52 4e fd w[33] = be ba 51 df w[37] = 26 e7 32 77
w[30] = 29 ca a2 ea w[34] = 97 70 f3 35 w[38] = b1 97 c1 42
w[31] = 58 93 21 34 w[35] = cf e3 d2 01 w[39] = 7e 74 13 43

w[40] = 3c 20 79 5b
w[41] = 1a c7 4b 2c
w[42] = ab 50 8a 6e
w[43] = d5 24 99 2d

3. Γύρος 0: Η αρχική κατάσταση s προκύπτει από το XOR του αρχικού κειμένου

και του αρχικού κλειδιού.

00 04 08 30 30 b7 3f 49 30 b3 37 79
01 05 09 40 70 ce d2 f5 71 cb db b5
s= � �⊕� �= � �
02 06 10 50 97 45 57 42 95 43 47 12
03 07 20 60 1a 06 3f 0d 19 01 1f 6d

4. Η νέα κατάσταση s προκύπτει από την εφαρμογή του μετασχηματισμού

SubBytes() στην προηγούμενη κατάσταση (σύμφωνα με τον Πίνακα 3. 3).

𝑆 (30)𝑆𝑅𝐷 (b3)𝑆𝑅𝐷 (37)𝑆𝑅𝐷 (79) 04 6d 9a b6

⎡ 𝑅𝐷 ⎤
𝑆 (71)𝑆𝑅𝐷 (cb)𝑆𝑅𝐷 (db)𝑆𝑅𝐷 (b5)
s=⎢ 𝑅𝐷 ⎥ = � a3 1f b9 d5�
𝑆
⎢ 𝑅𝐷 (95)𝑆 𝑅𝐷 (43)𝑆𝑅𝐷 (47)𝑆 𝑅𝐷 (12)⎥ 2a 1a a0 c9
⎣ 𝑆𝑅𝐷 (19)𝑆𝑅𝐷 (01)𝑆 𝑅𝐷 (1f)𝑆𝑅𝐷 (6d) ⎦ d4 7c c0 3c

77
 5. Η νέα κατάσταση προκύπτει από εφαρμογή του μετασχηματισμού
ShiftRows() στην προηγούμενη κατάσταση.

04 6d 9a b6
1f b9 d5 a3
s= � �
a0 c9 2a 1a
3c d4 7c c0

6. Η νέα κατάσταση προκύπτει από εφαρμογή του μετασχηματισμού

MixColumns() στην προηγούμενη κατάσταση.

02 03 01 01 04 6d 9a b6 b5 17 1d 53
01 02 03 01 1f b9 d5 a3 fd 90 29 05
s=� �⊗� �= � �
01 01 02 03 a0 c9 2a 1a 04 3a 9f 7a
03 01 01 02 3c d4 7c c0 cb 74 b2 e3

7. Η νέα κατάσταση προκύπτει από XOR μεταξύ της προηγούμενης

κατάστασης και του κλειδιού γύρου.

b5 17 1d 53 d7 60 5f 16 62 77 42 45
fd 90 29 05 5c 92 40 b5 a1 02 69 b0
s=� �⊕� �= � �
04 3a 9f 7a 40 05 52 10 44 3f cd 6a
cb 74 b2 e3 21 27 18 15 ea 53 aa f6

Τα βήματα 4 έως 7 απαρτίζουν την δομή όλων των ενδιαμέσων γύρων και στο
συγκεκριμένο παράδειγμα επαναλαμβάνονται άλλες 8 φορές. Ο 10ος και τελικός γύρος
του παραδείγματος περιλαμβάνει τα βήματα 4,5 και 7. Μετά το πέρας του τελικού
γύρου η κατάσταση μετατρέπεται από πίνακα 4x4 σε διάνυσμα 16 bytes και αποτελεί,
πλέον, το κρυπτοκείμενο.

Συνοπτικά τα αποτελέσματα της κατάστασης κάθε γύρου είναι:

Αρχή Γύρου Μετά από Μετά από Μετά από Κλειδί γύρου
SubBytes ShiftRows MixColumns
00 04 08 30 30 b7 3f 49
01 05 09 40 70 ce d2 f5
02 06 10 50 97 45 57 42
03 07 20 60 1a 06 3f 0d
30 b3 37 79 04 6d 9a b6 04 6d 9a b6 b5 17 1d 53 d7 60 5f 16
71 cb db b5 a3 1f b9 d5 1f b9 d5 a3 fd 90 29 05 5c 92 40 b5
95 43 47 12 2a 1a a0 c9 a0 c9 2a 1a 04 3a 9f 7a 40 05 52 10
19 01 1f 6d d4 7c c0 3c 3c d4 7c c0 cb 74 b2 e3 21 27 18 15
62 77 42 45 aa f5 2c 6e aa f5 2c 6e 29 64 9c 53 00 60 3f 29
a1 02 69 b0 32 77 f9 e7 77 f9 e7 32 da 9d 39 39 96 04 44 f1
44 3f cd 6a 1b 75 bd 02 87 bd 02 1b 75 7a 9a d1 59 19 1c 4e 5e
ea 53 aa f6 ed ac 42 42 87 ed ac ab ea 49 b6 66 41 59 4c
29 04 a3 7a a5 f2 0a da a5 f2 0a da 8e 9d ae 5a a5 c5 fa d3
4c 99 7d c8 29 ee ff e8 ee ff e8 29 39 fe b5 8e ce ca 8e 7f
63 86 9f 07 fb 44 db c5 db c5 fb 44 91 40 a9 3e 30 2c 62 3c
cd ab 10 fa bd 62 ca 2d 2d bd 62 ca 9b 56 c9 97 c3 82 db 97

78
Αρχή Γύρου Μετά από Μετά από Μετά από Κλειδί γύρου
SubBytes ShiftRows MixColumns
2b 58 54 89 f1 6a 20 a7 f1 6a 20 a7 ad f4 c2 74 7f ba 40 93
f7 34 3b f1 68 18 e2 a1 18 e2 a1 68 83 46 67 4e 25 ef 61 1e
a1 6c cb 02 32 50 1f 77 1f 77 32 50 72 d8 3d 2f b8 94 f6 ca
58 d4 12 00 6a 48 c9 63 63 6a 48 c9 c9 ff 63 43 a5 27 fc 6b
d2 4e 82 e7 b5 2f 13 94 b5 2f 13 94 34 66 c6 ad 1d a7 e7 74
a6 a9 06 50 24 d3 6f 53 d3 6f 53 24 1d d1 48 7c 51 be df c1
ca 4c cb e5 74 29 1f d9 1f d9 74 29 04 19 0b 94 c7 53 a5 6f
6c d8 9f 28 50 61 db 34 34 50 61 db 60 67 d0 07 79 5e a2 c9
29 c1 21 d9 a5 78 fd 35 a5 78 fd 35 dd a8 53 87 45 e2 05 71
4c 6f 97 bd 29 a8 88 7a a8 88 7a 29 52 b6 69 46 f9 47 98 59
c3 4a ae fb 2e d6 e4 0f e4 0f 2e d6 58 89 ed 6b 1a 49 ec 83
19 39 72 ce d4 12 40 8b 8b d4 12 40 b5 bc 6c 20 eb b5 17 de
98 4a 56 f6 46 d6 b1 42 46 d6 b1 42 b3 8c 0f b9 ce 2c 29 58
ab f1 f1 1f 62 a1 a1 c0 a1 a1 c0 62 20 61 5f 72 15 52 ca 93
42 c0 01 e8 2c ba 7c 9b 7c 9b 2c ba c9 b2 2a 2c 07 4e a2 21
5e 09 7b fe 58 01 21 bb bb 58 01 21 7a eb 26 5c 48 fd ea 34
7d a0 26 e1 ff e0 f7 f8 ff e0 f7 f8 3a 51 2a b1 92 be 97 cf
35 33 95 e1 96 c3 2a f8 c3 2a f8 96 70 f5 dd 4f e8 ba 70 e3
ce fc 88 0d 8b b0 c4 d7 c4 d7 8b b0 60 1a cb c8 1f 51 f3 d2
32 16 cc 68 23 47 4b 45 45 23 47 4b 97 80 ff a3 22 df 35 01
a8 ef bd 7e c2 df 7a f3 c2 df 7a f3 35 76 41 f0 98 26 b1 7e
98 4f ad ac 46 84 95 91 84 95 91 46 e2 c6 e1 c5 5d e7 97 74
7f 4b 38 1a d2 b3 07 a2 07 a2 d2 b3 06 71 1e 54 63 32 c1 13
b5 5f ca a2 d5 cf 74 3a 3a d5 cf 74 aa fc 48 13 a8 77 42 43
ad 50 f0 8e 95 53 8c 19 95 53 8c 19 3c 1a ab d5
bf 21 76 b1 08 fd 38 c8 fd 38 c8 08 20 c7 50 24
65 43 df 47 4d 1a 9e a0 9e a0 4d 1a 79 4b 8a 99
02 8b 0a 50 77 3d 67 53 53 77 3d 67 5d 2c 6e 2d
a9 49 27 cc
dd ff 98 2c
e7 eb c7 83
08 5b 53 4a

Πίνακας 3. 7 Παράδειγμα κρυπτογράφησης.

Με το s = [a9 49 27 cc dd ff 98 2c e7 eb c7 83 08 5b 53 4a] να αποτελεί το

κρυπτοκείμενο.

Αντίστοιχα για την αποκρυπτογράφηση των δεδομένων τα αποτελέσματα είναι:

Αρχή Γύρου Μετά από Μετά από Μετά από Κλειδί γύρου
InvMixColumns InvShiftRows InvSubBytes
a9 49 27 cc 3c 1a ab d5
dd ff 98 2c 20 c7 50 24
e7 eb c7 83 79 4b 8a 99
08 5b 53 4a 5b 2c 6e 2d
95 53 8c 19 95 53 8c 19 ad 50 f0 8e 98 26 b1 7e
fd 38 c8 08 08 fd 38 c8 bf 21 76 b1 5d e7 97 74
9e a0 4d 1a 4d 1a 9e a0 65 43 df 47 63 32 c1 13
53 77 3d 67 77 3d 67 53 02 8b 0a 50 a8 77 42 43

79
Αρχή Γύρου Μετά από Μετά από Μετά από Κλειδί γύρου
InvMixColumns InvShiftRows InvSubBytes
35 76 41 f0 c2 df 7a f3 c2 df 7a f3 a8 ef bd 7e 92 be 97 cf
e2 c6 e1 c5 84 95 91 46 46 84 95 91 98 4f ad ac e8 ba 70 e3
06 71 1e 54 07 a2 d2 b3 d2 b3 07 a2 7f 4b 38 1a 1f 51 f3 d2
aa fc 48 13 3a d5 cf 74 d5 cf 74 3a b5 5f ca a2 22 df 35 01
3a 51 2a b1 ff e0 f7 f8 ff e0 f7 f8 7d a0 26 e1 ce 2c 29 58
70 f5 dd 4f c3 2a f8 96 96 c3 2a f8 35 33 95 e1 15 52 ca 93
60 1a cb c8 c4 d7 8b b0 8b b0 c4 d7 ce fc 88 0d 07 4e a2 21
97 80 ff a3 45 23 47 4b 23 47 4b 45 32 16 cc 68 48 fd ea 34
b3 8c 0f b9 46 d6 b1 42 46 d6 b1 42 98 4a 56 f6 45 e2 05 71
20 61 5f 72 a1 a1 c0 62 62 a1 a1 c0 ab f1 f1 1f f9 47 98 59
c9 b2 2a 2c 7c 9b 2c ba 2c ba 7c 9b 42 c0 01 e8 1a 49 ec 83
7a eb 26 5c bb 58 01 21 58 01 21 bb 5e 09 7b fe eb b5 17 de
dd a8 53 87 a5 78 fd 35 a5 78 fd 35 29 c1 21 d9 1d a7 e7 74
52 b6 69 46 a8 80 7a 29 29 a8 88 7a 4c 6f 97 bd 51 be df c1
58 89 ed 6b e4 0f 2e d6 2e d6 e4 0f c3 4a ae fb c7 53 a5 6f
b5 bc 6c 20 8b d4 12 40 d4 12 40 8b 19 39 72 ce 79 5e a2 c9
34 66 c6 ad b5 2f 13 94 b5 2f 13 94 d2 4e 82 e7 7f ba 40 93
1d d1 48 7c d3 6f 53 24 24 d3 6f 53 a6 a9 06 50 25 ef 61 1e
04 19 0b 94 1f d9 74 29 74 29 1f d9 ca 4c cb e5 b8 94 f6 ca
6067 d0 07 34 50 61 db 50 61 db 34 6c d8 9f 28 a5 27 fc 6b
ad f4 c2 74 f1 6a 20 a7 f1 6a 20 a7 2b 58 54 89 a5 c5 fa d3
83 46 67 4e 18 e2 a1 68 68 18 e2 a1 f7 34 3b f1 ce ca 8e 7f
72 d8 3d 2f 1f 77 32 50 32 50 1f 77 a1 6c cb 02 30 2c 62 3c
c9 ff 63 43 63 6a 48 c9 6a 48 c9 63 58 d4 12 00 c3 82 db 97
8e 9d ae 5a a5 f2 0a da a5 f2 0a da 29 04 a3 7a 00 60 3f 29
39 fe b5 8e ee ff e8 29 29 ee ff e8 4c 99 7d c8 96 04 44 f1
91 40 a9 3e db c5 fb 44 fb 44 db c5 63 86 9f 07 19 1c 4e 5e
9b 56 c9 97 2d bd 62 ca bd 62 ca 2d cd ab 10 fa 66 41 59 4c
29 64 9c 53 aa f5 2c 6e aa f5 2c 6e 62 77 42 45 d7 60 5f 16
da 9d 39 39 77 f9 e7 32 32 77 f9 e7 a1 02 69 b0 5c 92 40 b5
7a 9a d1 59 bd 02 1b 75 1b 75 bd 02 44 3f cd 6a 40 05 52 10
ab ea 49 b6 42 87 ed ac 87 ed ac 42 ea 53 aa f6 21 27 18 15
b5 17 1d 53 04 6d 9a b6 04 6d 9a b6 30 b3 37 79 30 b7 3f 49
fd 90 29 05 1f b9 d5 a3 a3 1f b9 d5 71 cb db b5 70 ce d2 f5
04 3a 9f 7a a0 c9 2a 1a 2a 1a a0 c9 95 43 47 12 97 45 57 42
cb 74 b2 e3 3c d4 7c c0 d4 7c c0 3c 19 01 1f 6d 1a 06 3f 0d
00 04 08 30
01 05 09 40
02 06 10 50
03 07 20 60

Πίνακας 3. 8 Παράδειγμα αποκρυπτογράφησης.

Με το s = [00 01 02 03 04 05 06 07 08 09 10 20 30 40 50 60] να αποτελεί το αρχικό

μήνυμα που είχαμε εισάγει.

80
3.9 Ασφάλεια AES

Σαν κρυπτογραφικό πρότυπο ο AES, θα πρέπει να είναι ανθεκτικός σε όλες τις γνωστές
κρυπταναλυτικές επιθέσεις. Για το λόγο αυτό, σχεδιάστηκε να είναι ανθεκτικός σε
αυτές και ιδιαίτερα στη διαφορική και γραμμική κρυπτανάλυση. Οι αλγόριθμοι
τμήματος γενικά, για να διασφαλίσουν αυτό το επίπεδο ασφάλειας θα πρέπει να έχουν
διάχυση και μη-γραμμικότητα.

Η διάχυση καθορίζεται από την εξάπλωση των bits στο κρυπτογράφημα. Πλήρης
διάχυση σημαίνει ότι κάθε bit της κατάστασης εξαρτάται από όλα τα bits της
προηγούμενης κατάστασης. Στον AES, σε δυο διαδοχικούς γύρους παρέχεται πλήρη
διάχυση μέσω των μετασχηματισμών ShiftRows και MixColumns. Οι δύο αυτοί
μετασχηματισμοί σε συνδυασμό με την επέκταση κλειδιού παρέχουν την απαραίτητη
διάχυση στο κρυπτογράφημα ώστε να είναι ανθεκτικό στις γνωστές επιθέσεις.

Η μη-γραμμικότητα προσδίδεται στον αλγόριθμο με τα κουτιά αντικατάστασης SBox,

που χρησιμοποιούνται στον μετασχηματισμό SubBytes και στην επέκταση του κλειδιού.
Συγκεκριμένα, η μη-γραμμικότητα προέρχεται από την αντιστροφή σε ένα
πεπερασμένο πεδίο.

Η μη-γραμμικότητα αυξάνει την αντίσταση του κρυπτογραφήματος σε

κρυπταναλυτικές επιθέσεις. Στην επέκταση κλειδιού η μη-γραμμικότητα το καθιστά
ανθεκτικό έτσι ώστε ακόμα και αν είναι γνωστό ένα τμήμα του κλειδιού
κρυπτογράφησης ή ένα κλειδί γύρου δεν είναι εύκολο να υπολογιστούν τα υπόλοιπα
κλειδιά γύρου.

Η αξιοπιστία μιας κρυπτογράφησης μπορεί να δημιουργηθεί μέσω της απλότητας με

τον ακόλουθο τρόπο. Η χρήση απλών βημάτων κάνει τους ανθρώπους να πιστεύουν ότι
είναι πιο εύκολο να σπάσουν ένα κρυπτογράφημα και έτσι θα επιχειρήσουν να το
πράξουν. Όταν όμως πολλές προσπάθειες αποτυγχάνουν, το αποτέλεσμα είναι ο
αλγόριθμος να γίνεται ολοένα και περισσότερο έμπιστος.

Παρόλο που η επαναληψιμότητα έχει πολλά οφέλη, μπορεί να κάνει έναν αλγόριθμο πιο
ευάλωτο σε συγκεκριμένες επιθέσεις. Ο σχεδιασμός του AES εξασφαλίζει ότι η
επανάληψη δεν θα οδηγήσει σε κενά ασφαλείας. Για παράδειγμα, οι σταθερές γύρου
διαχωρίζουν τα μοτίβα μεταξύ των κλειδιών γύρου [25].

3.10 Εφαρμογές

Η ασφάλεια ενός κρυπτογραφικού αλγορίθμου βασίζεται πάνω σε δύο κριτήρια, στην

ασφάλεια και στην αποδοτικότητα. Οι Rijmen και Deamen σχεδίασαν τον AES με βάση
αυτά τα κριτήρια και επιπλέον πρόσθεσαν στον αλγόριθμο απλότητα και
επαναληπτικότητα.

Ο AES είναι κατάλληλος για διάφορες εφαρμογές, όπως για την ασφάλεια
δρομολογητών δικτύου, ασύρματες επικοινωνίες, αποθήκευση κρυπτογραφημένων
δεδομένων, Smart Cards, ασφαλή συστήματα βιντεοεπιτήρησης, ασφαλή ταυτοποίηση
μέσω ραδιοσυχνοτήτων (Radio Frequency Identification RFID), ΑΤΜ, οικονομικές
συναλλαγές ηλεκτρονικού εμπορίου και πληθώρα άλλων εφαρμογών.

81
Καθώς ο αλγόριθμος είναι ελεύθερος, μπορεί να χρησιμοποιηθεί για εμπορικούς και μη
σκοπούς καθώς και για ιδιωτική και δημόσια χρήση. Σε επίπεδο λογισμικού υπάρχουν
πολλές έτοιμες βιβλιοθήκες σε διάφορες γλώσσες προγραμματισμού. Ενδεικτικά
υπάρχουν βιβλιοθήκες σε C/ASM (AES Crypt, OpenSSL, GnuTLS, mcrypt Microsoft
CryptoAPI κ.α.), C++ (Botan, Crypto++), C#/.NET (.NET Framework 3.5 Bouncy Castle
Crypto Library), Java (Java Cryptography Extension, IAIK, Bouncy Castle Crypto Library),
Javascript (Implementation for JavaScript, Stanford Javascript Crypto Library), PHP
(phpseclib), Python (Python AES, NCrypt, alo-aes, pycrypt κ.α.) Flex/AS3 (as3crypto). Οι
παραπάνω βιβλιοθήκες χρησιμοποιούνται σε πολλές εφαρμογές όπως σε εργαλεία
αρχείων και συμπίεσης (7z, PKZIP, RAR, WinZip κ.α.), λειτουργικά συστήματα
(Encrypting File System στα Windows XP SP1), κρυπτογράφηση δίσκων (DiskCryptor,
BitLocker, Geli, Crypt4000 κ.α.), κρυπτογράφηση αρχείων (gKrypt, NCrypt AES Crypt
κ.α.), ασφάλεια επικοινωνίας σε τοπικά δίκτυα (IEEE 802. 11i, ITU-T G.hn) και διάφορα
άλλες (GPG, IPsec, IronKey, XFire, CyaSSL κ.α.). Επίσης έχει αναπτυχθεί ένα ρεπερτόριο
εντολών επονομαζόμενο ως AES Instruction Set σαν επέκταση εντολών μιας x86
αρχιτεκτονικής για μικροεπεξεργαστές που χρησιμοποιείται από την Intel και την AMD
[27].

Από όλα τα παραπάνω συμπεραίνουμε πως ο AES είναι ένας από τους πιο
καταξιωμένους αλγόριθμους κρυπτογράφησης. Ο σχεδιασμός, η ταχύτητα και η
αποδοτικότητα του, έχουν συνδέσει τον AES με ποικίλες εφαρμογές καταρτώντας τον
αναπόσπαστο κομμάτι της κρυπτογραφίας.

82
 4.Υλοποιήσεις AES

4.1 Κρυπτογραφία και λογισμικό ή υλικό

Η κρυπτογραφία μπορεί να υλοποιηθεί τόσο σε υλικό όσο και σε λογισμικό. Συνήθως τα

κριτήρια επιλογής της εκάστοτε τεχνολογίας που θα χρησιμοποιηθεί είναι η επιθυμητή
ταχύτητα κρυπτογράφησης/αποκρυπτογράφησης και το κόστος υλοποίησης.

Οι υλοποιήσεις λογισμικού σχεδιάζονται και κωδικοποιούνται σε διάφορες γλώσσες

προγραμματισμού και αναπτύσσονται με τέτοιο τρόπο ώστε να είναι εκτελέσιμες σε
επεξεργαστές γενικού σκοπού, επεξεργαστές ψηφιακού σήματος (DSPs), και smart
cards. Συνήθως, οι υλοποιήσεις σε λογισμικό είναι πολύ οικονομικές. Στις περισσότερες
περιπτώσεις οι κρυπτογραφικοί μετασχηματισμοί συμβαδίζουν με την αρχιτεκτονική
των σύγχρονων μικροεπεξεργαστών και έτσι ακόμα και προγραμματιστές που δεν είναι
έμπειροι μπορούν να παράγουν σωστές υλοποιήσεις.

Οι επεξεργαστές γενικού σκοπού παρέχουν μεγάλη ισχύ για την ικανοποίηση των
αναγκών των χρηστών, με αποτέλεσμα η πλειοψηφία των κρυπτογραφικών
εφαρμογών να υλοποιείται σε επίπεδο λογισμικού. Ωστόσο οι υλοποιήσεις υλικού είναι
ο μόνος τρόπος για την επίτευξη υψηλής ταχύτητας, πολύ μεγαλύτερης των
επεξεργαστών γενικού σκοπού.

Οι υλοποιήσεις υλικού σχεδιάζονται και κωδικοποιούνται είτε σε περιγραφικές

γλώσσες υλικού, όπως VHDL και Verilog, είτε με σχηματική περιγραφή του
κυκλώματος. Υλοποιούνται με δύο κύριες προσεγγίσεις: είτε με ειδικά ολοκληρωμένα
κυκλώματα (ASICs), είτε με κυκλώματα προγραμματιζόμενων πυλών (FPGAs).

Τα ASICs σχεδιάζονται με την περιγραφή της συμπεριφοράς στη φυσική διάταξη και το
σχέδιο απαιτεί πολύ χρόνο και ανθρώπινο δυναμικό. Η τελική διάταξη στέλνεται σε ένα
εργοστάσιο παραγωγής ανεβάζοντας το κόστος ακόμα πιο πολύ. Επιπλέον, κάθε
σφάλμα στο σχεδιασμό έχει μεγάλο αντίκτυπο στο σχεδιαστικό κύκλο και στο κόστος.
Για τους λόγους αυτούς οι σχεδιαστές χρειάζονταν οικονομικές συσκευές ταχείας
προτοτυποποίησης και η ιδέα αυτή οδήγησε στα FPGAs.

Τα FPGAs παρέχουν πολλά μοναδικά χαρακτηριστικά. Είναι οικονομικά και μπορούν να

επαναπρογραμματιστούν και να εκτελέσουν διάφορες λειτουργίες και κάθε
επαναπρογραμματισμός είναι πολύ σύντομος. Ένα FPGA αποτελείται από χιλιάδες
μπλοκ (Configurable Logic Blocks CLBs), όπου όχι μόνο η λογική, αλλά επίσης και η
διασύνδεση είναι προγραμματιζόμενη από το χρήστη.

Παρόλο που τα FPGAs αρχικά σχεδιάστηκαν να υποστηρίζουν την ανάπτυξη ASICs

σχεδίων, χρησιμοποιήθηκαν ως κύριες συσκευές σε διάφορες εφαρμογές. Επίσης, λόγω
της ικανότητας του επαναπρογραμματισμού, μπορούν να υλοποιηθούν πολύ
εξειδικευμένα κυκλώματα. Τα ASICs όμως είναι πολύ πιο γρήγορα από τα αντίστοιχα
FPGAs παρόλο που και τα δύο παράγονται υπό την ίδια τεχνολογία. Ωστόσο η

83
δυνατότητα επαναπρογραμμάτισης μπορεί να αποτελέσει ένα σημαντικό
χαρακτηριστικό του σχεδίου. Στην κρυπτογραφία, είναι συχνά χρήσιμη η εναλλαγή
μεταξύ κρυπτογραφικών αλγορίθμων και η παραμετροποίηση ενός FPGA μπορεί να
επιτύχει κάτι τέτοιο. Επιπλέον, η διόρθωση σφαλμάτων ή η αναβάθμιση ενός
υπάρχοντος προϊόντος είναι τόσο εύκολη όσο και η αναβάθμιση μιας υλοποίησης
λογισμικού.

Το κόστος ενός σχεδίου που βασίζεται σε τεχνολογία των FPGA είναι πολύ μικρότερο
από αυτό σε τεχνολογία ASIC. Οι ίδιοι οι σχεδιαστές μπορούν να προγραμματίσουν ένα
FPGA και συνεπώς απαιτείται μικρότερο ανθρώπινο δυναμικό για την ανάπτυξη ενός
σχεδίου. Παρόλα αυτά η υλοποίηση σε FPGA είναι πιο ακριβή από την υλοποίηση σε
λογισμικό.

Ένας σημαντικός παράγοντας σε κάθε κρυπτογραφική υλοποίηση είναι το επίπεδο

ασφάλειας της εφαρμογής. Παρόλο που οι υλοποιήσεις σε επίπεδο λογισμικού είναι οι
πιο κοινές, παρέχουν το χαμηλότερο επίπεδο ασφάλειας. Η διασφάλιση της μη διαρροής
πληροφοριών είναι εξαιρετικά δύσκολη. Για παράδειγμα, μια μορφή επίθεσης σε
λογισμικό μπορεί να χρησιμοποιεί μικρά προγράμματα, σαν ιούς, για τη συλλογή και
αποστολή πληροφοριών στον επιτιθέμενο.

Οι υλοποιήσεις σε υλικό είναι πολύ πιο εύκολο να προστατευθούν. Είναι σχετικά εύκολα
να σχεδιαστούν κυκλώματα που θα διασφαλίζουν ότι καμία επίθεση δεν είναι δυνατή,
εκτός και αν υπάρχει φυσική πρόσβαση στη συσκευή. Ένας από τους τρόπους επίθεσης
σε μια υλοποίηση υλικού είναι η αντικατάσταση του κρυπτογραφικού τσιπ με κάποιο
άλλο που θα εκτελεί την ίδια διεργασία με το αρχικό τσιπ αλλά παράλληλα θα διαρρέει
πληροφορίες και στον επιτιθέμενο.

Τα σχέδια σε FPGAs δεν παρέχουν μεγάλη προστασία ενάντια σε φυσικές επιθέσεις. Δεν
είναι πολύ δύσκολο να αναγνωρισθούν οι μηχανισμοί ασφαλείας μέσω του bitstream
παραμετροποίησης και να τροποποιηθούν αναλόγως. Επιπλέον οι συσκευές FPGA είναι
εξοπλισμένες με μια λειτουργία που επιτρέπει την ανάγνωση των περιεχομένων των
καταχωρητών και της μνήμης η οποία βοηθάει στην απασφαλμάτωση. Έτσι τίθενται σε
κίνδυνο ευαίσθητες πληροφορίες όπως το κλειδί κρυπτογράφησης.

Η προστασία των σχεδίων ASIC είναι κατά κάποιο τρόπο πιο εύκολη. Το ASIC μπορεί να
σχεδιαστεί ώστε να είναι ανθεκτικό, δηλαδή το τσιπ δεν επιτρέπει διαρροή
πληροφορίας υπό καμία μορφή πίεσης. Κάποιες από τις πιθανές επιθέσεις μπορεί να
βασίζονται σε ανάλυση κατανάλωσης ισχύος ή λανθασμένη εισαγωγή. Επιπλέον, μπορεί
να έχει υλοποιημένο έναν πολύ ισχυρό μηχανισμό αυθεντικοποίησης καθιστώντας την
αντικατάσταση του τσιπ δύσκολη.

Κάθε τύπος υλοποίησης έχει τα πλεονεκτήματα και τα μειονεκτήματα του, τα βασικά

χαρακτηριστικά τους συνοψίζονται στον Πίνακα 4. 1. Οι υλοποιήσεις λογισμικού
αποτελούν μια ενδιαφέρουσα επιλογή όταν η ταχύτητα κρυπτογράφησης δεν μας
απασχολεί πολύ και το αναμενόμενο ασφάλειας δεν χρειάζεται να είναι πολύ υψηλό.
Συνεπώς η προστατευόμενη πληροφορία είναι χαμηλής αξίας συγκρινόμενη με την
προσπάθεια που απαιτείται για να σπάσουν οι μηχανισμοί ασφαλείας. Όσο πιο
ασφαλείς και γρήγορες λύσεις απαιτούνται τόσο πιο ζωτικής σημασίας είναι οι
υλοποιήσεις υλικού. Όταν λαμβάνονται υπόψη λύσεις υλικού τα FPGAs γίνονται όλο και
περισσότερο ελκυστικά. Αν υποτεθεί ότι ένας επιτιθέμενος δεν έχει φυσική πρόσβαση
στη συσκευή τότε τα FPGAs μπορούν να είναι τόσο ασφαλή όσο τα ASICs [28].

84
 ASICs FPGAs Λογισμικό
Ταχύτητα Πολύ γρήγορο Γρήγορο Μέτρια Γρήγορο
Διαδικασία Ανάπτυξης
Κόστος Σχεδιασμού Πολύ ακριβό Μέτρια ακριβό Οικονομικό
Χρόνος Σχεδιασμού Μεγάλος Μέτρια μεγάλος Μικρός
Εργαλεία Πολύ ακριβά Οικονομικά Οικονομικά
Σχεδιασμού
Συντήρηση και Ακριβά Οικονομικά Οικονομικά
Αναβάθμιση
Κρυπτογραφικά Θέματα
Αντίσταση Ισχυρή Περιορισμένη Αδύναμη
Παραποίησης
Προστασία Κλειδιού Ισχυρή Περιορισμένη Αδύναμη
Ευελιξία Αλγορίθμου Όχι Ναι Ναι

Πίνακας 4. 1 Χαρακτηριστικά υλοποιήσεων κρυπτογραφικών μετασχηματισμών σε ASICs,

FPGAs και λογισμικό.

4.2 Υλοποίηση σε Λογισμικό

Η ανάπτυξη του λογισμικού υλοποιήσεως του AES έγινε με το προγραμματιστικό

πακέτο Microsoft Visual Studio 2010 σε γλώσσα προγραμματισμού C++. Η υλοποίηση
στην εφαρμογή AES.exe περιλαμβάνει δύο αρχεία:

1. Αρχείο Sboxes.cpp
Στο αρχείο αυτό υπάρχουν οι πίνακες αντικατάστασης για τους
μετασχηματισμούς SubBytes και InvSubBytes καθώς και ο πίνακας με τις
σταθερές γύρου RCon.

2. Αρχείο AES.cpp
Είναι το κύριο αρχείο του προγράμματος και περιέχει όλες τις απαραίτητες
συναρτήσεις για την εκτέλεση του AES και τη main() συνάρτηση του
προγράμματος.

4.2.1 Ανάλυση προγράμματος

Στο σημείο αυτό θα περιγράψουμε αναλυτικά τα δύο αρχεία, τις συναρτήσεις που
χρησιμοποιούνται και τη main() συνάρτηση του προγράμματος. Ο πλήρης κώδικας
βρίσκεται στο Παράρτημα Α [σελ.135].

Sboxes.cpp

Το αρχείο αυτό περιέχει τους πίνακες αντικατάστασης για τους μετασχηματισμούς

SubBytes και InvSubBytes και τον πίνακα με τις σταθερές γύρου RCon. Οι πίνακες
αυτοί είναι μονοδιάστατοι με 256 θέσεις για τους πίνακες SubBytes και InvSubBytes,
όσες δηλαδή και οι ανάλογες αντικαταστάσεις και 11 για τον RCon, όσες και οι
σταθερές γύρου.

85
AES.cpp

Το αρχείο αυτό περιλαμβάνει τη main() συνάρτηση του προγράμματος, τις συναρτήσεις

για την υλοποίηση του AES καθώς και συναρτήσεις για το χειρισμό των δεδομένων
εισόδου και εξόδου. Τα δεδομένα χειρίζονται υπό τη μορφή πινάκων, μονοδιάστατων
και δισδιάστατων ανάλογα με την περίπτωση, όπου κάθε θέση στον πίνακα αντιστοιχεί
σε ένα byte.

Η κύρια συνάρτηση που αποτελεί το κυρίως σώμα του αλγόριθμου είναι η συνάρτηση
Encryption, η οποία με τη σειρά της καλεί άλλες συναρτήσεις για την υλοποίηση των
ενδιάμεσων μετασχηματισμών. Πριν όμως δούμε την περιγραφή της συνάρτησης αυτής
θα δούμε πως πραγματοποιείται η επέκταση του κλειδιού και οι ενδιάμεσες
συναρτήσεις που το επιτυγχάνουν.

RotWord(): Συνάρτηση που δέχεται σαν είσοδο τέσσερα bytes, πραγματοποιεί κυκλική
ολίσθηση των δεδομένων και επιστρέφει τα μετατεθειμένα bytes.

SubWord(): Συνάρτηση που δέχεται σαν είσοδο τέσσερα bytes, κάθε byte γίνεται
είσοδος στον πίνακα αντικατάστασης Sbox (πίνακας που βρίσκεται στο αρχείο
Sboxes.cpp και πραγματοποιεί τον SubByte μετασχηματισμό) και αντικαθιστάται. Όταν
ολοκληρωθεί η διαδικασία και για τα τέσσερα byte επιστρέφονται τα
μετασχηματισμένα bytes.

KeyExpansion() : Συνάρτηση που δέχεται σαν είσοδο έναν πίνακα 4x8 bytes που
αποτελεί το αρχικό κλειδί. Ο λόγος που ο πίνακας είναι 4x8 είναι για να υποστηρίζεται η
επέκταση κλειδιού για 128 bits (16 bytes) 192 bits (24 bytes) και 256 bits (32 bytes).
Στη συνάρτηση αυτή υπάρχουν μεταβλητές (Nk, Nw) που καθορίζουν το πλήθος των
απαιτούμενων επαναλήψεων, ανάλογα με το μήκος του αρχικού κλειδιού για τη σωστή
υλοποίησή του. Έτσι μετά από κατάλληλο αριθμό επαναλήψεων προκύπτει ο πίνακας
extendedkey που περιέχει το επεκτεταμένο κλειδί. Παρακάτω παρουσιάζεται ο κώδικας
για την επέκταση του κλειδιού.

void KeyExpansion (unsigned char Key[4][8]){

extendedkey=new unsigned char *[4];
for (int i=0; i<4; i++)
extendedkey[i]=new unsigned char [Nw];
for (int i=0; i<4; ++i){
for (int j=0; j<Nk; ++j)
extendedkey[i][j]=Key[i][j]; }
for (int j = Nk; j < Nw; j++){
for (int i=0; i<4; ++i)
temp[i] = extendedkey[i][j-1];

if (j%Nk == 0){
RotWord(temp);
SubWord(temp) ;
temp [0]= temp[0] ^ RCon[j/Nk];
for (int i=0; i<4; ++i)
extendedkey[i][j]=extendedkey[i][j-Nk]^temp[i];}
else if (Nk==8 && j%Nk==4){
SubWord(temp) ;
for (int i=0; i<4; ++i)
extendedkey[i][j]=extendedkey[i][j-Nk]^temp[i];}
else
for (int i=0; i<4; ++i)
extendedkey[i][j]=extendedkey[i][j-Nk]^extendedkey[i][j-1];}}

86
Για την υλοποίηση της Encryption είναι απαραίτητες οι εξής συναρτήσεις:

SetRoundKey(): Δέχεται σαν είσοδο έναν ακέραιο που αντιπροσωπεύει το γύρο που
εκτελείται και επιστέφει έναν δισδιάστατο πίνακα 4x4 roundkey που περιέχει το κλειδί
γύρου.

SubBytes(): Συνάρτηση που δέχεται σαν είσοδο έναν πίνακα 4x4 που αποτελεί τον
πίνακα κατάστασης, όπου κάθε byte γίνεται είσοδος στον πίνακα αντικατάστασης Sbox
και αντικαθιστάται. Έτσι όταν ολοκληρωθεί η διαδικασία επιστρέφεται ο
μετασχηματισμένος πίνακας κατάστασης.

ShifRows(): Συνάρτηση που δέχεται σαν είσοδο έναν πίνακα 4x4 που αποτελεί τον πίνακα
κατάστασης και πραγματοποιεί σε κάθε γραμμή την κατάλληλη ολίσθηση. Με το τέλος
των επαναλήψεων, επιστρέφεται η νέα μετατοπισμένη κατάσταση.

multiply(): Συνάρτηση που είναι απαραίτητη για τον μετασχηματισμό MixColumns και
πραγματοποιεί τον πολλαπλασιασμό δύο bytes στο πεδίο GF(28) και επιστρέφει το
γινόμενο τους.

MixColumns(): Συνάρτηση που δέχεται σαν είσοδο τον πίνακα κατάστασης, εκτελεί τους
πολλαπλασιασμούς με το πολυώνυμο c(x) = “03”x3 + “01”x2 + “01”x + “02”, modulo (x4 + 1)
όπως περιγράφεται και στην ενότητα 3.5.3 και επιστρέφει τη μετασχηματισμένη
κατάσταση.

AddRoundKey(): Συνάρτηση που δέχεται σαν είσοδο τον πίνακα κατάστασης και το κλειδί
γύρου υπό μορφή πίνακα 4x4 και πραγματοποιεί την πράξη αποκλειστικής διάζευξης
(XOR).

Encryption(): Αποτελεί τον κύριο πυρήνα του προγράμματος καθώς αυτή είναι που
κρυπτογραφεί τα δεδομένα. Η Encryption δέχεται σαν είσοδο τα αρχικά δεδομένα υπό
μορφή πίνακα 4x4 και το κλειδί του κάθε γύρου επίσης σε πίνακα 4x4. Εκτελεί αρχικά την
AddRoundKey και έπειτα επαναλαμβάνει μέσω μιας for loop τους απαραίτητους
μετασχηματισμούς δίνοντας κάθε φορά στην έξοδο το αποτέλεσμα κάθε συνάρτησης. Το
πλήθος των επαναλήψεων εξαρτάται από την τιμή Nr που παίρνει τιμές 10,12 και 14
ανάλογα με τον αλγόριθμο που έχουμε επιλέξει (AES-128 έχει Nr 10, AES-192 έχει Nr 12,
AES-256 έχει Nr 14, ). Μετά το πέρας των επαναλήψεων εκτελείται ο τελευταίος γύρος
του αλγορίθμου όπου όπως έχουμε προαναφέρει δεν περιέχει τον μετασχηματισμό
MixColumns. Ο κώδικας για τη συνάρτηση κρυπτογράφησης παρουσιάζεται παρακάτω.

Για την αποκρυπτογράφηση των δεδομένων χρησιμοποιούνται συναρτήσεις για τους

αντίστροφους μετασχηματισμούς ανάλογες της κρυπτογράφησης. Συνοπτικά οι
συναρτήσεις είναι οι εξής:

InvSubBytes(): Συνάρτηση που δέχεται σαν είσοδο τον πίνακα κατάστασης, όπου κάθε
byte γίνεται είσοδος στον πίνακα αντικατάστασης InvSbox και αντικαθιστάται.

InvShifRows(): Συνάρτηση που δέχεται σαν είσοδο τον πίνακα κατάστασης και
πραγματοποιεί σε κάθε γραμμή την κατάλληλη ολίσθηση.

InvMixColumns(): Συνάρτηση που δέχεται σαν είσοδο τον πίνακα κατάστασης, εκτελεί
τους πολλαπλασιασμούς με το d(x)= “0B”x3 + “0D”x2 + “09”x + “0e”, modulo (x4 + 1) και
επιστρέφει τη μετασχηματισμένη κατάσταση.

87
void Encryption (unsigned char state[4][4],unsigned char rkey[4][4])
{
SetRoundKey(0);
cout<<"Round Key (0) : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round (0) : "; printmatrix (state);
for (int i=1; i<Nr; i++){
SubBytes(state);
cout<<"SubBytes ("<<i<<") : "; printmatrix (state);
ShiftRows(state);
cout<<"ShiftRows ("<<i<<") : "; printmatrix (state);
MixColumns(state);
cout<<"MixColumn ("<<i<<") : "; printmatrix (state);
SetRoundKey(i);
cout<<"Round Key ("<<i<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<i<<") : "; printmatrix (state);
}

SubBytes(state);
cout<<"SubBytes ("<<Nr<<") : "; printmatrix (state);
ShiftRows(state);
cout<<"ShiftRows ("<<Nr<<") : "; printmatrix (state);
SetRoundKey(Nr);
cout<<"Round Key ("<<Nr<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<Nr<<") : "; printmatrix (state);
}

Κώδικας για τη συνάρτηση κρυπτογράφησης.

Decryption(): Συνάρτηση που αποκρυπτογραφεί τα δεδομένα. Ακολουθεί τη δομή της

ευθείας αποκρυπτογράφησης επαναλαμβάνοντας για κάθε γύρο τους απαραίτητους
μετασχηματισμούς. Ο κώδικας για τη συνάρτηση αποκρυπτογράφησης παρουσιάζεται
παρακάτω.

Επιπλέον για το χειρισμό των δεδομένων και την εμφάνιση των αποτελεσμάτων
χρησιμοποιήθηκαν οι παρακάτω συναρτήσεις.

input_text(): Διαβάζει τα δεδομένα από το πληκτρολόγιο και τα αποθηκεύει σε πίνακα 16

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

input_key(): Διαβάζει τα δεδομένα από το πληκτρολόγιο και τα αποθηκεύει σε έναν

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

vec2mat_key(): Μετατρέπει τον πίνακα κλειδιού από μονοδιάστατο σε δισδιάστατο.

vec2mat(): Μετατρέπει τον πίνακα κατάστασης από μονοδιάστατο σε δισδιάστατο.

mat2vec(): Μετατρέπει έναν πίνακα από δισδιάστατο σε μονοδιάστατο.

Printmatrix(): Τυπώνει έναν πίνακα με γραμμές και στήλες.

88
void Decryption (unsigned char state[4][4],unsigned char rkey[4][4]){
SetRoundKey(Nr);
cout<<"Round Key ("<<Nr<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<Nr<<") : "; printmatrix (state);
InvShiftRows(state);
cout<<"InvSftRos ("<<Nr<<") : "; printmatrix (state);
InvSubBytes(state);
cout<<"InvSuBtes ("<<Nr<<") : "; printmatrix (state);

for (int i=Nr-1; i>0; i--){

SetRoundKey(i);
cout<<"Round Key ("<<i<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<i<<") : "; printmatrix (state);
InvMixColumns(state);
cout<<"InvMixCol ("<<i<<") : "; printmatrix (state);
InvShiftRows(state);
cout<<"InvSftRos ("<<i<<") : "; printmatrix (state);
InvSubBytes(state);
cout<<"InvSuBtes ("<<i<<") : "; printmatrix (state);
}
SetRoundKey(0);
cout<<"Round Key (0) : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round (0) : "; printmatrix (state);}

Κώδικας για τη συνάρτηση αποκρυπτογράφησης.

4.2.2 Παρουσίαση αποτελεσμάτων

Στο σημείο αυτό θα παρουσιάσουμε όλη τη διαδικασία κρυπτογράφησης και

αποκρυπτογράφησης μέσω των επιλογών της main() και την παρουσίαση ενός
παραδείγματος.

Αρχικά το πρόγραμμα μας ζητά να επιλέξουμε τον αλγόριθμο που θέλουμε να τρέξουμε
(Εικόνα 4. 1). Αν επιλέξουμε το 1 για AES-128 τότε θα δοθούν οι τιμές Nk=4, Nb=4 και
Nr=10 οι οποίες θα παραμετροποιήσουν τον αλγόριθμο. Αντίστοιχα στο 2 για AES-192 θα
δοθούν οι τιμές Nk=6, Nb=4 και Nr=12 και τέλος για AES-256 θα δοθούν οι τιμές Nk=8,
Nb=4 και Nr=14.

Για το παράδειγμα που πραγματοποιούμε επιλέγουμε τον αλγόριθμο AES-128. Στη

συνέχεια το πρόγραμμα μας ζητάει να εισάγουμε το κείμενο μας. Όταν το
πραγματοποιήσουμε και πατώντας enter μας ζητάει να εισάγουμε το κλειδί. Με τη
σωστή είσοδο του κλειδιού και πάλι πατώντας enter η διαδικασία κρυπτογράφησης
ξεκινάει εμφανίζοντας τα αρχικά δεδομένα και το κλειδί σε δεκαεξαδική μορφή καθώς
και όλα τα ενδιάμεσα βήματα. Στην Εικόνα 4. 2 φαίνεται η διαδικασία κρυπτογράφησης
για κείμενο εισόδου “hello!!!” και κλειδί “0123456789102030”. Μετά την ολοκλήρωση
της διαδικασίας κρυπτογράφησης τυπώνεται το κρυπτοκείμενο σε δεκαεξαδική μορφή
και έπειτα γίνεται η αντιστοίχηση των δεκαεξαδικών τιμών με τους ASCI χαρακτήρες.
Επίσης το πρόγραμμα μας ζητάει αν θέλουμε να πραγματοποιήσουμε την
αποκρυπτογράφηση των δεδομένων που μόλις πήραμε με το αρχικό κλειδί και εφόσον
την επιλέξουμε εκτελείται η διαδικασία της αποκρυπτογράφησης δίνοντας ως
αποτέλεσμα στο τέλος το αρχικό μας κείμενο (Εικόνα 4. 2).

89
Εικόνα 4. 1 Υλοποίηση σε λογισμικό. Έναρξη προγράμματος(αριστερά). Είσοδος δεδομένων
στο πρόγραμμα και μετατροπή στο δεκαεξαδικό σύστημα (δεξιά).

Εικόνα 4. 2 Κρυπτογράφηση και αποκρυπτογράφηση των δεδομένων.

90
4.3 Διαδικτυακή υλοποίηση

Στα πλαίσια της ερευνητικής εργασίας αναπτύχθηκε και μια διαδικτυακή υλοποίηση
του AES η οποία είναι επέκταση της υλοποίησης σε λογισμικό. Το εκτελέσιμο αρχείο
AES.exe τροποποιήθηκε κατάλληλα και προστέθηκαν σε αυτό και άλλοι αλγόριθμοι
κρυπτογράφησης (DES και TDES, από την εργασία “Συμμετρικοί Αλγόριθμοι
Κρυπτογράφησης Δεδομένων – Οι περιπτώσεις των αλγορίθμων DES και TDEA” της
Φλωκατούλας Δώρας) μετατράπηκε στο αρχείο crypto.cgi και αναρτήθηκε στον
ιστότοπο:

http://www.ellab.physics.upatras.gr/~bakalis/cgi-bin/Cryptography/cryptography.htm

Στην αρχική σελίδα παρουσιάζονται συνοπτικά οι βασικές πληροφορίες για τους τρεις
αλγορίθμους και δίνεται ο σύνδεσμος για τα πρότυπα υλοποίησης τους. Για την πιο
εύχρηστη εκτέλεση των αλγορίθμων έχουν προστεθεί οι παρακάτω επιλογές:

• Επιλογή ASCI ή HEX : Με την επιλογή αυτή ο χρήστης μπορεί να εισάγει τα

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

• Επιλογή Αλγορίθμου : Δίνεται η δυνατότητα στο χρήστη να κρυπτογραφήσει τα

δεδομένα του με τη χρήση πέντε διαφορετικών αλγορίθμων (DES, TDES, AES-128,
AES-192, AES-256). Επιλέγοντας λοιπόν το ανάλογο radio button ενεργοποιείται
και ο αντίστοιχος αλγόριθμος.

• Έλεγχος εισόδου : Τα δεδομένα εισάγονται στα πεδία Key και Message. Για τη
σωστή εισαγωγή των δεδομένων εκτελείται ένα αρχείο JavaScript το οποίο ελέγχει
κάθε φορά το μήκος των δεδομένων και του κλειδιού έτσι ώστε να μην
ξεπερνιέται ο επιτρεπτός αριθμός δεδομένων που χρειάζεται ο εκάστων
αλγόριθμος.

• Επιλογή λειτουργίας : Μόλις ο χρήστης ολοκληρώσει την είσοδο των δεδομένων

και την επιλογή του αλγορίθμου του δίνεται η δυνατότητα να εκτελέσει τρεις
διαφορετικές λειτουργίες Κρυπτογράφηση, Αποκρυπτογράφηση και εκτέλεση
μιας πλήρους λειτουργίας (Κρυπτογράφηση και Αποκρυπτογράφηση.

Στην Εικόνα 4. 3 παρουσιάζεται η αρχική ιστοσελίδα της διαδικτυακής υλοποίησης. Ο

τρόπος λειτουργίας της είναι ο εξής: Μόλις εισαχθούν τα δεδομένα και επιλεγεί η
λειτουργία δημιουργείται ένα string που περιλαμβάνει τη μέθοδο εισόδου, το κλειδί, το
κείμενο, τον αλγόριθμο και τη λειτουργία που θα εκτελεστεί και με τη μέθοδο post
γίνεται εισαγωγή στο εκτελέσιμο αρχείο crypto.cgi. Το πρόγραμμα χωρίζει αυτό το
string και ανάλογα με τις επιλογές που έχουν γίνει, εκτελεί τις κατάλληλες εργασίες.
Μόλις η διαδικασία ολοκληρωθεί οι έξοδοι που δίνονται από το πρόγραμμα είναι
κατάλληλα γραμμένες έτσι ώστε ο Browser να τις αναγνωρίσει και να τις μεταγλωττίσει
σε html μορφή. Έτσι σαν αποτέλεσμα παίρνουμε έναν πίνακα με τις επιλογές που
έχουμε κάνει μέσω του string. Και ένα textbox με όλα τα ενδιάμεσα βήματα που
εκτελέστηκαν για την κρυπτογράφηση των δεδομένων.

91
 Εικόνα 4. 3 Διαδικτυακή υλοποίηση.

Στο σημείο αυτό θα παραθέσουμε ένα παράδειγμα για την καλύτερη κατανόηση της
διαδικτυακής υλοποίησης. Έστω ότι επιλέγουμε σαν μέθοδο εισόδου την ASCI επιλογή,
σαν κλειδί το “0123456789102030” και σαν κείμενο το «hello!!!”. Για το παράδειγμά μας
θα χρησιμοποιήσουμε τον αλγόριθμο AES-128 και θα επιλέξουμε από το πρόγραμμα να
εκτελέσει μια πλήρη λειτουργία (κρυπτογράφηση και αποκρυπτογράφηση). Σύμφωνα
με αυτές τις επιλογές η αρχική σελίδα θα πρέπει να είναι όπως και στην Εικόνα 4. 4.

Εικόνα 4. 4 Παράδειγμα διαδικτυακής υλοποίησης.

92
Το αποτέλεσμα που παίρνουμε είναι αρχικά ένας πίνακας που έχει τις επιλογές μας,
δηλαδή μέθοδο εισόδου ASCII, αλγόριθμος AES-128, λειτουργία πλήρη, κλειδί
“0123456789102030” κείμενο “hello!!!” και ένα textbox με τα ενδιάμεσα βήματα. Στην
Εικόνα 4. 5 παρουσιάζεται το τελικό αποτέλεσμα και στην Εικόνα 4. 6 τα περιεχόμενα
του textbox για την επιβεβαίωση της ορθής λειτουργίας.

Εικόνα 4. 5 Αποτελέσματα παραδείγματος διαδικτυακής υλοποίησης.

93
Εικόνα 4. 6 Αποτελέσματα διαδικτυακής υλοποίησης.

94
4.4 VHDL υλοποίηση AES

Η υλοποίηση του AES σε υλικό πραγματοποιήθηκε με βάση τις απαιτήσεις και

προδιαγραφές του Fips-197, επιλέχθηκε να γίνει με τη χρήση της περιγραφικής
γλώσσας VHDL και πραγματοποιήθηκε με το σχεδιαστικό εργαλείο Quartus II 7.2. Στα
πλαίσια της ερευνητικής εργασίας πραγματοποιήθηκαν δύο υλοποιήσεις, μια που
υποστηρίζει κλειδί εισόδου 128 bits και μια που επιλέγεται μεταξύ τριών κλειδιών
128,192 και 256 αντίστοιχα. Τα κλειδιά κάθε γύρου μπορούν είτε να παράγονται
χωριστά, να αποθηκεύονται σε μια RAM και να αποτελούν είσοδο στον αλγόριθμο είτε
να παράγονται στο ίδιο κύκλωμα με τον αλγόριθμο. Για τις δύο υλοποιήσεις επιλέξαμε
τα κλειδιά να παράγονται στο κύκλωμα του αλγορίθμου και αυτό γιατί η μέθοδος αυτή
πλεονεκτεί σε ταχύτητα (δεν υπάρχουν καθυστερήσεις πρόσβασης μνήμης) και στο
γεγονός ότι αν αλλάζουν τα κλειδιά συνεχώς, αυτόματα θα παράγονται τα νέα
υποκλειδιά που απαιτούνται. Παρακάτω παρουσιάζονται συνοπτικά οι επιλογές που
έχουν γίνει για την υλοποίηση του AES.

Μέγεθος κλειδιού: Στην πρώτη υλοποίηση το κλειδί είναι μήκους 128 bits και στη
δεύτερη δίνεται η δυνατότητα κρυπτογράφησης με κλειδί 128/192 και 256.

Μονάδα παραγωγής κλειδιού: Και στις δύο περιπτώσεις υπάρχει μονάδα που δέχεται ως
είσοδο το εκάστοτε κλειδί και παράγει τα κλειδιά του κάθε γύρου. Στην περίπτωση των
τριών κλειδιών, υπάρχουν σήματα εισόδου που ενεργοποιούν ανάλογα την παραγωγή
10, 12 και 14 υποκλειδιών αντίστοιχα, ανάλογα με τις απαιτήσεις του αλγόριθμου.

Μέγεθος μπλοκ: Η είσοδος και η έξοδος από το κύκλωμα είναι 128 bits και είναι
υλοποιημένο με μέθοδο μη-ανατροφοδότησης.

Βασική Αρχιτεκτονική: Η κρυπτογράφηση και αποκρυπτογράφηση του AES

υλοποιήθηκε με τη βασική αρχιτεκτονική (Εικόνα 4. 7).

Κοινή χρήση πόρων: Με σκοπό να ελαττωθεί όσο το δυνατόν περισσότερο ο χώρος που
καταλαμβάνει το κύκλωμα, τόσο στην υλοποίηση με κλειδί 128 bits όσο και στην
υλοποίηση με τα τρία κλειδιά, η κρυπτογράφηση και αποκρυπτογράφηση μοιράζονται
όσο το δυνατόν περισσότερους πόρους γίνεται.

Στη συνέχεια παρουσιάζονται αναλυτικά και επεξηγούνται τα τμήματα των

αλγορίθμων και περιγράφονται τα VHDL αρχεία κάθε τμήματος.

Εικόνα 4. 7 Βασική αρχιτεκτονική υλοποίησης κρυπτογράφησης/αποκρυπτογράφησης.

95
4.4.1 AES-128

Το βασικό κύκλωμα του αλγορίθμου παρουσιάζεται στην Εικόνα 4. 8 σε μπλοκ μορφή.

Όπως φαίνεται αποτελείται από τρία κύρια μέρη: την παραγωγή κλειδιών, το κύριο
σώμα κρυπτογράφησης/αποκρυπτογράφησης και μια μονάδα ελέγχου. Οι είσοδοι του
κυκλώματος είναι το αρχικό κλειδί, ένα bit εισόδου που δείχνει την είσοδο ενός νέου
κλειδιού, τα δεδομένα για κρυπτογράφηση ή αποκρυπτογράφηση, ένα ρολόι και ένα bit
εισόδου (λειτουργία) που ενεργοποιεί ανάλογα την κρυπτογράφηση ή την
αποκρυπτογράφηση. Τέλος σαν έξοδο από το κύκλωμα παίρνουμε τα
κρυπτογραφημένα (ή αποκρυπτογραφημένα) δεδομένα. Το κλειδί και τα δεδομένα
εισόδου εξόδου είναι μήκους 128 bits σύμφωνα με τα πρότυπα του Fips-197. Στη
συνέχεια παρουσιάζονται αναλυτικά η κάθε μια μονάδα ξεχωριστά καθώς και τα
επιμέρους τμήματα από τα οποία αποτελείται.

4.4.1.1 Μονάδα παραγωγής κλειδιού

Από το βασικό κλειδί που εισάγεται παράγονται δέκα υποκλειδιά για την περίπτωση
του AES 128 τα οποία χρησιμοποιούνται στην κρυπτογράφηση και
αποκρυπτογράφηση. Σε πολλές υλοποιήσεις ο αλγόριθμος είναι ανεξάρτητος από την
παραγωγή των κλειδιών, τα οποία πολλές φορές είναι αποθηκευμένα σε μνήμη και
χρησιμοποιούνται από τον αλγόριθμο χωρίς να παράγονται εκείνη τη στιγμή.

Στη συγκεκριμένη υλοποίηση το μυστικό κλειδί εισέρχεται στο κύκλωμα και ακολούθως
παράγονται τα δέκα υποκλειδιά. Επίσης υπάρχει επιλογή αλλαγής του κλειδιού και
επαναπροσδιορισμού των υποκλειδιών κάτι που είναι χρήσιμο σε εφαρμογές που το
κλειδί αλλάζει συνεχώς. Συγκεκριμένα μόλις η είσοδος newkey γίνει ‘1’ η μονάδα
ελέγχου στέλνει τα κατάλληλα σήματα και η διαδικασία παραγωγής ξεκινάει από την
αρχή. Τέλος υπάρχει μια είσοδος round των τεσσάρων bits η οποία οδηγεί το κατάλληλο
κλειδί στην έξοδο του κυκλώματος. Στην Εικόνα 4. 8 παρουσιάζεται το μπλοκ
διάγραμμα για τη μονάδα παραγωγής των κλειδιών και στον Πίνακα 4. 2 τα αρχεία που
έχουν χρησιμοποιηθεί.

Αρχείο Περιγραφή
KeyExpansion.vhd Υλοποιεί την παραγωγή των κλειδιών
key_pack.vhd Πακέτο που περιλαμβάνει όλα τα επιμέρους τμήματα που
χρησιμοποιούνται
ControlKey.vhd Μονάδα ελέγχου που με κατάλληλα σήματα ενεργοποιεί
τις απαραίτητες ενέργειες
mux_nbits.vhd 2 σε 1 πολυπλέκτης μεταβλητού μήκους εισόδου
reg_nbits.vhd Καταχωρητής μεταβλητού μήκους εισόδου
SubBytes.vhd Μετασχηματισμός ενός byte με μη-γραμμική
αντικατάσταση

Πίνακας 4. 2 Αρχεία vhd για την παραγωγή κλειδιών.

96
Εικόνα 4. 8 Μπλοκ διάγραμμα υλοποίησης συμμετρικού αλγορίθμου AES.

Εικόνα 4. 9 Κύκλωμα για τη μονάδα παραγωγής κλειδιών.

97
Σύμφωνα με το Fips-197 το αρχικό κλειδί πρέπει να περάσει από μια σειρά
μετασχηματισμών (SubWord, RotWord, xor με RCon) και σε κάθε επανάληψη να
παράγεται ένα κλειδί γύρου. Στο παραπάνω κύκλωμα η διαδικασία έχει ως εξής: Το
κλειδί των 128 bits χωρίζεται σε τέσσερις λέξεις των 32 bits (4 bytes) οι οποίες
αποτελούν είσοδο σε τέσσερις πολυπλέκτες (key_to_mux0-3), έτσι στον αριστερότερο
πολυπλέκτη έχουμε τα πρώτα 32 bits του κλειδιού (περισσότερο σημαντικά) και στο
δεξιότερο τα τελευταία 32 bits (λιγότερο σημαντικά). Η είσοδος του κλειδιού την
πρώτη φορά θα πρέπει να συνοδεύεται με ένα bit ελέγχου newkey το οποίο θα πρέπει
να γίνεται “1” σε κάθε κλειδί και μετά να μηδενίζεται. Το bit αυτό οδηγείται σε μια
μονάδα ελέγχου η οποία στην ουσία είναι ένας μετρητής και ενεργοποιεί τα κατάλληλα
σήματα για τους καταχωρητές, τους πολυπλέκτες και δίνει κάθε φορά την τιμή RCon.
Συνεπώς στον πρώτο κύκλο οι πολυπλέκτες παίρνουν σαν είσοδο τους το αρχικό κλειδί
και το βγάζουν στην έξοδό τους. Η έξοδος του δεξιότερου πολυπλέκτη (key_to_mux0)
είναι αυτή που θα επιδεχθεί τους μετασχηματισμούς. Επιπλέον, το κλειδί οδηγείται σε
έναν καταχωρητή 128 bits για την αποθήκευση του.

Αρχικά θα πρέπει να εφαρμοστεί στη λέξη ο μετασχηματισμός RotWord, έπειτα ο

SubWord και τέλος το αποτέλεσμα να γίνει xor με τη σταθερά RCon. Όπως φαίνεται
στην Εικόνα 4. 9 Κύκλωμα για τη μονάδα παραγωγής κλειδιών[34,36] δεν υπάρχει
κάποια μονάδα που να πραγματοποιεί τον RotWord μετασχηματισμό, αντίθετα αυτός
υλοποιείται ταυτόχρονα με τον μετασχηματισμό SubWord οδηγώντας κατάλληλα τα
δεδομένα από τον πολυπλέκτη στο κομμάτι SubBytes (Εικόνα 4. 10). Μόλις τα δεδομένα
τροποποιηθούν κατάλληλα από τον μετασχηματισμό SubBytes, παίρνουμε στην έξοδο
της μονάδας τα 32 μη-γραμμικά μετασχηματισμένα bits σε τέσσερις ομάδες των 8 bits
(Ο μετασχηματισμός SubBytes είναι υλοποιημένος αρχικά να εφαρμόζεται σε 1 byte,
αναλυτικά θα τον δούμε παρακάτω). Στη συνέχεια αντί να κάνουμε xor του RCon με
ολόκληρη τη λέξη πραγματοποιούμε την πράξη της αποκλειστικής διάζευξης μεταξύ
των 8 πιο σημαντικών bits που έχουν εξαχθεί από το μετασχηματισμό SubBytes και
ενός byte (RCon) που δίνεται από τη μονάδα ελέγχου. Το αποτέλεσμα μαζί με τα
υπόλοιπα 24 bits οδηγείται σε μια άλλη πύλη xor όπου πραγματοποιείται η πράξη της
αποκλειστικής διάζευξης της μετασχηματισμένης λέξης και της πιο σημαντικής λέξης
του κλειδιού (έξοδος του πολυπλέκτη key_to_mux3) και στη συνέχεια αποθηκεύεται σε
έναν καταχωρητή 32 bits. Επίσης το αποτέλεσμα που εισάγεται στον καταχωρητή
οδηγείται σε μια τρίτη πύλη xor και προστίθεται με την έξοδο του 3ου καταχωρητή
(key_to_mux2) και επίσης αποθηκεύεται σε έναν καταχωρητή 32 bits. Η ίδια διαδικασία
γίνεται και για τις υπόλοιπες δύο λέξεις με τα αποτελέσματα να αποθηκεύονται επίσης
σε καταχωρητές. Έτσι στο τέλος της διαδικασίας έχουμε το επεκτεταμένο κλειδί του
πρώτου γύρου αποθηκευμένο σε τέσσερις καταχωρητές. Αυτό που πρέπει να γίνει στη
συνέχεια είναι να αποθηκευτεί το κλειδί στον κατάλληλο καταχωρητή και να
ανατροφοδοτηθεί στους πολυπλέκτες για την παραγωγή και των υπόλοιπων
υποκλειδιών. Τη διαδικασία αυτή την αναλαμβάνει η μονάδα ελέγχου κλειδιού η οποία
στέλνοντας τα κατάλληλα σήματα ενεργοποιεί τους καταχωρητές και τους
πολυπλέκτες. Στη συνέχεια θα περιγράψουμε αναλυτικά κάθε τμήμα που
χρησιμοποιείται από το κύκλωμα και στη συνέχεια θα δούμε ένα παράδειγμα
εξομοίωσης.

32

31-24 0-7 15-8 23-16

SubBytes

Εικόνα 4. 10 Υλοποίηση μετασχηματισμού RotWord.

98
key_pack.vhd: Είναι αρχείο το οποίο περιλαμβάνει όλα τα επιμέρους τμήματα που
χρησιμοποιούνται και καλείται στο κυρίως αρχείο του κυκλώματος.

reg_nbits.vhd: Περιγράφει τη λειτουργία ενός καταχωρητή μήκους n-bits. Έχει εισόδους

ένα ρολόι Clk, ένα bit φόρτωσης load και την είσοδο των δεδομένων input_reg και σαν
έξοδο output_reg τα δεδομένα εισόδου. Ο τρόπος λειτουργίας του είναι ο εξής : σε μια
θετική ακμοπυροδότηση του ρολογιού αν η τιμή του bit φόρτωσης είναι “1” τότε τα
δεδομένα εισόδου αποτελούν δεδομένα εξόδου. (Στο Παράρτημα Β σελ. 147
παρουσιάζεται ο VHDL κώδικας όλων των τμημάτων).

mux_nbits.vhd: Περιγράφει τη λειτουργία ενός πολυπλέκτη μήκους n-bits. Ο

πολυπλέκτης έχεις δύο εισόδους δεδομένων L_in και R_in, μια είσοδο ενεργοποίησης En,
μια είσοδο επιλογής εισόδου sel, και την έξοδο mux_out. Αν η είσοδος ενεργοποίησης En
είναι “0” τότε η έξοδος του πολυπλέκτη είναι nbits “0” , διαφορετικά η έξοδος παίρνει
την τιμή εισόδου L_in όταν το bit sel είναι “0” και R_in όταν το bit sel είναι “1”.

SubBytes.vhd: Είναι το τμήμα που υλοποιεί τον μη γραμμικό μετασχηματισμό ενός byte.
Έχει σαν είσοδο 8 bits δεδομένων και μετά από μια σειρά πράξεων, παίρνουμε μια έξοδο
των 8 επίσης bits.

ControlKey.vhd: Είναι η μονάδα που ελέγχει όλα τα επιμέρους τμήματα για την επέκταση
του κλειδιού. Οι είσοδοι της μονάδας ελέγχου είναι το bit newkey και ένα ρολόι Clk, σαν
έξοδο παίρνουμε το bit sel, το bit En, ένα διάνυσμα ld μήκους 11 bits και τη σταθερά
γύρου RCon μήκους 8 bits. Η μονάδα ελέγχου λειτουργεί ως εξής: Μόλις έρθει το bit
newkey με τιμή “1” θέτει το sel στη τιμή “0”, δηλαδή ενεργοποιεί την L_in είσοδο του
πολυπλέκτη που είναι το αρχικό κλειδί, το En στη τιμή “1” ,ενεργοποιεί δηλαδή τους
πολυπλέκτες, δίνει την τιμή “0” σε έναν εσωτερικό μετρητή, μηδενίζει το διάνυσμα ld
(έτσι το διάνυσμα έχει την τιμή “00000000000” και δεν ενεργοποιείται κανένας
καταχωρητής για την αποθήκευση των κλειδιών γύρου) και τέλος δίνει την
δεκαεξαδική τιμή “01” στη σταθερά γύρου RCon. Όταν το bit newkey γίνει “0” τότε στη
θετική ακμή του ρολογιού θα συμβούν τα εξής, τα ld(0) και ld(1) θα πάρουν τη τιμή “1”,
δηλαδή θα αποθηκευτεί το αρχικό κλειδί και το κλειδί του πρώτου γύρου, ο μετρητής
θα αυξηθεί κατά 1 και με την εντολή ld(count+1)<='1'; και με αυτόν τον τρόπο σε κάθε
κύκλο ρολογιού θα αποθηκεύεται το κλειδί γύρου. Στη συνέχεια η σταθερά γύρου θα
προστίθεται στον εαυτό της με τον έλεγχο να παίρνει τις τιμές “1B” και “36” στους
κατάλληλους γύρους και να μηδενίζεται όταν πρέπει. Η όλη διαδικασία
επαναλαμβάνεται συνεχώς μέχρις ότου να έρθει ένα νέο σήμα newkey που θα ξεκινήσει
τη διαδικασία από την αρχή.

KeyExpansion.vhd: Είναι το κύριο τμήμα για την παραγωγή του κλειδιού. Έχει σαν
είσοδο το αρχικό κλειδί, την επιλογή newkey, ένα ρολόι, την είσοδο round για την
επιλογή του κλειδιού γύρου και σαν έξοδος δίνεται το κατάλληλο κλειδί. Το αρχείο αυτό
καλεί το αρχείο key_pack.vhd που περιλαμβάνει όλα τα επιμέρους τμήματα, δημιουργεί
τους καταχωρητές τους πολυπλέκτες και όλα τα τμήματα που είναι απαραίτητα, και τα
συνδέει κατάλληλα όπως φαίνεται στην Εικόνα 4. 9. Τέλος ανάλογα με την τιμή της
εισόδου round οδηγεί τα περιεχόμενα των καταχωρητών που περιέχουν τα κλειδιά
γύρου στην έξοδο του κυκλώματος.

99
Παράδειγμα εξομοίωσης

Η υλοποίηση της επέκτασης κλειδιού έγινε με το σχεδιαστικό εργαλείο Quartus II

Version 7.2 της Altera και επιλέχθηκε για τη συγκεκριμένη υλοποίηση το CYCLONE II
EP2C35F672C6 FPGA. Η μεταγλώττιση του σχεδίου παρουσιάζεται στον Πίνακα 4. 3.
Όπως παρατηρούμε το κύκλωμα χρησιμοποιεί έναν συνολικό αριθμό 2.206 λογικών
στοιχείων που αποτελούν το 15% των συνολικά διαθέσιμων στοιχείων και 1586
λογικούς καταχωρητές, δηλαδή το 11% του συνόλου. Επιπλέον, από τους 315
διαθέσιμους ακροδέκτες, το κύκλωμα χρησιμοποιεί τους 262 δηλαδή το 83% και αυτό
γιατί το κλειδί εισόδου και εξόδου είναι 128 bits οπότε μόνο τα κλειδιά καταλαμβάνουν
256 ακροδέκτες. Επίσης παρατηρούμε πως δεν έχουν χρησιμοποιηθεί καθόλου στοιχεία
μνήμης κάτι που ήταν επιθυμητό. Τέλος, το συνολικό κύκλωμα, σύμφωνα με το
εργαλείο Classic Timing Analyzer δουλεύει με μέγιστη συχνότητα στα 103,47 MHz.

Για το παράδειγμα εξομοίωσης θα χρησιμοποιήσουμε σαν κλειδί το κλειδί που

χρησιμοποιήσαμε και στο παράδειγμα της υλοποίησης σε λογισμικό
(“0123456789102030” όπου στο δεκαεξαδικό σύστημα είναι
“30313233343536373839313032303330”) ώστε να μπορέσουμε να επιβεβαιώσουμε
τα αποτελέσματα. Στην Εικόνα 4. 11 παρουσιάζονται τα αποτελέσματα εξομοίωσης.

Μεταγλώτιση σχεδίου
Quartus II Version 7.2 Build 203 02/05/2008 SP 2 SJ Full Version
Top-level Entity Name KeyExpansion
Family Cyclone II
Device EP2C35F672C6
Total logic elements 2.206 / 33.216 (7%)
Total combinational functions 1.566 / 33.216 (5%)
Dedicated logic registers 1.586 / 33.216 (5%)
Total registers 1.586
Total pins 262 / 475 (55%)
Total memory bits 0 / 483.840 (0%)
Embedded Multiplier 9-bit elements 0 / 70 (0%)
Total PLLs 0 / 4 (0%)
Timing Models Final
Πίνακας 4. 3 Αναφορά μεταγλώττισης για την επέκταση κλειδιού.

Εικόνα 4. 11 Αποτελέσματα εξομοίωσης για την επέκταση κλειδιού.

100
4.4.1.2 Μονάδα κρυπτογράφησης/αποκρυπτογράφησης

Για την κρυπτογράφηση και αποκρυπτογράφηση των δεδομένων υλοποιήθηκε μια

μονάδα η οποία κρυπτογραφεί και αποκρυπτογραφεί ταυτόχρονα επιλέγοντας κάθε
φορά τα κατάλληλα δεδομένα μέσα από πολυπλέκτες. Συγκεκριμένα για την
αποκρυπτογράφηση χρησιμοποιήθηκε η υλοποίηση ισοδύναμης αποκρυπτογράφησης
με την κατάλληλη τροποποίηση στα κλειδιά γύρου ώστε να βελτιστοποιήσουμε το
κύκλωμα. Σύμφωνα με τον αλγόριθμο όπως έχουμε αναφέρει, αρχικά γίνεται η πράξη
της αποκλειστικής διάζευξης μεταξύ του κειμένου και ενός κλειδιού και έπειτα
επαναλαμβάνονται για εννιά γύρους οι μετασχηματισμοί SubBytes/InvSubBytes,
ShiftRows/InvShiftRows, MixColumns/InvMixColumns, xor με κλειδί γύρου και στον
τελευταίο κύκλο επαναλαμβάνεται η ίδια διαδικασία χωρίς το μετασχηματισμό
MixColumns/InvMixColumns. Για την υλοποίηση της διαδικασίας αυτής υπάρχουν
κατάλληλα σήματα που ελέγχουν τους πολυπλέκτες που υπάρχουν ενδιάμεσα από κάθε
μετασχηματισμό και ελέγχονται από τη μονάδα ελέγχου που θα δούμε παρακάτω. Στο
σημείο αυτό μπορούμε να πούμε πως οι κύριες είσοδοι στη μονάδα
κρυπτογράφησης/αποκρυπτογράφησης (δεν συμπεριλαμβάνονται τα σήματα από τη
μονάδα ελέγχου) είναι το αρχικό κείμενο plaintext μήκους 128 bits, το κλειδί γύρου KEY
μήκους 128 bits που λαμβάνεται από τη μονάδα παραγωγής κλειδιού, ένα bit Operation
που επιλέγει αν θα γίνει κρυπτογράφηση (όταν έχει τιμή “0”) ή αποκρυπτογράφηση
(όταν έχει τιμή “1”), ένα ρολόι Clk και δίνεται σαν έξοδο τα κρυπτογραφημένα
δεδομένα ciphertext μήκους 128 bits.

Για την υλοποίηση της μονάδας κρυπτογράφησης/αποκρυπτογράφησης και των

απαραίτητων μετασχηματισμών χρησιμοποιήθηκε ένα πλήθος αρχείων, τα βασικότερα
αυτών παρουσιάζονται στον Πίνακα 4. 4 και στην Εικόνα 4. 12 φαίνεται το μπλοκ
διάγραμμα του κυκλώματος[32, 33, 34, 35, 36,39].

Αρχείο Περιγραφή
mux_clk.vhd Πολυπλέκτης 2 σε 1 που διατηρεί τα δεδομένα
mux_nbits.vhd Πολυπλέκτης 2 σε 1 μεταβλητού μήκους εισόδου
mux3in1.vhd Πολυπλέκτης 3 σε 1 μεταβλητού μήκους εισόδου
ShiftRows.vhd Μετάθεση των 128 bits
InvShiftRows.vhd Αντίστροφη μετάθεση των 128 bits
SubBytes128.vhd Μετασχηματισμός των 128 bits με μη-γραμμική
αντικατάσταση
InvSubBytes128.vhd Αντίστροφος μετασχηματισμός των 128 bits με μη-
γραμμική αντικατάσταση
InvMixColumn128.vhd Πολλαπλασιασμός στο πεπερασμένο πεδίο GF(28) με
δεδομένο πολυώνυμο. Η υλοποίηση εφαρμόζει και τον
κανονικό μετασχηματισμό MixColumn και τον αντίστροφο
InvMixColumn για 128 bits δεδομένα

Πίνακας 4. 4 Αρχεία για την υλοποίηση της μονάδας κρυπτογράφησης/αποκρυπτογράφησης.

Εικόνα 4. 12 Μπλοκ διάγραμμα κρυπτογράφησης/αποκρυπτογράφησης.

101
Περιγραφή αρχείων

mux_clk.vhd: Το αρχείο αυτό περιγράφει έναν πολυπλέκτη δύο εισόδων L_in και R_in
όπου ανάλογα με τα σήματα εισόδου οδηγούνται στην έξοδο mux_out. Συγκεκριμένα το
κύκλωμα έχει ένα bit εισόδου ενεργοποίησης του πολυπλέκτη En, ένα bit επιλογής
εξόδου sel, και ένα ρολόι Clk. Όταν σε κάθε θετική ακμή του ρολογιού ο πολυπλέκτης
είναι ενεργός (En=”1”) τότε ανάλογα με την τιμή sel παίρνουμε την επιθυμητή έξοδο
(L_in αν το sel=”0” R_in αν το sel=”1”).

mux_nbits.vhd: Το αρχείο περιγράφει έναν πολυπλέκτη 2 σε 1 μεταβλητού μήκους

εισόδου. Είναι το ίδιο αρχείο που περιγράφηκε και χρησιμοποιήθηκε στην επέκταση
του κλειδιού.

mux3in1.vhd: Είναι ένας πολυπλέκτης τριών εισόδων, MC, IMC, last_round και
τοποθετείται μετά το μετασχηματισμό InvMixColumn. Ο πολυπλέκτης αυτός χρησιμεύει
για την υλοποίηση των εννιά επαναλήψεων και του τελευταίου γύρου. Έχει ένα bit
εισόδου για την ενεργοποίηση του En, ένα διάνυσμα μήκους δύο bits για την επιλογή
εξόδου sel, και μια έξοδο mux_out. Η λειτουργία του είναι όπως αυτή ενός απλού
πολυπλέκτη, δηλαδή όταν είναι ενεργός (En=”1”) αν το sel έχει την τιμή “00” δίνει έξοδο
MC, αν το sel έχει την τιμή “01” δίνει έξοδο IMC, διαφορετικά δίνει έξοδο last_round.

ShiftRows128.vhd: Με το αρχείο αυτό επιτυγχάνεται η υλοποίηση του μετασχηματισμού

ShiftRows. Το τμήμα αυτό παίρνει σαν είσοδο το μπλοκ δεδομένων των 128 bits και
κάνει τις κατάλληλες αντιμεταθέσεις στα δεδομένα δίνοντας σαν έξοδο το
μετατοπισμένο μπλοκ δεδομένων.

InvShiftRows128.vhd: Είναι η αντίστροφη διαδικασία του μετασχηματισμού ShiftRows

και η λειτουργία του είναι ανάλογη με το αρχείο ShiftRows128.vhd μόνο που αλλάζουν οι
αντιμεταθέσεις στα δεδομένα.

SubBytes128.vhd: Το αρχείο αυτό καλεί ένα μικρότερο αρχείο SubBytes.vhd που

πραγματοποιεί τον μετασχηματισμό SubBytes σε ένα byte δεδομένων. Συγκεκριμένα το
SubBytes128.vhd χωρίζει τα δεδομένα σε 16 bytes και τα τροφοδοτεί στο SubBytes.vhd
για να μετασχηματιστούν και έπειτα τα εξάγει έχοντας πλέον την κατάλληλη μορφή.

SubBytes.vhd: Για τον SubByte μετασχηματισμού έχουν γίνει πολλές προσπάθειες και
έρευνες για την καλύτερη και αποδοτικότερη υλοποίηση του [32, 33, 34, 35, 36]. Σε μια
πρώτη προσέγγιση θα μπορούσε ο μετασχηματισμός να υλοποιείται μέσω μιας μνήμης
RAM όπου θα ήταν αποθηκευμένοι μέσα οι πίνακες μετασχηματισμού κάτι ανάλογο
δηλαδή, με την υλοποίηση σε λογισμικό. Όμως η προσπέλαση της μνήμης θα είχε μεγάλη
επίπτωση στην αύξηση της καθυστέρησης, πράγμα που θα έκανε τον αλγόριθμο αρκετά
αργό. Για το λόγο αυτό έχουν γίνει προσπάθειες για τον επί τόπου υπολογισμό του
μετασχηματισμού μέσω πράξεων στο πεδίο GF(28). Οι X. Zhang και K.K. Parhi [34]
στηρίχθηκαν στην ιδιότητα ότι το πεδίο GF(28) μπορεί να χτιστεί επαναληπτικά από το
πεδίο GF(2) χρησιμοποιώντας τα ακόλουθα ανάγωγα πολυώνυμα

GF(2)⇾ GF(22): P0(x) = x2 + x + 1

GF(22)⇾ GF((22)2): P1(x) = x2 + x + φ
GF((22)2)⇾ GF(((22)2)2): P2(x) = x2 + x + λ

όπου φ = {10}2 και λ = {1100}2 . Επιπλέον για την αναπαράσταση ενός στοιχείου στο
πεδίο GF(28) πρέπει να εφαρμοστεί μια ισομορφική συνάρτηση f(x) = δ × x και η
αντίστροφη της. Η συνάρτηση δ που αντιστοιχεί στο πολυώνυμο p(x) = x8+x4+x3+x+1
είναι ένας πίνακας 8x8 όπως φαίνεται παρακάτω:

102
 Εικόνα 4. 13 Μπλοκ διάγραμμα υλοποίησης SubBytes.

11000010
⎡0 1 0 0 1 0 1 0⎤
⎢0 1 1 1 1 0 0 1⎥
⎢ ⎥
0 1 1 0 0 0 1 1⎥
δ =⎢
⎢0 1 1 1 0 1 0 1⎥
⎢0 0 1 1 0 1 0 1⎥
⎢0 1 1 1 1 0 1 1⎥
⎣0 0 0 0 0 1 0 1⎦

Έτσι λοιπόν κατέληξαν στην υλοποίηση του μετασχηματισμού μέσω τριών

διαδικασιών, ισομορφική συνάρτηση, πολλαπλασιαστική αντιστροφή, αντίστροφη
ισομορφική συνάρτηση και μετασχηματισμός συσχέτισης (Εικόνα 4. 13, [34]).

Οι R.R. Rachh, P.V. A. Mohan και B.S. Anami [33] στηριζόμενοι στην εργασία των Zhang
και Parhi βελτιστοποίησαν ακόμα περισσότερο το κύκλωμα ελαχιστοποιώντας της
πύλες που χρειάζονται για την υλοποίηση του και συνδυάζοντας την έξοδο από την
ισομορφική συνάρτηση δ με την έξοδο από την αντίστροφη ισομορφική συνάρτηση και
το μετασχηματισμό συσχέτισης ελαττώνοντας έτσι την κρίσιμη διαδρομή και
ελαχιστοποιώντας τις απαιτούμενες πύλες (Εικόνα 4. 14). Έτσι κατέληξαν στην
υλοποίηση του μετασχηματισμού μέσα από πύλες xor και and την οποία και
χρησιμοποιήσαμε. Για είσοδο x και έξοδο t των 8 bits οι σχέσεις είναι οι ακόλουθες για
κάθε ένα μπλοκ:

Μπλοκ Ι:

q(3) = (x(7)⋅(x(5)⊕ x(4) ⊕ x(1) ⊕ x(0))) ⊕ (x(6)⋅(x(5) ⊕ x(4) ⊕ x(2) ⊕ x(1))) ⊕ (x(5) ⋅(x(4)
⊕ x(2) ⊕ x(1) ⊕ x(0))) ⊕ (x(4)⋅(x(2) ⊕ x(1))) ⊕ ((x(3)) ⋅(x(2) ⊕ x(1))) ⊕ (x(2)⋅ x(1))

q(2) = (x(7)⋅(x(6) ⊕ x(5) ⊕ x(3) ⊕ x(2) ⊕ x(0))) ⊕ (x(6)⋅(x(5) ⊕ x(3) ⊕ x(2) ⊕ x(1) ⊕ x(0)))
⊕ (x(5)⋅(x(3) ⊕ x(2))) ⊕ (x(4)⋅(x(3) ⊕ x(2) ⊕ x(0))) ⊕ (x(3)⋅(x(2) ⊕ x(0))) ⊕ ((x(2) ⊕
x(1))⋅ x(0))

q(1) = (x(7)⋅(x(5) ⊕ x(2) ⊕ x(0) ⊕'1')) ⊕ (x(6)⋅(x(5) ⊕ x(3))) ⊕ (x(5)⋅(x(4) ⊕ x(3) ⊕ x(2) ⊕
x(0) ⊕'1')) ⊕ (x(4)⋅(x(2) ⊕'1')) ⊕ (x(3)⋅(x(2) ⊕ x(0))) ⊕ (x(2)⋅(x(1) ⊕ x(0) ⊕'1')) ⊕
x(1)

q(0) = (x(7)⋅(x(6) ⊕ x(4) ⊕ x(0))) ⊕ (x(6)⋅(x(5) ⊕ x(4) ⊕ x(3) ⊕ x(1) ⊕'1')) ⊕ (x(5)⋅(x(3) ⊕
x(0) ⊕'1')) ⊕ (x(4)⋅(x(3) ⊕ x(1))) ⊕ (x(3)⋅(x(2) ⊕ x(1) ⊕ x(0) ⊕'1')) ⊕ ((x(2) ⊕ x(1))⋅
x(0)) ⊕ (x(0) ⊕ x(2))

Εικόνα 4. 14 Βελτιστοποιημένο μπλοκ διάγραμμα υλοποίησης SubBytes.

103
Μπλοκ ΙΙ

y(3) = q(3) ⊕ (q(3)⋅q(2)⋅q(1)) ⊕ (q(3)⋅q(0)) ⊕ q(2)

y(2) = (q(3)⋅q(2)⋅q(1)) ⊕ (q(3)⋅q(2)⋅q(0)) ⊕ (q(3)⋅q(0)) ⊕q(2) ⊕ (q(2)⋅q(1))

y(1) = q(3) ⊕ (q(3)⋅q(2)⋅q(1))⊕(q(3)⋅q(1)⋅q(0)) ⊕q(2) ⊕(q(2)⋅q(0)) ⊕q(1)

y(0) = (q(3)⋅ q(2)⋅ q(1)) ⊕(q(3)⋅ q(2)⋅q(0)) ⊕(q(3)⋅q(1)) ⊕(q(3)⋅q(1)⋅q(0)) ⊕(q(3)⋅q(0)) ⊕

q(2) ⊕(q(2)⋅q(1))⊕(q(2)⋅q(1)⋅q(0)) ⊕ q(1) ⊕ q(0)

Μπλοκ ΙΙΙ

t(7) = (y(3)⋅(x(7) ⊕ x(6) ⊕ x(4) ⊕ x(0)))⊕(y(2)⋅(x(5) ⊕ x(4) ⊕ x(3) ⊕ x(0)))⊕(y(1)⋅(x(5) ⊕

x(4) ⊕ x(3) ⊕ x(2) ⊕ x(1)))⊕(y(0)⋅(x(7) ⊕ x(2) ⊕ x(1)))

t(6) = (y(3)⋅(x(7) ⊕ x(6) ⊕ x(4)))⊕(y(2)⋅(x(7) ⊕ x(5) ⊕ x(1)))⊕(y(1)⋅(x(6) ⊕ x(5) ⊕

x(4)))⊕(y(0)⋅(x(6) ⊕ x(5) ⊕ x(4) ⊕ x(3) ⊕ x(2))) ⊕'1'

t(5) = (y(3)⋅(x(7) ⊕ x(6) ⊕ x(5) ⊕ x(2)))⊕(y(2)⋅(x(7) ⊕ x(5) ⊕ x(0)))⊕(y(1)⋅(x(4) ⊕

x(3)))⊕(y(0)⋅(x(7) ⊕ x(6) ⊕ x(5))) ⊕'1'
t(4) = (y(3)⋅(x(6) ⊕ x(5) ⊕ x(2)))⊕(y(2)⋅(x(7) ⊕ x(6) ⊕ x(5) ⊕ x(3) ⊕ x(2)))⊕(y(1)⋅(x(5) ⊕
x(4) ⊕ x(3) ⊕ x(2) ⊕ x(1) ⊕ x(0)))⊕(y(0)⋅(x(4) ⊕ x(3) ⊕ x(2) ⊕ x(0)))

t(3) <= (y(3)⋅(x(7) ⊕ x(6) ⊕ x(5) ⊕ x(4) ⊕ x(3) ⊕ x(2) ⊕ x(1)))⊕(y(2)⋅(x(7) ⊕ x(6) ⊕ x(5) ⊕
x(3) ⊕ x(2) ⊕ x(0)))⊕(y(1)⋅(x(7) ⊕ x(3) ⊕ x(1) ⊕ x(0)))⊕(y(0)⋅(x(6) ⊕ x(4) ⊕ x(1) ⊕
x(0)))

t(2) = (y(3)⋅(x(5) ⊕ x(2) ⊕ x(1) ⊕ x(0)))⊕(y(2)⋅(x(7) ⊕ x(6) ⊕ x(5) ⊕ x(4) ⊕ x(3) ⊕ x(2) ⊕
x(0)))⊕(y(1)⋅(x(7) ⊕ x(5) ⊕ x(4)))⊕(y(0)⋅(x(4) ⊕ x(2) ⊕ x(1) ⊕ x(0)))

t(1) = (y(3)⋅(x(6) ⊕ x(4) ⊕ x(3) ⊕ x(1)))⊕(y(2)⋅(x(6) ⊕ x(5) ⊕ x(3) ⊕ x(1)))⊕(y(1)⋅

x(7))⊕(y(0)⋅(x(6) ⊕ x(3) ⊕ x(2) ⊕ x(0))) ⊕'1'

t(0) = (y(3)⋅(x(7) ⊕ x(3) ⊕ x(2) ⊕ x(1)))⊕(y(2)⋅(x(7) ⊕ x(4) ⊕ x(0)))⊕(y(1)⋅(x(6) ⊕ x(4) ⊕

x(2) ⊕ x(0)))⊕(y(0)⋅(x(5) ⊕ x(3) ⊕ x(2) ⊕ x(0))) ⊕'1'

InvSubBytes128.vhd: Είναι ο αντίστροφος μετασχηματισμός του SubBytes. Το

συγκεκριμένο αρχείο καλεί ένα μικρότερο μετασχηματισμό που βρίσκεται στο αρχείο
InvSubBytes.vhd και λειτουργεί ανάλογα .

InvSubBytes.vhd: Όπως και στη περίπτωση του SubBytes.vhd η υλοποίηση έγινε με βάση
την εργασία των Rachh, Mohan και Anami. Η βελτιστοποίηση στα Μπλοκ Ι, ΙΙ και ΙΙΙ
γίνεται πλέον στη διαδικασία μετασχηματισμού, αντίστροφος μετασχηματισμός
συσχέτισης και ισομορφική συνάρτηση, πολλαπλασιαστική αντιστροφή, αντίστροφη
ισομορφική συνάρτηση (Εικόνα 4. 15, [33,34]).

Εικόνα 4. 15 Μπλοκ διάγραμμα υλοποίησης InvSubBytes.

104
Οι συναρτήσεις που υλοποιούν τον αντίστροφο μετασχηματισμό είναι οι εξής:

Μπλοκ Ι:

q(3) =(x(7) ⋅(x(4) ⊕x(1) ⊕x(0)))⊕(x(6) ⋅(x(4) ⊕x(2) ⊕x(0))) ⊕(x(5) ⋅(x(4) ⊕x(3))) ⊕(x(4)
⋅(x(2) ⊕x(1)))⊕x(4) ⊕(x(3) ⋅(x(1) ⊕x(0)))⊕(x(2) ⋅(x(1)⊕x(0)))⊕(x(0))

q(2) =(x(7) ⋅(x(5) ⊕x(2) ⊕x(1) ⊕x(0)))⊕x(7) ⊕(x(6) ⋅(x(5) ⊕x(4)))⊕x(6) ⊕(x(4) ⋅(x(2)
⊕x(1)))⊕x(4)⊕(x(3) ⋅x(1))⊕(x(1) ⋅(x(0)))⊕x(1) ⊕(x(0)) ⊕'1'

q(1) =(x(7) ⋅(x(4) ⊕x(2) ⊕x(0) ⊕x(1)))⊕x(7) ⊕(x(6) ⋅(x(5) ⊕x(4) ⊕x(2) ⊕x(1)))⊕x(6)
⊕(x(5) ⋅(x(3) ⊕x(1)⊕x(0)))⊕x(5) ⊕(x(4) ⋅(x(2)))⊕x(4) ⊕(x(3) ⋅(x(2) ⊕x(0)))⊕(x(2))
⊕(x(1)) ⊕(x(0))

q(0) =(x(7) ⋅(x(4) ⊕x(0))) ⊕(x(6) ⋅(x(5) ⊕x(4) ⊕x(1))) ⊕(x(5) ⋅x(4)) ⊕(x(4) ⋅(x(3) ⊕x(2)
⊕x(1))) ⊕x(4) ⊕(x(3) ⋅(x(2) ⊕x(0))) ⊕x(3) ⊕(x(1) ⋅x(0)) ⊕'1'

Μπλοκ ΙΙ

Το Μπλοκ ΙΙ είναι ακριβώς ίδιο όπως και στη περίπτωση SubBytes.

Μπλοκ ΙΙI

t(7)=(y(3)⋅(x(4)⊕x(0)⊕'1'))⊕(y(2)⋅(x(2) ⊕ x(1)⊕'1')) ⊕ (y(1)⋅(x(5) ⊕ x(0))) ⊕ (y(0)⋅(x(5)

⊕ x(1) ⊕x(0)⊕'1'))

t(6)=(y(3)⋅(x(7) ⊕ x(3)⊕x(1) ⊕'1')) ⊕ (y(2)⋅(x(5)⊕x(1))) ⊕(y(1)⋅(x(7)⊕x(5)⊕'1')) ⊕

(y(0)⋅(x(7)⊕x(6)⊕x(5)⊕x(2)⊕x(1)⊕'1'))

t(5)=(y(3)⋅(x(6)⊕x(4)⊕x(0))) ⊕ (y(2)⋅(x(7)⊕x(5)⊕x(4)⊕x(0))) ⊕ (y(1)⋅(x(5)⊕x(3)⊕'1')) ⊕

(y(0)⋅(x(7)⊕x(6)⊕x(5)⊕x(2)⊕x(0)⊕'1'))

t(4)=(y(3)⋅(x(6)⊕x(5)⊕x(2)⊕x(0)⊕'1'))⊕(y(2)⋅(x(7)⊕x(5)⊕x(1)))⊕(y(1)⋅(x(5)⊕x(4)⊕x(3)
⊕x(2)⊕x(1)⊕x(0)⊕'1'))⊕(y(0)⋅(x(7)⊕x(6)⊕x(5)⊕x(4)⊕x(2)))

t(3)=(y(3)⋅(x(5)⊕x(4)⊕x(3)⊕x(1))) ⊕ (y(2)⋅(x(6)⊕x(5)⊕x(3))) ⊕ (y(1)⋅(x(7)⊕x(5)⊕x(4)⊕

x(2)⊕x(1)))⊕(y(0)⋅(x(6)⊕x(4)⊕x(3)⊕x(2)⊕x(0)))

t(2)=(y(3)⋅(x(7)⊕x(5)⊕x(4)⊕x(2)⊕x(0))) ⊕ (y(2)⋅(x(7)⊕x(6)⊕x(4)⊕x(2)⊕x(1))) ⊕ (y(1)

⋅(x(7)⊕x(6)⊕x(5)⊕x(4)⊕x(2)⊕x(1)⊕'1'))⊕(y(0)⋅(x(7)⊕x(6)⊕x(5)⊕x(3)⊕x(1)⊕'1'))

t(1)=(y(3)⋅(x(7)⊕x(6)⊕x(2)⊕x(1))) ⊕ (y(2)⋅(x(7)⊕x(6)⊕x(3)⊕x(2)⊕x(1)⊕x(0)⊕'1')) ⊕
(y(1) ⋅(x(5)⊕x(4)⊕x(3)⊕'1'))⊕(y(0)⋅(x(6)⊕x(3) ⊕x(0)))

t(0)=(y(3)⋅(x(1) ⊕ x(0))) ⊕ (y(2)⋅(x(7) ⊕ x(3) ⊕ x(1) ⊕ x(0))) ⊕ (y(1)⋅(x(7) ⊕ x(6) ⊕ x(1) ⊕

x(0)⊕'1')) ⊕ (y(0)⋅(x(6)⊕x(4)⊕x(1)⊕x(0)⊕'1'))

InvMixColumn128.vhd: Το τμήμα αυτό υλοποιεί το μετασχηματισμό MixColumn και

InvMixColumn ταυτόχρονα. Παίρνει σαν είσοδο την κατάσταση state των 128 bits και
δίνει δύο εξόδους των 128 bits την MC για το μετασχηματισμό MixColumn και την IMC
για τον InvMixColumn. Το αρχείο αυτό καλεί ένα αρχείο InvMixColumn32.vhd, όπου
πραγματοποιεί το μετασχηματισμό για 32 bits και συνδέοντας κατάλληλα τα δεδομένα
τον εφαρμόζει σε ολόκληρο το μπλοκ.

105
 Εικόνα 4. 16 Υλοποίηση πολλαπλασιασμού {02}16 με πολυώνυμο.

InvMixColumn32.vhd: Για την υλοποίηση των μετασχηματισμών MixColumn και

InvMixColumn στηριχθήκαμε στην εργασία των Zhang και Parhi [34]. Εφαρμόζοντας τη
μέθοδο κοινής χρήσης δομής ανάμεσα στον υπολογισμό ενός byte και στον υπολογισμό
των τεσσάρων bytes σε μια στήλη του πίνακα κατάστασης, ο μετασχηματισμός
MixColumn μπορεί να γραφεί:

S’0,c = {02}16(S0,c + S1,c) + (S2,c + S3,c) + S1,c

S’1,c = {02}16(S1,c + S2,c) + (S3,c + S0,c) + S2,c
S’2,c = {02}16(S2,c + S3,c) + (S0,c + S1,c) + S3,c
S’3,c = {02}16(S3,c + S0,c) + (S1,c + S2,c) + S0,c

Όπου S είναι η αρχική κατάσταση S’ η τελική και c η στήλη του πίνακα κατάστασης. Ο
σταθερός πολλαπλασιασμός με το {02}16 αναφέρεται σαν XTime και με βάση το ότι ένα
πολυώνυμο στο GF(28) εκφράζεται ως S = s7x7 + s6x6 + s5x5 + s4x4 + s3x3 + s2x2 + s1x + s0 ο
πολλαπλασιασμός γίνεται :

{02}12S = xS = s7x8 + s6x7 + s5x6 + s4x5 + s3x4 + s2x3 + s1x2 + s0x modp(x)
= s6x7 + s5x6 + s4x5 + (s3 + s7)x4 + (s2 + s7)x3 + s1x2 + (s0 + s7)x + s7

Συνεπώς ο πολλαπλασιασμός XTime υλοποιείται με τρείς πύλες xor με μια μόλις πύλη
στην κρίσιμη διαδρομή (Εικόνα 4. 16).

Αντίστοιχα ο μετασχηματισμός InvMixColumn γράφεται:

S’0,c = ({02}16(S0,c + S1,c) + (S2,c + S3,c) + S1,c) + ({02}16({04}16(S0,c + S2,c) + {04}16(S1,c + S3,c)) +
{04}16(S0,c + S2,c))
S’1,c = ({02}16(S1,c + S2,c) + (S3,c + S0,c) + S2,c) + ({02}16({04}16(S0,c + S2,c) + {04}16(S1,c + S3,c)) +
{04}16(S1,c + S3,c))
S’2,c = ({02}16(S2,c + S3,c) + (S0,c + S1,c) + S3,c) + ({02}16({04}16(S0,c + S2,c) + {04}16(S1,c + S3,c)) +
{04}16(S0,c + S2,c))
S’3,c = ({02}16(S3,c + S0,c) + (S1,c + S2,c) + S0,c) + ({02}16({04}16(S0,c + S2,c) + {04}16(S1,c + S3,c)) +
{04}16(S1,c + S3,c))

και ο πολλαπλασιασμός με το {04}16 (X4Time) υπολογίζεται με βάση την εξίσωση :

{04}12S = x2 S = s7x9 + s6x8 + s5x7 + s4x6 + s3x5 + s2x4 + s1x3 + s0x2 modp(x)
= s5x7 + s4x6 + (s3 + s7) x5+ (s2 + (s6 + s7)) x4 + (s1 + s6 ) x3 + (s0 + s7)x2 +(s6 + s7)x + s6

Συνεπώς ο πολλαπλασιασμός X4Time υλοποιείται με πέντε πύλες xor με δύο πύλες

στην κρίσιμη διαδρομή (Εικόνα 4. 17).

106
 Εικόνα 4. 17 Υλοποίηση πολλαπλασιασμού {04}16 με πολυώνυμο.

Παρατηρώντας τις δύο εξισώσεις που υλοποιούν τους μετασχηματισμούς βλέπουμε

πως η συνάρτηση της Mix Column επαναλαμβάνεται στην InvMixColumn με κάποιες
επιπλέον προσθήκες. Συνεπώς, αν υλοποιήσουμε τη συνάρτηση InvMixColumn και
πάρουμε τις κατάλληλες εξόδους, θα έχουμε υλοποιήσει ταυτόχρονα και την συνάρτηση
MixColumn. Αυτή τη μέθοδο χρησιμοποιήσαμε και στην υλοποίηση μας μειώνοντας έτσι
τη χρήση των διαθέσιμων πόρων. Στην Εικόνα 4. 18 [34] παρουσιάζεται το μπλοκ
διάγραμμα που πραγματοποιεί τους δύο αυτούς μετασχηματισμούς.

Εικόνα 4. 18 Υλοποίηση μετασχηματισμού Inv/MixColumns.

107
4.4.1.3 Μονάδα ελέγχου

Η μονάδα ελέγχου είναι υπεύθυνη για το συγχρονισμό όλου του κυκλώματος. Στην
ουσία δεν είναι τίποτα περισσότερο από έναν μετρητή που την κατάλληλη στιγμή
στέλνει τα απαραίτητα σήματα τόσο στην μονάδα κρυπτογράφησης
αποκρυπτογράφησης όσο και στη μονάδα επέκτασης κλειδιού. Η μονάδα ελέγχου
περιγράφεται στο αρχείο counter.vhd, έχει σαν είσοδο ένα ρολόι Clk, ένα bit Res και ένα
bit U_D και δίνει σαν έξοδο τα σήματα Sel, En, stop, key_sel μήκους ενός bit και το
διάνυσμα count μήκους τεσσάρων bit. Ο έλεγχος των σημάτων γίνεται κάθε φορά στη
θετική ακμή του ρολογιού και η λειτουργία του είναι η ακόλουθη. Ο πρώτος έλεγχος
αφορά την τιμή του bit U_D που σχετίζεται με την λειτουργία που θα πραγματοποιηθεί
(U_D=”0” για κρυπτογράφηση U_D=”1” για αποκρυπτογράφηση ). Στην περίπτωση της
κρυπτογράφησης ελέγχεται αν πρέπει να μηδενιστεί ο μετρητής και να ξεκινήσει η
διαδικασία από την αρχή, κάτι που είναι απαραίτητο με την εισαγωγή ενός νέου
κλειδιού και για το λόγο αυτό το bit Res τροφοδοτείται από το bit newkey. Όσο το Res
παραμένει μηδέν ο μετρητής αυξάνεται μέχρι και την τιμή 10, όσο δηλαδή και το
απαιτούμενο πλήθος γύρων όπου και σταματάει. Ενδιάμεσα στην τιμή 9 όπου πρέπει να
προσπεραστεί ο μετασχηματισμός MixColumns η μονάδα στέλνει το κατάλληλο σήμα
ώστε να δοθεί η σωστή είσοδος στον πολυπλέκτη που βρίσκεται μετά από το τμήμα
InvMixColumns128 και να πραγματοποιηθεί σωστά η διαδικασία.

Η περίπτωση της αποκρυπτογράφησης είναι ιδιαίτερη και αυτό λόγο του ότι για να
ξεκινήσει η διαδικασία αποκρυπτογράφησης πρέπει πρώτα να παραχθεί το 10ο
υποκλειδί και να χρησιμοποιηθεί πρώτο. Για το λόγο αυτό η αρχικοποίηση του μετρητή
γίνεται από το 10 και προστίθεται ένας επιπλέον εσωτερικός μετρητής που θα δώσει
αυτούς τους απαραίτητους 10 κύκλους ρολογιού. Έτσι όταν πρέπει η διαδικασία να
ξεκινήσει από την αρχή μέσω του bit Res και οι δύο μετρητές αρχικοποιούνται στο 10.
Όσο ο εσωτερικός μετρητής μετράει αντίστροφα τα πάντα παραμένουν ανενεργά
δίνοντας χρόνο στην παραγωγή του κλειδιού. Όταν μηδενιστεί αυτός ο μετρητής τότε
ξεκινάει ο κύριος αντίστροφα μέχρι να μηδενιστεί όπου και σταματάει. Αντίστοιχα με τη
διαδικασία κρυπτογράφησης όταν ο μετρητής φτάσει στο 1 στέλνει το κατάλληλο σήμα
ώστε να δοθεί η κατάλληλη είσοδος στον πολυπλέκτη που βρίσκεται μετά από το τμήμα
InvMixColumns128 και να προσπεραστεί ο μετασχηματισμός InvMixColumns.

4.4.1.4 AES-128 υλοποίηση και εξομοίωση

Εφόσον είδαμε την κάθε μονάδα ξεχωριστά θα παρουσιάσουμε στην παρούσα ενότητα
πως αυτές οι μονάδες συνδέονται μεταξύ τους για να υλοποιηθεί ο αλγόριθμος AES.
Παρακάτω στον Πίνακα 4. 5 παρουσιάζονται όλα τα επιμέρους αρχεία που
χρησιμοποιήθηκαν με μια συνοπτική περιγραφή, το μπλοκ διάγραμμα στην Εικόνα 4.
19. που αποτελεί το πλήρες κύκλωμα και στη συνέχεια ένα παράδειγμα εξομοίωσης.

Το κύκλωμα όπως φαίνεται και στην Εικόνα 4. 8 έχει σαν είσοδο το αρχικό κλειδί, το
αρχικό μήνυμα και τα δύο μήκους 128 bits, ένα bit λειτουργίας (Operation), ένα ρολόι
Clk, και ένα bit newkey για την επιλογή νέου κλειδιού και δίνει σαν έξοδο το
κρυπτογράφημα plaintext. Το αρχικό κλειδί οδηγείται στην μονάδα επέκτασης κλειδιού
μαζί με το bit ελέγχου newkey και η διαδικασία παραγωγής των υποκλειδιών ξεκινά. Το
αρχικό μήνυμα οδηγείται στη μονάδα κρυπτογράφησης/αποκρυπτογράφησης μαζί με
το bit Operation και περιμένει τα κατάλληλα σήματα από τη μονάδα ελέγχου ώστε να
ξεκινήσει η διαδικασία. Η μονάδα ελέγχου δέχεται τα σήματα newkey και Operation

108
δίνοντας στην έξοδο τα απαραίτητα σήματα στη μονάδα κλειδιού και στη μονάδα
κρυπτογράφησης/αποκρυπτογράφησης. Στο σημείο αυτό είναι σημαντικό να
αναφέρουμε την τροποποίηση που χρειάζεται το κύκλωμα ώστε να πραγματοποιηθεί η
μέθοδος ισοδύναμης κρυπτογράφησης η οποία δεν είναι τίποτα περισσότερο από μια
προσθήκη της συνάρτησης MixColumn σε κάθε κλειδί. Συγκεκριμένα σε όλα τα κλειδιά
γύρου εκτός από το πρώτο πριν γίνουν xor με την τρέχουσα κατάσταση στο τέλος κάθε
γύρου εφαρμόζεται ο μετασχηματισμός MixColumn και έπειτα προστίθενται. Έτσι στην
έξοδο του κλειδιού υπάρχει μια επιπλέον μονάδα InvMixColumn128 και ένας
πολυπλέκτης που επιλέγει αν θα βγάλει έξοδο τα κλειδιά γύρου ή τα μετασχηματισμένα
κλειδιά (Εικόνα 4. 19). Κάθε φορά η μονάδα ελέγχου στέλνει το σήμα που δείχνει σε
ποιον γύρο βρίσκεται η διαδικασία στη μονάδα κλειδιού, εξάγοντας έτσι τα σωστά
κλειδιά γύρου τα οποία τροφοδοτούνται στη μονάδα
κρυπτογράφησης/αποκρυπτογράφησης. Η τελική κατάσταση σε κάθε γύρο οδηγείται
στην έξοδο ciphertext και μόλις η διαδικασία ολοκληρωθεί η τελική κατάσταση
αποτελεί και το κρυπτοκείμενο.

Αρχείο Περιγραφή
key_pack.vhd Αρχείο που περιλαμβάνει τα τμήματα που
χρησιμοποιούνται για το κλειδί
pack_for_all.vhd Αρχείο που περιλαμβάνει όλα τα τμήματα που
χρησιμοποιούνται
mux_clk.vhd Πολυπλέκτης 2 σε 1 που διατηρεί τα δεδομένα
mux_nbits.vhd Πολυπλέκτης 2 σε 1 μεταβλητού μήκους εισόδου
mux3in1.vhd Πολυπλέκτης 3 σε 1 μεταβλητού μήκους εισόδου
reg_nbits.vhd Καταχωρητής μεταβλητού μήκους εισόδου
ControlKey.vhd Μονάδα ελέγχου που με κατάλληλα σήματα ενεργοποιεί
τις απαραίτητες ενέργειες
KeyExpansion.vhd Αρχείο που υλοποιεί την επέκταση κλειδιού
ShiftRows.vhd Μετάθεση των 128 bits
InvShiftRows.vhd Αντίστροφη μετάθεση των 128 bits
SubBytes.vhd Μετασχηματισμός ενός byte με μη-γραμμική
αντικατάσταση
SubBytes128.vhd Συνδυασμός του SubByte μετασχηματισμού για υλοποίηση
σε 128 bits
InvSubBytes.vhd Αντίστροφος μετασχηματισμός ενός byte με μη-γραμμική
αντικατάσταση
InvSubBytes128.vhd Συνδυασμός του InvSubByte μετασχηματισμού για
υλοποίηση σε 128 bits
x_time.vhd Υλοποίηση πολλαπλασιασμού {02}16 με πολυώνυμο.
x_time4.vhd Υλοποίηση πολλαπλασιασμού {04}16 με πολυώνυμο.
MixColumn_Inv32.vhd Πολλαπλασιασμός στο πεπερασμένο πεδίο GF(28) με
δεδομένο πολυώνυμο. Η υλοποίηση εφαρμόζει και τον
κανονικό μετασχηματισμό MixColumn και τον αντίστροφο
InvMixColumn για 32 bits δεδομένα
InvMixColumn128.vhd Συνδυασμός του MixColumn_Inv32 μετασχηματισμού για
υλοποίηση σε 128 bits

Πίνακας 4. 5 Αρχεία για την υλοποίηση του αλγορίθμου AES-128.

109
Εικόνα 4. 19 Κύκλωμα AES-128.

110
Παράδειγμα εξομοίωσης

Όπως και με την υλοποίηση του κλειδιού χρησιμοποιούμε το CYCLONE II

EP2C35F672C6 FPGA. Η μεταγλώττιση του σχεδίου παρουσιάζεται στον Πίνακα 4. 6.
Παρατηρούμε πως ο αλγόριθμος χρησιμοποιεί συνολικά 6012 λογικά στοιχεία (18%
των συνολικών διαθέσιμων), 1725 καταχωρητές, 391 ακροδέκτες από τους 475 (82%)
και καθόλου μνήμη. Συγκριτικά με την υλοποίηση της επέκτασης κλειδιού που πλέον
συμπεριλαμβάνεται στην πλήρη υλοποίηση του αλγορίθμου, μπορούμε να πούμε πως
ένα μεγάλο τμήμα καταλαμβάνεται από την επέκταση του. Για αυτό το λόγο και σε
πολλές υλοποιήσεις δεν πραγματοποιείται ταυτόχρονα στο ίδιο κύκλωμα αλλά
αποθηκεύεται στη μνήμη. Όμως όπως προαναφέραμε είναι σημαντικό το κλειδί να
υπολογίζεται με κάποιο τρόπο για τυχόν εφαρμογές που απαιτούν συνεχή αλλαγή
κλειδιού κρυπτογράφησης. Τέλος, να αμαφέρουμε πως το συνολικό κύκλωμα, σύμφωνα
με το εργαλείο Classic Timing Analyzer δουλεύει με μέγιστη συχνότητα στα 51,41 Mhz
δηλαδή με περίοδο 19,450 ns.

Μεταγλώτιση σχεδίου
Quartus II Version 7.2 Build 203 02/05/2008 SP 2 SJ Full Version
Top-level Entity Name AES128
Family Cyclone II
Device EP2C35F672C6
Total logic elements 6.012 / 33.216 (18%)
Total combinational functions 5.372 / 33.216(16%)
Dedicated logic registers 1.725 / 33.216(5%)
Total registers 1.725
Total pins 391 / 475 (82%)
Total memory bits 0 / 483.840 (0%)
Embedded Multiplier 9-bit elements 0 / 70 (0%)
Total PLLs 0 / 4 (0%)
Timing Models Final

Πίνακας 4. 6 Αναφορά μεταγλώττισης για τον AES-128.

Εικόνα 4. 20 Λογικά στοιχεία που χρησιμοποιούνται.

111
Εικόνα 4. 21 RTL σχηματικό AES-128.

112
Στην Εικόνα 4. 20 φαίνονται ο χώρος που καταλαμβάνει ο αλγόριθμος στο FPGA και
στην Εικόνα 4. 21 το κύκλωμα που δημιουργεί το Quartus II για την υλοποίηση του. Για
την εξομοίωση του αλγορίθμου σε υλικό θα χρησιμοποιήσουμε τις εισόδους που
εισάγαμε και στην περίπτωση του λογισμικού ώστε να μπορέσουμε να συγκρίνουμε τη
σωστή λειτουργία του. Συνεπώς σαν είσοδο κειμένου θα έχουμε το “hello!!!” που
αντιστοιχεί στο δεκαεξαδικό “68656c6c6f2121210000000000000000” και σαν κλειδί
το “0123456789102030” που αντιστοιχεί στο δεκαεξαδικό
“30313233343536373839313032303330”. Για την περίπτωση της κρυπτογράφησης
θα πρέπει να θέσουμε για ένα παλμό ρολογιού το newkey στην τιμή “1” και έπειτα στο
“0” και την είσοδο Operation στη τιμή “0”. Τα αποτελέσματα παρουσιάζονται στην
Εικόνα 4. 22. Όπως παρατηρούμε σε κάθε γύρο που υποδικνείεται από την έξοδο rnd
παίρνουμε την ενδιάμεση κατάσταση στο τέλος κάθε γύρου και στο τέλος (γύρος 10)
δίνεται η τελική έξοδος του κρυπτοκειμένου που στο παράδειγα μας είναι
“44a1aaa9b2a975290795ae5ca91dc2ef”, που συμφωνεί με τα αποτελέσματα της
υλποίησης σε λογισμικό και της διαδικτυακής υλοποίησης. Στη συνέχεια για να
ελέγξουμε και τη λειτουργία της αποκρυπτογράφησης θα εισάγουμε το κρυπτοκείμενο
στην είσοδο plaintext και θα θέσουμε την είσοδο Operation στην τιμή “1”. Όπως
φαίνεται στην Εικόνα 4. 23 αρχικά ο αλγόριθμος περιμένει για 9 κύκλους ρολογιού και
στον 10ο ξεκινάει η διαδικασία της αποκρυπτογράφησης για να δώσει χρόνο στην
μονάδα απέκτασης κλειδιού να παράγει τα κλειδιά. Πλέον οι γύροι μετριούνται
αντίστροφα με την έξοδο ciphertext στο τέλος του κάθε γύρου να αποτελεί την
κατάσταση γύρου. Έπειτα από 10 γύρους αποκρυπτογράφησης λαμβάνουμε τελικά
σαν έξοδο το αρχικό κείμενο “68656c6c6f2121210000000000000000” που είναι και η
είσοδος που είχαμε εισάγει στην αρχή του παραδείγματος.

Εικόνα 4. 22 Αποτελέσματα εξομοίωσης κρυπτογράφησης.

113
 Εικόνα 4. 23 Αποτελέσματα εξομοίωσης αποκρυπτογράφησης.

4.4.2 AES-128/192/256

Σύμφωνα με το Fips-197 ο αλγόριθμος AES πρέπει να υποστηρίζει κλειδιά μήκους 128,

192 και 256 bits για την κρυπτογράφηση και την αποκρυπτογράφηση των δεδομένων.
Στα πλαίσια της υλοποίησης του αλγορίθμου σε υλικό πραγματοποιήθηκε και μια
υλοποίηση η οποία πραγματοποιεί την κρυπτογράφηση και αποκρυπτογράφηση με την
επιλογή ενός εκ των τριών κλειδιών. Η συγκεκριμένη υλοποίηση βασίζεται στον AES-
128 όμως τροποποιείται κατάλληλα για να μπορεί να υποστηρίξει κλειδιά 128, 192 και
256 και να πραγματοποιεί 10, 12 και 14 γύρους κρυπτογράφησης. Συγκεκριμένα, η
μονάδα κρυπτογράφησης/αποκρυπτογράφησης παραμένει η ίδια καθώς η διαδικασία
δεν αλλάζει ανεξάρτητα από το κλειδί που έχουμε επιλέξει. Αυτό που αλλάζει είναι ο
τρόπος επέκτασης του κλειδιού και οι γύροι που απαιτούνται για την ολοκλήρωση της
κάθε διαδικασίας. Άρα αυτά που πρέπει να τροποποιηθούν κατάλληλα είναι η μονάδα
παραγωγής του κλειδιού, η μονάδα ελέγχου και να προστεθεί μια είσοδος για την
επιλογή του αλγορίθμου.

4.4.2.1 Μονάδα παραγωγής κλειδιού

Η μονάδα παραγωγής κλειδιού πρέπει πλέον να υποστηρίζει και τα τρία κλειδιά μήκους
128, 192 και 256 αντίστοιχα. Οι συναρτήσεις που χρησιμοποιούνται σε σύγκριση με τη
μονάδα παραγωγής του αλγορίθμου AES-128 είναι οι ίδιες. Αυτό που διαφέρει είναι ο
τρόπος που γίνεται η διασύνδεση μεταξύ των καταχωρητών και των πολυπλεκτών που

114
Αρχείο Περιγραφή
KeyExpansion.vhd Υλοποιεί την παραγωγή των κλειδιών
Keypack.vhd Πακέτο που περιλαμβάνει όλα τα επιμέρους τμήματα που
χρησιμοποιούνται
ControlKey.vhd Μονάδα ελέγχου που με κατάλληλα σήματα ενεργοποιεί
τις απαραίτητες ενέργειες
mux_nbits.vhd 2 σε 1 πολυπλέκτης μεταβλητού μήκους εισόδου
mux3in1.vhd Πολυπλέκτης 3 σε 1 μεταβλητού μήκους εισόδου
reg_nbits.vhd Καταχωρητής μεταβλητού μήκους εισόδου
SubBytes.vhd Μετασχηματισμός ενός byte με μη-γραμμική
αντικατάσταση
RotWord.vhd Ολίσθηση δεδομένων

Πίνακας 4. 7 Αρχεία vhd για την παραγωγή κλειδιών.

διαθέτει το κύκλωμα και η μονάδα ελέγχου. Για τη συγκεκριμένη υλοποίηση η είσοδος

του κλειδιού είναι μήκους 256 bits, το μέγιστο δηλαδή που μπορεί να δεχθεί και η
έξοδος 128 bits, όσο δηλαδή ένα κλειδί γύρου. Πέρα από τις εισόδους newkey, Clk, και
round που τις συναντήσαμε και στην επέκταση κλειδιού 128 bits, υπάρχει μια επιπλέον
είσοδος key_sel μήκους 2 bits που χρησιμεύει στην επιλογή του κλειδιού. Στην Εικόνα 4.
24 παρουσιάζεται το μπλοκ διάγραμμα για τη μονάδα παραγωγής των κλειδιών και
στον Πίνακα 4. 7 τα αρχεία που έχουν χρησιμοποιηθεί.

Αρχικά στη μονάδα εισέρχεται το κλειδί που έχει επιλεγεί. Η είσοδος είναι μήκους 256
bits και χωρίζεται σε οκτώ λέξεις των 32 bits και εισάγονται σε οκτώ πολυπλέκτες. Αν
το κλειδί είναι μήκους 128 bits, τότε γεμίζουν τα 128 λιγότερο σημαντικά ψηφία και τα
υπόλοιπα συμπληρώνονται με μηδενικά, αντίστοιχα συμβαίνει και στο κλειδί των 192
bits. Μαζί με το κλειδί έρχεται και το bit newkey, που όπως έχουμε ξανά αναφέρει
ξεκινάει τη διαδικασία από την αρχή μηδενίζοντας τη μονάδα ελέγχου του κλειδιού, ένα
ρολόι Clk, το διάνυσμα round που υποδεικνύει ποιο κλειδί γύρου πρέπει να οδηγηθεί
στην έξοδο και μια νέα επιλογή key_sel μήκους δύο bits. Με την είσοδο αυτή επιλέγεται
ποιό κλειδί έχει επιλεγεί έτσι ωστέ να γίνει η σωστή επέκταση του. Οι δυνατές τιμές που
μπορεί να πάρει είναι “00” ή “01” για κλειδί 128 bits, “10” για κλειδί 192 bits και “11” για
κλειδί 256 bits. Η είσοδος αυτή οδηγείται στην μονάδα ελέγχου όπου αρχικοποιεί
κατάλληλα τους πολυπλέκτες και τους καταχωρητές που θα αποθηκευτούν τα κλειδιά
γύρου και στις εισόδους ενέργοποίησης των τεσσάρων αριστερότερων πολυπλεκτών
(Εικόνα 4. 24 για AES128 ενεργοποιούνται οι τέσσεροι δεξιότεροι, για AES192 οι έξι
δεξιότεροι και για AES256 όλοι οι πολυπλέκτες). Με αυτόν τον τρόπο ανάλογα με το
μέγεθος του κλειδιού έχουμε και τους απαραίτητους πολυπλέκτες. Οι πολυπλέκτες στη
μια τους είσοδο δέχονται το αρχικό κλειδί και στην άλλη την επεκτεταμμένη λέξη. Στην
περίπτωση των κλειδιών 192 και 256 οι επεκτεταμμένες λέξεις είναι 6 και 8 αντίστοιχα
όμως τα δεδομένα που απαιτούνται για τον υπολογισμό των νέων λέξεων από τον
προηγούμενο γύρο χάνονται. Για το λόγο αυτό στην έξοδο κάθε πολυπλέκτη έχει
προστεθεί ένας καταχωρητής που περιέχει τα δεδομένα του προηγούμενου γύρου και
ένας νέος πολυπλέκτης με εισόδο την έξοδο του αρχικού πολυπλέκτη και την έξοδο του
καταχωρητή (για το κλειδί 192 υπάρχουν δύο επιπλέον τέτοιοι καταχωρητές). Έτσι
ανάλογα με την επιλογή του κλειδιού και τα σήματα από τη μονάδα ελέγχου
επιλέγονται ποιες έξόδους θα δώσει ο κάθε πολυπλέκτης. Για παράδειγμα στην
περίπτωση του κλειδιού των 128 bits, οι τέσσεροι δεξιότεροι πολυπλέκτες δίνουν σαν
έξοδο την έξοδο του αρχικού πολυπλέκτη όπως και στην επέκταση κλειδιού του AES-
128, ενώ για κλειδί 192 και 256 δίνουν σαν έξοδο τα δεδομένα των καταχωρητών.

115
Εικόνα 4. 24 Μπλοκ διάγραμμα για τη μονάδα παραγωγής κλειδιών.

116
Επιπλέον συμφωνα με το Fips-197 η πρώτη λέξη αφού δεχθεί τους μετασχηματισμούς
RotWord, SubWord και xor με τη σταθερά RCon, πρέπει να γίνει xor με την τελευταία
λέξη. Στην περίπτωση του κλειδιού των 256 bits απλά υλοποιείται η πράξη πριν την
είσοδο της στον καταχωρητή στις περιπτώσεις όμως των άλλων δύο κλειδιών δεν
μπορεί να γίνει η πράξη απευθείας γιατί κάτι τέτοιο θα επηρεάσει τα δεδομένα για το
κλειδί 256. Για το λόγο αυτό προστίθενται δυο νέοι πολυπλέκτες που έχουν σαν
είσοδους τα μετασχηματισμένα δεδομένα της πρώτης λέξης και τη μετασχηματισμένη
λέξη του επόμενου καταχωρητή (Εικόνα 4. 24). Τέλος μια σημαντική προσθήκη για την
περίπτωση της επέκτασης του κλειδιού των 256 bits είναι ο μετασχηματισμός SubWord
που πρέπει να πραγματοποιείται σε κάθε τέταρτη λέξη. Αυτό επιτυγχάνεται με την
είσοδο του μετασχηματισμού που παίρνει σαν είσοδο τα δεδομένα του πέμπτου
πολυπλέκτη και ενός επιπλέον πολυπλέκτη που δίνει σαν έξοδο είτε τα
μετασχηματισμένα δεδομένα (για 256 bits κλειδί) ή τα δεδομένα του τρίτου
πολυπλέκτη (για κλειδιά 128 και 192).

Η διαδικασία επαναλαμβάνεται για όσους γύρους απαιτείται και ελέγχεται κάθε φορά
από τη μονάδα ελέγχου, με τα αποτελέσματα να αποθηκεύονται σε κάθε γύρο σε
καταχωρητές μήκους 32 bits. Τα δεδομένα των καταχωρητών οδηγούνται κάθε φορά
σε 14 καταχωρητες μήκους 128 bits που θα αποτελέσουν και τα κλειδιά γύρου. Η
μονάδα ελέγχου πέρα από τα κατάλληλα σήματα για τη σωστή λειτουργία της
επέκτασης, είναι υπεύθυνη και σε ποιόν από τους 14 καταχωρητές θα αποθηκεύονται
τα δεδομένα κάθε φορά.

Παράδειγμα εξομοίωσης

Για την εξομοίωση της επέκτασης κλειδιού χρησιμοποιήσαμε ως συσκευή στόχου το

CYCLONE II EP2C35F672C6 FPGA. Η μεταγλώττιση του σχεδίου παρουσιάζεται στον
Πίνακα 4. 8. Όπως παρατηρούμε το συνολικό κύκλωμα χρησιμοποιεί 8.126 λογικά
στοιχεία, το 24% δηλαδή των διαθέσιμων και 3.832 καταχωρητές (12%). Από τους 475
ακροδέκτες χρησιμοποιούνται οι 392 (83%) και το κύκλωμα δεν χρησιμοποιεί bit
μνήμης. Καταλαμβάνει συνεπώς ένα μικρό κομμάτι των διαθέσιμων πόρων αλλά έναν
μεγάλο αριθμό ακροδεκτών. Τέλος το κύκλωμα δουλεύει με συχνότητα ρολογιού στα
50,83 MHz δηλαδή με περίοδο 19,675 ns.

Μεταγλώτιση σχεδίου
Quartus II Version 7.2 Build 203 02/05/2008 SP 2 SJ Full Version
Top-level Entity Name KeyExpansion
Family Cyclone II
Device EP2C35F672C6
Total logic elements 8.126 / 33.216 (24%)
Total combinational functions 7.903 / 33.216(24%)
Dedicated logic registers 3.832 / 33.216(12%)
Total registers 3.382
Total pins 392 / 475 (83%)
Total memory bits 0 / 483.840 (0%)
Embedded Multiplier 9-bit elements 0 / 70 (0%)
Total PLLs 0 / 4 (0%)
Timing Models Final

Πίνακας 4. 8 Αναφορά μεταγλώττισης για την επέκταση κλειδιού.

117
Για την επιβεβαίωση της ορθής λειτουργίας της επέκτασης του κάθε κλειδιού θα
ελέγξουμε τα κλειδιά που δίνονται στο Fips-197.

Επέκταση κλειδιού 128 bits

Κλειδί: 2b7e151628aed2a6abf7158809cf4f3c

Εικόνα 4. 25 Αποτελέσματα εξομοίωσης για την επέκταση κλειδιού 128 bits.

Επέκταση κλειδιού 192 bits

Κλειδί: 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b

Εικόνα 4. 26 Αποτελέσματα εξομοίωσης για την επέκταση κλειδιού 192 bits.

118
Επέκταση κλειδιού 256 bits

Κλειδί: 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4

Εικόνα 4. 27 Αποτελέσματα εξομοίωσης για την επέκταση κλειδιού 256 bits.

Από τα παραπάνω αποτελέσματα επιβεβαιώνεται η σωστή λειτουργία του

κυκλώματος. Παρατηρούμε πως κάθε φορά μαζί με το κλειδί και το bit newkey πρέπει
να αλλάζει και η επιλογή key_sel ώστε να πραγματοποιείται κάθε φορά η σωστή
διαδικασία.

4.4.2.2 Μονάδα ελέγχου

Η μονάδα ελέγχου όπως έχουμε αναφέρει είναι υπεύθυνη για τη σωστή λειτουργία του
κυκλώματος κρυπτογράφησης και για τη σωστή έξοδο των κλειδιών γύρων. Για την
περίπτωση της υλοποίησης των τριών αλγορίθμων αναπτύχθηκαν τρεις μονάδες
ελέγχου, μια για τον AES-128, μια για τον AES-192 και μια για τον AES-256. Η λογική και
ο τρόπος λειτουργίας της είναι ακριβώς ίδια με την υλοποίηση της μονάδας ελέγχου
στον αλγόριθμο AES-128. Αποτελεί, δηλαδή έναν μετρητή που απαριθμεί ως το 10 (AES-
128), 12 (AES-192) και 14 (AES-256) δίνοντας ως έξοδο τα κατάλληλα σήματα. Η μόνη
προσθήκη που έχει πραγματοποιηθεί είναι μια είσοδος ενεργοποίησης Start όπου όταν
έχει την τιμή “1” δίνει τις κατάλληλες τιμές στα σήματα εξόδου και όταν έχει την τιμή
“0” μηδενίζει τις εξόδους. Έτσι από κάθε μεμονωμένη μονάδα ελέγχου παίρνουμε κάθε
φορά όλα τα σήματα (Sel, En, stop, key_sel, count). Τα σήματα αυτά της κάθε μονάδας
γίνονται xor με τα αντίστοιχα σήματα των άλλων μονάδων και οδηγούνται στο
υπόλοιπο κύκλωμα. Με αυτόν τον τρόπο όταν είναι ενεργή μια από τις τρεις μονάδες
μόνο τα δικά της σήματα θα οδηγηθούν στο κύκλωμα καθώς τα σήματα από τις άλλες
μονάδες θα είναι “0”.

119
4.4.2.3 AES-128/192/256 υλοποίηση και εξομοίωση

Όπως και στην περίπτωση του AES-128 οι τρείς συνδυάζονται κατάλληλα και
υλοποιούν το πλήρες κύκλωμα για την κρυπτογράφηση και αποκρυπτογράφηση των
δεδομένων. Στον Πίνακα 4. 9 παρουσιάζονται όλα τα επιμέρους αρχεία που
χρησιμοποιήθηκαν και στην Εικόνα 4. 28 το μπλοκ διάγραμμα του κυκλώματος.

Αρχείο
key_pack.vhd
pack_for_all.vhd
mux_clk.vhd
mux_nbits.vhd
mux3in1.vhd
reg_nbits.vhd
ControlKey.vhd
KeyExpansion.vhd
counter_128.vhd
counter_192.vhd
counter_256.vhd
ShiftRows.vhd
InvShiftRows.vhd
SubBytes.vhd
SubBytes128.vhd
InvSubBytes.vhd
InvSubBytes128.vhd
x_time.vhd
x_time4.vhd
MixColumn_Inv32.vhd
InvMixColumn128.vhd
AES_128_192_256.vhd
Περιγραφή
Αρχείο που περιλαμβάνει τα τμήματα που
χρησιμοποιούνται για το κλειδί
Αρχείο που περιλαμβάνει όλα τα τμήματα που
χρησιμοποιούνται
Πολυπλέκτης 2 σε 1 που διατηρεί τα δεδομένα
Πολυπλέκτης 2 σε 1 μεταβλητού μήκους εισόδου
Πολυπλέκτης 3 σε 1 μεταβλητού μήκους εισόδου
Καταχωρητής μεταβλητού μήκους εισόδου
Μονάδα ελέγχου που με κατάλληλα σήματα ενεργοποιεί
τις απαραίτητες ενέργειες
Αρχείο που υλοποιεί την επέκταση κλειδιού
Μονάδα ελέγχου για αλγόριθμο AES-128
Μονάδα ελέγχου για αλγόριθμο AES-192
Μονάδα ελέγχου για αλγόριθμο AES-256
Μετάθεση των 128 bits
Αντίστροφη μετάθεση των 128 bits
Μετασχηματισμός ενός byte με μη-γραμμική
αντικατάσταση
Συνδυασμός του SubByte μετασχηματισμού για υλοποίηση
σε 128 bits
Αντίστροφος μετασχηματισμός ενός byte με μη-γραμμική
αντικατάσταση
Συνδυασμός του InvSubByte μετασχηματισμού για
υλοποίηση σε 128 bits
Υλοποίηση πολλαπλασιασμού {02}16 με πολυώνυμο.
Υλοποίηση πολλαπλασιασμού {04}16 με πολυώνυμο.
Πολλαπλασιασμός στο πεπερασμένο πεδίο GF(28) με
δεδομένο πολυώνυμο. Η υλοποίηση εφαρμόζει και τον
κανονικό μετασχηματισμό MixColumn και τον αντίστροφο
InvMixColumn για 32 bits δεδομένα
Συνδυασμός του MixColumn_Inv32 μετασχηματισμού για
υλοποίηση σε 128 bits
Αρχείο που πραγματοποιεί την κατάλληλη συνδεσμολογία
και υλοποιεί τον πλήρη αλγόριθμο

Πίνακας 4. 9 Αρχεία για την υλοποίηση του αλγορίθμου AES128/192/256.

120
Εικόνα 4. 28 Κύκλωμα AES_128_192_256.

121
Η διαδικασία κρυπτογράφησης/αποκρυπτογράφησης είναι εφάμιλλη αυτής του
αλγορίθμου AES-128, το αρχικό κείμενο εισέρχεται στο κύκλωμα μαζί με το κλειδί και
τον τύπο του αλγορίθμου που θα χρησιμοποιηθεί (algorithm). Το bit newkey
σηματοδοτεί την έναρξη για την παραγωγή των κλειδιών και ο συνδυασμός της
εισόδου algorithm (algorithm(1), algorithm(0)) ενεργοποιεί την κατάλληλη μονάδα
ελέγχου για να δοθούν τα σωστά σήματα στο κυρίως σώμα του αλγορίθμου και στην
επέκταση κλειδιού. Η διαδικασία επαναλαμβάνεται για όσους γύρους χρειάζεται
μέχρις ότου δοθούν τα κατάλληλα σήματα όπου σταματάει και εξάγει το τελικό
κρυπτοκείμενο.

Παράδειγμα εξομοίωσης

Για την υλοποίηση του κυκλώματος που υποστηρίζει και τους τρείς αλγορίθμους
ταυτόχρονα χρησιμοποιήθηκε το CYCLONE III EP3C120F780C8 FPGA και αυτό γιατί
οι 475 ακροδέκτες του CYCLONE II EP2C35F672C6 FPGA δεν ήταν αρκετοί καθώς
πλέον χρειαζόμαστε 256 ακροδέκτες για το κλειδί 128 ακροδέκτες για το αρχικό
κείμενο και 128 ακροδέκτες για το κρυπτοκείμενο, δηλαδή περισσότερους από 512
ακροδέκτες. Όπως φαίνεται και στον Πίνακα 4. 10 το κύκλωμα χρησιμοποιεί 12.192
λογικά στοιχεία (10% των διαθέσιμων για το συγκεκριμένο FPGA) 3.993
καταχωρητές (3%) και 521 ακροδέκτες (98%) και με μέγιστη συχνότητα ρολογιού
στα 25,73 MHz. Παρατηρούμε πως ο αλγόριθμος καταλαμβάνει ένα πολύ μικρό μέρος
των διαθέσιμων πόρων του συγκεκριμένου συστήματος αλλά σχεδόν όλους τους
διαθέσιμους ακροδέκτες. Ίσως χρησιμοποιώντας έναν διαφορετικό τρόπο στον
χειρισμό των δεδομένων να μπορούσαμε να ελαττώσουμε τον αριθμό των
ακροδεκτών και να μπορούσαμε να χρησιμοποιήσουμε ένα μικρότερο FPGA, όμως στα
πλαίσια της ερευνητικής εργασίας κάτι τέτοιο δεν ήταν αναγκαίο.

Μεταγλώτιση σχεδίου
Quartus II Version 7.2 Build 203 02/05/2008 SP 2 SJ Full Version
Top-level Entity Name AES_128_192_256
Family Cyclone III
Device EP3C120F780C8
Total logic elements 12.192 / 119.088 (10%)
Total combinational functions 11.704 / 119.088(10%)
Dedicated logic registers 3.993/ 119.088 (3%)
Total registers 3.993
Total pins 521 / 532 (98%)
Total memory bits 0 / 3.981.312 (0%)
Embedded Multiplier 9-bit elements 0 / 576 (0%)
Total PLLs 0 / 4 (0%)
Timing Models Final

Πίνακας 4. 10 Αναφορά μεταγλώττισης για τον AES_128_192_256.

122
 Εικόνα 4. 29 Λογικά στοιχεία που χρησιμοποιούνται.

Στην Εικόνα 4. 29 φαίνονται ο χώρος που καταλαμβάνει ο αλγόριθμος στο FPGA και
στην Εικόνα 4. 30 το κύκλωμα που δημιουργεί το Quartus II για την υλοποίηση του.
Για την εξομοίωση του αλγορίθμου σε υλικό και για τον έλεγχο του θα
χρησιμοποιήσουμε τα δεδομένα που δίνονται στο Fips-197 (Πίνακας 4. 11).

Αλγόριθμος Κείμενο Κλειδί Κρυπτοκείμενο

AES-128 00112233445566778899 000102030405060708090a 69c4e0d86a7b0430d8cd
Nk=4, Nr=10 aabbccddeeff 0b0c0d0e0f b78070b4c55a
AES-192 00112233445566778899 000102030405060708090a0 dda97ca4864cdfe06eaf70
Nk=6, Nr=12 aabbccddeeff b0c0d0e0f1011121314151617 a0ec0d7191
AES-256 00112233445566778899 000102030405060708090 8ea2b7ca516745bfeafc49
Nk=8, Nr=14 aabbccddeeff a0b0c0d0e0f10111213141 904b496089
5161718191a1b1c1d1e1f

Πίνακας 4. 11 Δεδομένα για την εξομοίωση των αλγορίθμων.

123
Εικόνα 4. 30 RTL σχηματικό AES_128_192_256.

124
Αποτελέσματα εξομοίωσης

AES-128

Στην Εικόνα 4. 31 παρατηρούμε πως έχουν δοθεί οι επιλογές algorithm “0” για να
χρησιμοποιηθεί ο AES-128 και Operation “0” για να γίνει κρυπτογράφηση. Στην
Εικόνα 4. 32 η είσοδος Operation παίρνει την τιμή “1” για αποκρυπτογράφηση και σαν
κείμενο δίνεται το κρυπτοκείμενο.

Εικόνα 4. 31 Αποτελέσματα εξομοίωσης κρυπτογράφησης για τον AES-128.

Εικόνα 4. 32 Αποτελέσματα εξομοίωσης αποκρυπτογράφησης για τον AES-128.

125
AES-192

Στην Εικόνα 4. 33 παρατηρούμε πως έχουν δοθεί οι επιλογές algorithm “2” για να
χρησιμοποιηθεί ο AES-192 και Operation “0” για να γίνει κρυπτογράφηση. Στην
Εικόνα 4. 34 η είσοδος Operation παίρνει την τιμή “1” για αποκρυπτογράφηση και σαν
κείμενο δίνεται το κρυπτοκείμενο.

Εικόνα 4. 33 Αποτελέσματα εξομοίωσης κρυπτογράφησης για τον AES-192.

Εικόνα 4. 34 Αποτελέσματα εξομοίωσης αποκρυπτογράφησης για τον AES-192.

126
AES-256

Στην Εικόνα 4. 35 παρατηρούμε πως έχουν δοθεί οι επιλογές algorithm “3” για τον
AES-192 και Operation “0” για να γίνει κρυπτογράφηση. Στην Εικόνα 4. 36 η είσοδος
Operation παίρνει την τιμή “1” για αποκρυπτογράφηση και σαν κείμενο δίνεται το
κρυπτοκείμενο.

Εικόνα 4. 35 Αποτελέσματα εξομοίωσης κρυπτογράφησης για τον AES-256.

Εικόνα 4. 36 Αποτελέσματα εξομοίωσης αποκρυπτογράφησης για τον AES-256.

127
128
 5.Συμπεράσματα

Στη παρούσα εργασία ασχοληθήκαμε με την επιστήμη της κρυπτογραφίας και την
εξέλιξη της στο πέρασμα των αιώνων. Είδαμε τις μεθόδους που χρησιμοποιήθηκαν
από τις πρώτες εφαρμογές της ως τη σύγχρονη κρυπτογραφία. Παρουσιάστηκαν
διάφοροι αλγόριθμοι κρυπτογράφησης και δόθηκε ιδιαίτερη έμφαση στους
συμμετρικούς αλγορίθμους και ιδιαίτερα στον αλγόριθμο AES που ήταν και το κυρίως
θέμα της εργασίας. Είδαμε αναλυτικά τον τρόπο με τον οποίο ο αλγόριθμος
κρυπτογραφεί και αποκρυπτογραφεί τα δεδομένα και τους μετασχηματισμούς που
χρησιμοποιεί σε κάθε διαδικασία.

Στη συνέχεια έγινε μια προσπάθεια για υλοποίηση του αλγορίθμου τόσο σε επίπεδο
λογισμικού όσο και σε επίπεδο υλικού, παρουσιάζοντας κάθε φορά τα πλεονεκτήματα
και τα μειονεκτήματα της εκάστοτε μεθόδου. Αναπτύχθηκε ένα πρόγραμμα σε C++
και σε επέκταση του αναρτήθηκε στο διαδίκτυο, στο οποίο εισάγοντας τα επιθυμητά
δεδομένα και ένα κλειδί κρυπτογράφησης μπορεί κάποιος να δει τη διαδικασία και τα
ενδιάμεσα βήματα που χρησιμοποιεί ο αλγόριθμος. Στη συνέχεια είδαμε την
υλοποίηση του αλγορίθμου σε υλικό. Χρησιμοποιώντας το σχεδιαστικό εργαλείο
Quartus II αναπτύχθηκαν δύο κυκλώματα σε επίπεδο εξομοίωσης στα οποία δίνοντας
τις επιθυμητές επιλογές και εισόδους πραγματοποιούνταν η κρυπτογράφηση και
αποκρυπτογράφηση των δεδομένων.

Τέλος, θα μπορούσαμε να αναφέρουμε σαν μελλοντικές εργασίες την ανάπτυξη κι

άλλων αλγορίθμων κρυπτογράφησης ή ακόμα και τον συνδυασμό διαφορετικών
αλγορίθμων σε μια υλοποίηση, την ανάπτυξη και άλλων μεθόδων λειτουργίας των
κωδικοποιητών τμημάτων, πέρα της ECB που εφαρμόστηκε στην παρούσα εργασία,
την υλοποίηση των μετασχηματισμών που χρησιμοποιεί ο AES με διαφορετικές
μεθόδους με σκοπό τη μεταξύ τους σύγκριση. Επιπλέον, οι υλοποιήσεις μπορούν να
αναπτυχθούν και με διαφορετικές γλώσσες προγραμματισμού όπως C, Java, PhP κ.α.
και σε διαφορετικές πλατφόρμες υλικού όπως VLSI, DSPs, μCs κ.α.

129
130
 Αναφορές

1. FIPS-197 : “Announcing the Advanced Encryption Standard (AES)”, National

Institute of Standards and Technology (NIST), November 2001

2. J. Daemen and V. Rijmen, “AES Proposal: Rijndael”, AES Algorithm Submission,

September 3, 1999

3. AES page available

http://www.nist.gov/CryptoToolkit

4. AES Calculator
http://www.unsw.adfa.edu.au/~lpb/src/AEScalc/AEScalc.html

5. Andrew S. Tanenmaum , “Δίκτυα Υπολογιστών” 4η έκδοση, Κλειδάριθμος, 2003

6. “Κρυπτογραφία”,
http://el.wikipedia.org/wiki/%CE%9A%CF%81%CF%85%CF%80%CF%84%CE
%BF%CE%B3%CF%81%CE%B1%CF%86%CE%AF%CE%B1

7. Mihir Bellare, Phillip Rogaway, “Introduction to Modern Cryptography”, CSE207,

May 2005

8. “ΒΑΣΙΚΑ ΘΕΜΑΤΑ ΚΡΥΠΤΟΓΡΑΦΙΑΣ”,

http://www.ct.aegean.gr

9. A. J. Menezes, P. C. van Oorschot, S. A. Vanstone, “Handbook of Applied

Cryptography”, CRC Press, 1997

10. Βασίλειος Ζορκάδης , “Θεωρία Πληροφορίας και Κωδικοποίησης”, ΕΑΠ, 2002

11. “Κρυπτοσύστημα μετάθεσης”

http://en.wikipedia.org/wiki/Transposition_cipher

12. “Κρυπτοσύστημα αντικατάστασης”

http://en.wikipedia.org/wiki/Substitution_cipher

13. Bruce Schneier, “Applied Cryptography” 2η έκδοση, John Wiley & Sons, 1996

14. Wade Trappe, Lawrence C. Washington, “Introduction to Cryptography with

Coding Theory”, Pearson Education, 2002

15. Wenbo Mao, “Modern Cryptography: Theory and Practice”, Prentice Hall, 2003

16. Β.Α. Κάτος, Γ.Χ. Σταφανίδης, “Τεχνικές κρυπτογραφίας και κρυπτανάλυσης”,

Ζυγός, 2003

17. William Stallings, “Cryptography and Network Security: Principles and Practice”
4η έκδοση, Prentice Hall, 2005

131
18. Nigel Smart, “Cryptography: An Introduction” 3η έκδοση, Mcgraw-Hill College,
2002

19. “Μέθοδοι γεμίσματος”

http://en.wikipedia.org/wiki/Padding_(cryptography)

20. “Κωδικοποιητές τμημάτων”

http://en.wikipedia.org/wiki/Block_ciphers

21. “Σύγκριση αλγορίθμων”

http://www.kellermansoftware.com/t-ArticleStrongestAlgo.aspx

22. “An Introduction to Cryptography”

http://www.mavi1.org/web_security/cryptography/pgp/pgp_pdf_files/IntrotoC
rypto.pdf

23. “Πλεονεκτήματα – μειονεκτήματα συμμετρικής – ασύμμετρης κρυπτογραφίας”

http://www.islab.demokritos.gr/gr/html/ptixiakes/kostas-
aris_ptyxiakh/Phtml/kruptografia.htm

24. “Σύγκριση συμμετρικών – ασύμμετρων κρυπτοσυστημάτων”

http://voices.yahoo.com/comparing-symmetric-asymmetric-key-encryption-
6329400.html

25. Edward Schaefer, “An introduction to cryptography and cryptanalysis

26. Βασίλειος Ζορκάδης, “Το πρότυπο συμμετρικό κρυπτογραφικό σύστημα AES

(Advanced Encryption Standard)”

27. “Εφαρμογές AES”

http://en.wikipedia.org/wiki/AES_implementations

28. P.R. Chodowiec, “Comparison of the Hardware Performance of the AES Candidates
Using Reconfigurable Hardware”, 2002

29. A.J Elbirt, W. Yip, B. Chetwynd, C. Paar, “An FPGA-Based Performance Evaluation
of the AES Block Cipher Candidate Algorithm Finalists”, The Third Advance
Encryption Standard (AES3) Candidate Conference, 2000

30. N.A. Saqib, A. D.Perez, C. K. Koc, “Cryptographic Algorithms on Reconfigurable

Hardware”, Springer Science, 2006

31. T. Wolliger, J. Guajardo, C. Paar, “Cryptography on FPGAs: State of the Art

Implementations and Attacks”, ACM Transactions on Embedded Computing
Systems, 2003

32. E. Mui , “Practical Implementation of Rijndael S-Box Using Combinational Logic”,

2004

33. R. R. Rachh, P.V.Ananda Mohan, B.S. Anami, “Efficient Implementations for AES
Encryption and Decryption”, Springer Science & Business Media, LLC 2012

34. X. Zhang, K. K. Parhi, “High-Speed VLSI Architectures for the AES Algorithm IEEE
Transactions on Very Large Scale Integration(VLSI) Systems, Vol.12, No. 9, 2004

132
35. M.C. Libertatori, J.C. Bonadero, “AES-128 Chipher. Minimum Area, Low Cost FPGA
Implementation”, 2007

36. T. Good, M. Benaissa, “AES on FPGA from the Fastest to the Smallest”, Springer,
2005

37. F. Charot, E. Yahya, C. Wagner, “Efficient Modular-Pipelined AES Implementation

in Counter Mode on ALTERA FPGA”, Springer, 2003

38. P. Noo-intara, S. Chantarawong, S. Choomchuay, “Architectures for MixColumn

Transform for the AES”, 2004

39. M. McLoone , J. V. McCanny, “Single-Chip FPGA Implementation of the Advanced

Encryption Standard Algorithm”, Springer, 2001

40. Φλωκατούλα Δώρα, “Συμμετρικοί Αλγόριθμοι Κρυπτογράφησης Δεδομένων – Οι

περιπτώσεις των αλγορίθμων DES και TDEA”, 2012

133
134
 Παράρτημα Α

Στο σημείο αυτό δίνεται ο κώδικας C++ για υλοποίηση σε λογισμικό.

Αρχείο SBoxes.cpp

unsigned char Sbox [256]= {

0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67,
0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59,
0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7,
0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1,
0x71, 0xD8, 0x31, 0x15, 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05,
0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83,
0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29,
0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA,
0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C,
0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC,
0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC,
0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19,
0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE,
0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49,
0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4,
0xEA, 0x65, 0x7A, 0xAE, 0x08, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6,
0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70,
0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9,
0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E,
0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1,
0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0,
0x54, 0xBB, 0x16};

unsigned char InvSbox [256]= {

0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3,
0x9E, 0x81, 0xF3, 0xD7, 0xFB, 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F,
0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, 0x54,
0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B,
0x42, 0xFA, 0xC3, 0x4E, 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24,
0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, 0x72, 0xF8,
0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D,
0x65, 0xB6, 0x92, 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84, 0x90, 0xD8, 0xAB,
0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3,
0x45, 0x06, 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1,
0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B, 0x3A, 0x91, 0x11, 0x41,
0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6,
0x73, 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9,
0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E, 0x47, 0xF1, 0x1A, 0x71, 0x1D,
0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,

135
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0,
0xFE, 0x78, 0xCD, 0x5A, 0xF4, 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07,
0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F, 0x60,
0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F,
0x93, 0xC9, 0x9C, 0xEF, 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5,
0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2B,
0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55,
0x21, 0x0C, 0x7D};

unsigned char RCon [11]= { 0x00, 0x01, 0x02, 0x04,0x08, 0x10, 0x20,
0x40,0x80, 0x1b, 0x36};

AES.cpp

#include "Sboxes.cpp"
#include <iostream>

using namespace std;

int count,c,k,Nw,Nk,Nr,Nb,r;
unsigned char
state[4][4],Key[4][8],input[1000]={0},*key,*plaintext,arr[16],round
key[4][4],**extendedkey,temp[4],temp2[4][4],select;

unsigned char vec2mat_key (unsigned char *vec,int length,unsigned

char mat[4][8]){

int col_num=length/4;

for (int i=0; i<4; i++)

for (int j=0; j<col_num; j++)
mat[i][j]=vec[i+4*j];
return mat[4][8];
}

unsigned char vec2mat (unsigned char *vec,int length,unsigned char

mat[4][4]){

int col_num=length/4;

for (int i=0; i<4; i++)

for (int j=0; j<col_num; j++)
mat[i][j]=vec[i+4*j];
return mat[4][4];
}

unsigned char mat2vec (unsigned char mat[4][4],int col_num,unsigned

char vec[16]){

int length=4*col_num;

for (int i=0; i<length; i++)

vec[i]=mat[i%4][i/4];
return vec[16];
}

136
void printmatrix (unsigned char print[4][4]){

for (int j=0; j<sizeof print[0] /sizeof print[0][0]; j++)

for (int i=0; i<sizeof print/sizeof print[0][0]; i++){
printf("%02x", print[i][j]);
}
cout << "\n\n";}

unsigned char RotWord (unsigned char RotWord_in[4]) {

unsigned char a;

a = RotWord_in[0];

for(int i=0;i<3;i++)
RotWord_in[i] = RotWord_in[i + 1];
RotWord_in[3] = a;
return RotWord_in[4];
}

unsigned char SubWord (unsigned char SubWord_in[4])

{
for (int i=0; i<4; i++)
SubWord_in[i]=Sbox[SubWord_in[i]];
return SubWord_in[4];
}

void SetRoundKey (int r)

{
for (int i=0; i<4; i++)
for (int j=0; j<4; j++)
roundkey[i][j]=extendedkey[i][j+4*r];
}

void KeyExpansion (unsigned char Key[4][8])

{
extendedkey=new unsigned char *[4];

for (int i=0; i<4; i++)

extendedkey[i]=new unsigned char [Nw];

for (int i=0; i<4; ++i){

for (int j=0; j<Nk; ++j)
extendedkey[i][j]=Key[i][j];
}
for (int j = Nk; j < Nw; j++){
for (int i=0; i<4; ++i)
temp[i] = extendedkey[i][j-1];

if (j%Nk == 0)
{
RotWord(temp);
SubWord(temp) ;
temp [0]= temp[0] ^ RCon[j/Nk];

for (int i=0; i<4; ++i)

extendedkey[i][j] = extendedkey[i][j - Nk]^temp[i];
}
else if (Nk==8 && j%Nk==4){
SubWord(temp) ;

137
 for (int i=0; i<4; ++i)
extendedkey[i][j] = extendedkey[i][j - Nk]^temp[i];}
else
for (int i=0; i<4; ++i)
extendedkey[i][j] = extendedkey[i][j - Nk]^extendedkey[i][j - 1];
}
}

void AddRoundKey (unsigned char previous_state[4][4], unsigned char

rKey[4][4])
{
for (int i=0; i<4; i++)
for (int j=0; j<4; j++)
state[i][j]=previous_state[i][j]^rKey[i][j];
}

void SubBytes (unsigned char previous_state[4][4])

{
for (int i=0; i<4; i++)
for (int j=0; j<4; j++)
state[i][j]=Sbox[state[i][j]];
}

void ShiftRows (unsigned char previous_state[4][4])

{
for (int i=1; i<4; i++)
for (int j=0; j<4; j++)
temp2[i][j]=previous_state[i][(j+i)%4];
for (int i=1; i<4; i++)
for (int j=0; j<4; j++)
state[i][j]=temp2[i][j];
}

unsigned char multiply(unsigned char a, unsigned char b)

{
unsigned char p = 0, hi_bit_set;
for(int i = 0; i < 8; i++)
{
if((b & 1) == 1)
p ^= a;
hi_bit_set = (a & 0x80);
a <<= 1;
if(hi_bit_set == 0x80)
a ^= 0x1b;
b >>= 1;
}
return p;
}

void MixColumns (unsigned char previous_state[4][4])

{
unsigned char in[4],out[4];
for (int j=0; j<4; j++){
for (int i=0; i<4; i++)
in[i]=state[i][j];

out[0] = multiply(0x02,in[0])^multiply(0x03,in[1])^in[2]^in[3];
out[1] = in[0]^multiply(0x02,in[1])^multiply(0x03,in[2])^in[3];
out[2] = in[0]^in[1]^multiply(0x02,in[2])^multiply(0x03,in[3]);
out[3] = multiply(0x03,in[0])^in[1]^in[2]^multiply(0x02,in[3]);

138
 for (int i=0; i<4; i++)
state[i][j]=out[i];
}
}

void Encryption (unsigned char state[4][4],unsigned char

rkey[4][4])
{
SetRoundKey(0);
cout<<"Round Key (0) : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round (0) : "; printmatrix (state);
for (int i=1; i<Nr; i++){
SubBytes(state);
cout<<"SubBytes ("<<i<<") : "; printmatrix (state);
ShiftRows(state);
cout<<"ShiftRows ("<<i<<") : "; printmatrix (state);
MixColumns(state);
cout<<"MixColumn ("<<i<<") : "; printmatrix (state);
SetRoundKey(i);
cout<<"Round Key ("<<i<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<i<<") : "; printmatrix (state);
}

SubBytes(state);
cout<<"SubBytes ("<<Nr<<") : "; printmatrix (state);
ShiftRows(state);
cout<<"ShiftRows ("<<Nr<<") : "; printmatrix (state);
SetRoundKey(Nr);
cout<<"Round Key ("<<Nr<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<Nr<<") : "; printmatrix (state);
}

void InvSubBytes (unsigned char previous_state[4][4])

{
for (int i=0; i<4; i++)
for (int j=0; j<4; j++)
state[i][j]=InvSbox[state[i][j]];
}

void InvShiftRows (unsigned char previous_state[4][4])

{
for (int i=1; i<4; i++)
for (int j=0; j<4; j++)
temp2[i][j]=previous_state[i][(j-i+4)%4];
for (int i=1; i<4; i++)
for (int j=0; j<4; j++)
state[i][j]=temp2[i][j];
}

void InvMixColumns (unsigned char previous_state[4][4])

{
unsigned char in[4],out[4];
for (int j=0; j<4; j++){
for (int i=0; i<4; i++)
in[i]=state[i][j];

139
out[0] =
multiply(0x0e,in[0])^multiply(0x0b,in[1])^multiply(0x0d,in[2])^mult
iply(0x09,in[3]);
out[1] =
multiply(0x09,in[0])^multiply(0x0e,in[1])^multiply(0x0b,in[2])^mult
iply(0x0d,in[3]);
out[2] =
multiply(0x0d,in[0])^multiply(0x09,in[1])^multiply(0x0e,in[2])^mult
iply(0x0b,in[3]);
out[3] =
multiply(0x0b,in[0])^multiply(0x0d,in[1])^multiply(0x09,in[2])^mult
iply(0x0e,in[3]);

for (int i=0; i<4; i++)

state[i][j]=out[i];
}
}

void Decryption (unsigned char state[4][4],unsigned char

rkey[4][4])
{
SetRoundKey(Nr);
cout<<"Round Key ("<<Nr<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<Nr<<") : "; printmatrix (state);
InvShiftRows(state);
cout<<"InvSftRos ("<<Nr<<") : "; printmatrix (state);
InvSubBytes(state);
cout<<"InvSuBtes ("<<Nr<<") : "; printmatrix (state);

for (int i=Nr-1; i>0; i--){

SetRoundKey(i);
cout<<"Round Key ("<<i<<") : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round ("<<i<<") : "; printmatrix (state);
InvMixColumns(state);
cout<<"InvMixCol ("<<i<<") : "; printmatrix (state);
InvShiftRows(state);
cout<<"InvSftRos ("<<i<<") : "; printmatrix (state);
InvSubBytes(state);
cout<<"InvSuBtes ("<<i<<") : "; printmatrix (state);
}
SetRoundKey(0);
cout<<"Round Key (0) : "; printmatrix(roundkey);
AddRoundKey(state,roundkey);
cout<<"Add Round (0) : "; printmatrix (state);
}

void input_text (){

cout<<"Input your plaintext:\n";

k = getchar();
c = getchar();
count = 0;
while ( c != 0x0a) {
input[count] = c;
++count;
c = getchar(); }

plaintext=new unsigned char[count];

140
 for (int i=0; i<16; i++) {
plaintext[i] = input[i];
}
cout<<"\n";}

void input_key (){

key=new unsigned char [Nk*4];
count=0;
cout<<"\n\n";
cout<<"Input your Key:\n";
k = getchar();
while ( k != 0x0a) {
input[count] = k;
++count;
k = getchar();}
while (count>Nk*4)
{
cout<<"\nInvalid Key.Please insert correct Key.\n\nThe Key must
have up to "<<dec<< Nk*4 <<" characters.\n";

count=0;
k = getchar();
while ( k != 0x0a) {
input[count] = k;
++count;
k = getchar(); }
}

for(int i=count;i<32;i++){
input[i]=0;
key[i]=0;}
for (int i=0; i<count; i++){
key[i] = input[i];
}
cout<<"\n"<<"\n";
}

int main ()
{
cout<<"Encryption/Decryption with AES algorithm\n\n";

cout<<"Please choose security level.\nInput:\n\n";

cout<<" 1 , for AES-128.\n";
cout<<" 2 , for AES-192.\n";
cout<<" 3 , for AES-256.\n\n";
cin>>select;

while (select !='1' && select !='2' && select !='3'){

cout<<"\nUnexpected Input.Please try again.\n\n";
cin>>select; }

switch (select){
case '1':
Nk=4; Nb=4; Nr=10; /*gia AES-128*/
break;
case '2':
Nk=6; Nb=4; Nr=12; /*gia AES-192*/
break;
case '3':
Nk=8; Nb=4; Nr=14; /*gia AES-256*/
break;

141
 }
Nw=Nb*(Nr+1);

input_text();
input_key();

vec2mat(plaintext,16,state);
vec2mat_key(key,Nk*4,Key);

cout<<"Text in Hex:\n";
printmatrix(state);

cout<<"Key in Hex:\n";
for (int i=0; i<sizeof Key/sizeof Key[0]; ++i)
{ for (int j=0; j<Nk; ++j)
printf("%02x ", Key[i][j]);
cout << '\n';} cout << '\n';

KeyExpansion(Key);
Encryption(state,roundkey);
cout<<"Encrypted Text in Hex\n";
printmatrix (state);

mat2vec(state,4,arr);
cout<<"Encrypted Text\n";

for (int i=0; i<sizeof arr/sizeof arr[0]; ++i)

cout<<arr[i];
cout << "\n\n";

cout<<"\nDo you want to continue with Decryption? (Y/N)\n";

cin>>select;
while (select !='Y' && select !='y' && select !='N' && select
!='n'){
cout<<"\nUnexpected Input.Please try again.\n\n";
cin>>select; }
switch (select){
case 'Y':
case 'y':
Decryption(state,roundkey);
cout<<"\nDecrypted Text in Hex\n";
printmatrix (state);
mat2vec(state,4,arr);
cout<<"\nDecrypted Text\n";
for (int i=0; i<sizeof arr/sizeof arr[0]; ++i)
cout<<arr[i];
cout << '\n';
break;
case 'N':
case 'n':
break;
}

system("pause");
}

Για τη διαδικτυακή υλοποίηση ο κώδικας είναι ο ακόλουθος:

142
void checkinput(char *str2,int length){

for (i=0,j=0;i<length;i++){
if (str2[i]=='%'){
h1=switch_hex(str2[i+1]);
h2=switch_hex(str2[i+2]);
ak[j]=((16*h1)+h2);
j++;i=i+2;
count2++;
}
else{
ak[j]=str2[i];
j++;
count3++;}
}
}

void checkstringkey (char *character, char *charreturn){

length=strlen(character);
for (i=0,j=0;i<length;i++){
if (character[i]=='%')
check=1;
}
if(check==1){
checkinput(character,length);
for(int i=0; i<(count2+count3); i++)
charKey[i]=ak[i];
check=0;
count3=0;
count2=0;
}
else{
for(int i=0; i<length; i++)
charreturn[i]=character[i];
}
}

void checkstringstr (char *character, char *charreturn){

length=strlen(character);
for (i=0,j=0;i<length;i++){
if (character[i]=='%')
check=1;
}
if(check==1){
checkinput(character,length);
for(int i=0; i<(count2+count3); i++)
str[i]=ak[i];
check=0;
count3=0;
count2=0;
}
else{
for(int i=0; i<length; i++)
charreturn[i]=character[i];
}
}

void addpercent (char *in, char *out){

chartemp[0]='%';

143
 for (int i=1,j=0; i<(strlen(in)+(strlen(in)/2)); i++){
if (i%3==0)
out[i]='%';
else {
out[i]=in[j];
j++;}
}
}

using namespace std;

int main()
{
int ContentLength = 0,test;
char PostString[1024] =
"Type=HEX&key=133457799BBCDFF164777261666C6F66&message=0123456789AB
CDEF&Algorithm=TDEA&Operation=ENCRYPT";
string DataString = "";
string KeyString = "";
string MessageString = "";
string AlgorithmString = "";
string OperationString = "";
string TypeString = "";
enum ALGORITHM {DES, TDEA, AES_128,AES_192,AES_256,
UNKNOWN_ALGORITHM};
ALGORITHM algorithm = DES;
enum OPERATION {ENCRYPT, DECRYPT,FULL,UNKNOWN_OPERATION};
OPERATION operation = ENCRYPT;
enum TYPE {ASCII, HEX, UNKNOWN_TYPE};
TYPE type = ASCII;

cout << "Content-Type: text/html\n\n";

cout << "<html><head><meta http-equiv='Content-Type'
content='text/html; charset=utf-8' />";
cout << "<link rel='shortcut icon' href='favicon.ico'
type='image/x-icon' /><title>Cryptography Results</title>";
cout << "<style type='text/css'>.myfont{font-family: 'Comic Sans
MS', cursive; font-size: 16px;color: #093D62;text-decoration:
underline;}</style></head>";
cout << "<body>";
if ( getenv("CONTENT_LENGTH")){
ContentLength=atoi(getenv("CONTENT_LENGTH"));
cin.read(PostString, ContentLength);
DataString = PostString;
cout << "DataString=" << DataString;
int TypeStart = DataString.find("Type=")+5;
int TypeEnd = DataString.find("&key");
int KeyStart = DataString.find("&key=")+5;
int KeyEnd = DataString.find("&message");
int MessageStart = DataString.find("message=")+8;
int MessageEnd = DataString.find("&Algorithm");
int AlgorithmStart = DataString.find("Algorithm=")+10;
int AlgorithmEnd = DataString.find("&Operation");
int OperationStart = DataString.find("Operation=")+10;
int OperationEnd = ContentLength;

TypeString = DataString.substr(TypeStart, TypeEnd-TypeStart);

KeyString = DataString.substr(KeyStart, KeyEnd-KeyStart);

144
 MessageString = DataString.substr(MessageStart, MessageEnd-
MessageStart);

test=KeyString.copy(charKey2,96,0);
test=MessageString.copy(str2,48,0);

if (TypeString =="ASCII"){
checkstringkey(charKey2,charKey);
key_str=(unsigned char*)charKey;
checkstringstr(str2,str);
mesg_str=(unsigned char*)str;}

else if (TypeString =="HEX"){

addpercent(charKey2,chartemp);
for (i=0; i<strlen(chartemp); i++)
charKey2[i]=chartemp[i];

addpercent(str2,chartemp);
for (i=0; i<strlen(chartemp); i++)
str2[i]=chartemp[i];

checkstringkey(charKey2,charKey);
key_str=(unsigned char*)charKey;
checkstringstr(str2,str);
mesg_str=(unsigned char*)str;}

OperationString = DataString.substr(OperationStart, OperationEnd-

OperationStart);
AlgorithmString = DataString.substr(AlgorithmStart, AlgorithmEnd-
AlgorithmStart);

cout << "<img src='Cryptography.jpg' height='120' width='100%'/>";

cout << "<div align='center'><br /><table rules='all' border='2'
bordercolor='#1B6B8C' style='font-family:'Comic Sans MS',
cursive';>";
cout <<"<tr><td>Input Type:</td><td>"<<TypeString<<"</td></tr>";
cout << "<tr><td>Algorithm:
</td><td>"<<AlgorithmString<<"</td></tr>";
cout <<
"<tr><td>Operation:</td><td>"<<OperationString<<"</td></tr>";
if (TypeString =="ASCII"){
cout <<
"<tr><td>Key:</td><td>"<<charKey<<"</td></tr>";
cout <<
"<tr><td>Message:</td><td>"<<str<<"</td></tr>";
}
else {
cout <<
"<tr><td>Key:</td><td>"<<KeyString<<"</td></tr>";
cout <<
"<tr><td>Message:</td><td>"<<MessageString<<"</td></tr>";
}
cout << "</table>";

cout << "<p class='myfont'>Results:</p><textarea

rows='24' cols='70' style='border-color:#1B6B8C; border-
style:solid'readonly='readonly'>";

if (OperationString == "ENCRYPT")
operant = 'E';

145
 else if (OperationString == "DECRYPT")
operant = 'D';
else if (OperationString == "FULL")
operant='A';

if (AlgorithmString == "DES"){
choise='1';
MyDES(choise, operant,charKey,str);
}
else if (AlgorithmString == "TDEA"){
choise='2';
MyDES(choise, operant,charKey,str);
}
else if (AlgorithmString == "AES_128"){
myselect='1';
MyAES(myselect,operant,key_str,mesg_str);
}
else if (AlgorithmString == "AES_192"){
myselect='2';
MyAES(myselect,operant,key_str,mesg_str);
}
else if (AlgorithmString == "AES_256"){
myselect='3';
MyAES(myselect,operant,key_str,mesg_str);
}
else
cout << "No input";
}

cout << "</textarea></div><br /><br /><br />";

cout << "<div align='center' style='text-align: center;
position:fixed; bottom: 0px;left: 0px; width: 100%; background-
color:#093D62'><font color='#FFFFFF'>Kostas Lykoudis-Dora
Flokatoula<br />Copyright @ 2012</font></div>";
cout << "</body></html>";
system("pause");
return 0;
}

146
 Παράρτημα Β

Στο σημείο αυτό δίνεται ο κώδικας VHDL για την υλοποίηση του αλγορίθμου. Αρχικά
δίνεται ο κώδικας για τα βασικά τμήματα που καλούνται από τα κύρια κυκλώματα
και έπειτα οι υλοποιήσεις των AES-128, AES_128_192_256.

Βασικά τμήματα

Καταχωρητής

library ieee;
use ieee.std_logic_1164.all;
entity reg_nbits is
generic (n:integer :=32);
port( input_reg : in std_logic_vector(n-1 downto
0);
Clk,load : in std_logic;
output_reg : buffer std_logic_vector(n-1
downto 0));
end reg_nbits;

architecture behavioral of reg_nbits is

begin
process(Clk)
begin
if rising_edge (Clk) then
if load = '1' then
output_reg <= input_reg;
end if;
end if;
end process;
end;

Πολυπλέκτες

library ieee;
use ieee.std_logic_1164.all;

entity mux_nbits is
generic (n: integer :=32);
port(
L_in,R_in :in std_logic_vector(n-1 downto 0);
En,sel :in std_logic;
mux_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture behavioral of mux_nbits is

begin
process (En,sel)
begin

if En='1' then
if sel='0' then mux_out <=L_in;

147
 else mux_out <=R_in;
end if;
else mux_out<=(others =>'0');
end if;
end process;
end;

library ieee;
use ieee.std_logic_1164.all;

entity mux_clk is
generic (n: integer :=32);
port(
L_in,R_in :in std_logic_vector(n-1 downto 0);
En,sel,Clk :in std_logic;
mux_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture behavioral of mux_clk is

begin
process (En,sel,Clk)
begin
if rising_edge (Clk) then
if En='1' then
if sel='0' then mux_out <=L_in;
else mux_out <=R_in;
end if;
end if;
end if;
end process;
end;

library ieee;
use ieee.std_logic_1164.all;

entity mux3in1 is
generic (n: integer :=128);
port(
MC,IMC,last_round :in std_logic_vector(n-1 downto 0);
En :in std_logic;
sel :in std_logic_vector(1 downto 0);
mux_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture behavioral of mux3in1 is

begin
process (En,sel)
begin
if En='1' then
if sel="00" then mux_out <=MC;
elsif sel="01" then mux_out <=IMC;
else mux_out <=last_round;
end if;
end if;
end process;
end;

148
Μετασχηματισμός SubBytes για ένα byte

library ieee;
use ieee.std_logic_1164.all;

entity SubBytes is
generic (n : integer :=8);
port ( x :in std_logic_vector(n-1 downto 0);
t :out std_logic_vector(n-1 downto 0));
end entity;

architecture structural of SubBytes is

signal q,y :std_logic_vector(n-5 downto 0);

begin

--exodos apo Block I

q(3) <= (x(7)and(x(5) xor x(4) xor x(1) xor x(0))) xor (x(6)and
(x(5) xor x(4) xor x(2) xor x(1))) xor (x(5) and (x(4) xor x(2) xor
x(1) xor x(0))) xor (x(4)and(x(2)xor x(1))) xor ((x(3)) and(x(2)xor
x(1)))xor(x(2)and x(1));

q(2) <= (x(7)and(x(6) xor x(5) xor x(3) xor x(2) xor x(0)))xor
(x(6)and(x(5) xor x(3) xor x(2) xor x(1) xor x(0)))xor
(x(5)and(x(3) xor x(2)))xor (x(4)and(x(3) xor x(2)xor x(0)))xor
(x(3)and(x(2) xor x(0)))xor((x(2) xor x(1))and x(0));

q(1) <= (x(7)and(x(5) xor x(2) xor x(0) xor '1'))xor (x(6)and(x(5)
xor x(3)))xor (x(5)and(x(4) xor x(3) xor x(2) xor x(0) xor '1'))xor
(x(4)and(x(2) xor '1'))xor (x(3)and(x(2) xor x(0)))xor
(x(2)and(x(1) xor x(0) xor '1'))xor x(1);

q(0) <= (x(7)and(x(6) xor x(4) xor x(0)))xor (x(6)and(x(5) xor x(4)
xor x(3) xor x(1) xor '1'))xor (x(5)and(x(3) xor x(0) xor '1'))xor
(x(4)and(x(3) xor x(1)))xor (x(3)and(x(2) xor x(1) xor x(0) xor
'1'))xor((x(2) xor x(1))and x(0)) xor(x(0) xor x(2));

--exodos apo Block II

y(3) <= q(3) xor (q(3)and q(2)and q(1)) xor (q(3)and q(0)) xor
q(2);

y(2) <= (q(3)and q(2)and q(1)) xor (q(3)and q(2)and q(0))xor

(q(3)and q(0))xor q(2) xor (q(2)and q(1));

y(1) <= q(3) xor (q(3)and q(2)and q(1))xor (q(3)and q(1)and q(0))
xor q(2) xor (q(2)and q(0)) xor q(1);

y(0) <= (q(3)and q(2)and q(1)) xor (q(3)and q(2)and q(0)) xor
(q(3)and q(1)) xor (q(3)and q(1)and q(0)) xor (q(3)and q(0)) xor
q(2) xor (q(2)and q(1))xor (q(2)and q(1)and q(0)) xor q(1) xor
q(0);

--exodos apo Block III

t(7) <= (y(3)and(x(7) xor x(6) xor x(4) xor x(0)))xor (y(2)and(x(5)
xor x(4) xor x(3) xor x(0)))xor (y(1)and (x(5) xor x(4) xor x(3)
xor x(2) xor x(1)))xor (y(0)and(x(7) xor x(2) xor x(1)));

149
t(6) <= (y(3)and(x(7) xor x(6) xor x(4)))xor (y(2)and(x(7) xor x(5)
xor x(1)))xor (y(1)and(x(6) xor x(5) xor x(4)))xor (y(0)and(x(6)
xor x(5) xor x(4) xor x(3) xor x(2)))xor '1';

t(5) <= (y(3)and(x(7) xor x(6) xor x(5) xor x(2)))xor (y(2)and(x(7)
xor x(5) xor x(0)))xor (y(1)and(x(4) xor x(3)))xor (y(0)and(x(7)
xor x(6) xor x(5)))xor '1';

t(4) <= (y(3)and(x(6) xor x(5) xor x(2)))xor (y(2)and(x(7) xor x(6)
xor x(5) xor x(3) xor x(2)))xor (y(1)and(x(5) xor x(4) xor x(3) xor
x(2) xor x(1) xor x(0)))xor (y(0)and(x(4) xor x(3) xor x(2) xor
x(0)));

t(3) <= (y(3)and(x(7) xor x(6) xor x(5) xor x(4) xor x(3) xor x(2)
xor x(1)))xor (y(2)and(x(7) xor x(6) xor x(5) xor x(3) xor x(2) xor
x(0)))xor (y(1)and(x(7) xor x(3) xor x(1) xor x(0)))xor
(y(0)and(x(6) xor x(4) xor x(1) xor x(0)));

t(2) <= (y(3)and(x(5) xor x(2) xor x(1) xor x(0)))xor (y(2)and(x(7)
xor x(6) xor x(5) xor x(4) xor x(3) xor x(2) xor x(0)))xor
(y(1)and(x(7) xor x(5) xor x(4)))xor (y(0)and(x(4) xor x(2) xor
x(1) xor x(0)));

t(1) <= (y(3)and(x(6) xor x(4) xor x(3) xor x(1)))xor (y(2)and(x(6)
xor x(5) xor x(3) xor x(1)))xor (y(1)and x(7))xor (y(0)and(x(6) xor
x(3) xor x(2) xor x(0)))xor '1';

t(0) <= (y(3)and(x(7) xor x(3) xor x(2) xor x(1)))xor (y(2)and(x(7)
xor x(4) xor x(0)))xor (y(1)and(x(6) xor x(4) xor x(2) xor
x(0)))xor (y(0)and(x(5) xor x(3) xor x(2) xor x(0)))xor '1';

end architecture;

Μετασχηματισμός InvSubBytes για ένα byte

library ieee;
use ieee.std_logic_1164.all;

entity InvSubBytes is
generic (n : integer :=8);
port ( x :in std_logic_vector(n-1 downto 0);
t :out std_logic_vector(n-1 downto 0));
end entity;

architecture structural of InvSubBytes is

signal q,y :std_logic_vector(n-5 downto 0);

begin

--exodos apo Block I

q(3) <=(x(7) and (x(4) xor x(1) xor x(0))) xor (x(6) and (x(4)
xor x(2) xor x(0))) xor (x(5) and (x(4) xor x(3))) xor (x(4) and
(x(2) xor x(1)))xor x(4) xor (x(3) and (x(1) xor x(0))) xor (x(2)
and (x(1)xor x(0)))xor (x(0));

q(2) <=(x(7) and (x(5) xor x(2) xor x(1) xor x(0)))xor x(7)xor
(x(6) and (x(5) xor x(4)))xor x(6) xor (x(4) and (x(2) xor
x(1)))xor x(4)xor (x(3) and x(1))

150
 xor (x(1) and (x(0)))xor x(1)xor (x(0)) xor '1';

q(1) <=(x(7) and (x(4) xor x(2) xor x(0) xor x(1)))xor x(7) xor
(x(6) and (x(5) xor x(4) xor x(2) xor x(1)))xor x(6) xor (x(5) and
(x(3) xor x(1)xor x(0)))xor x(5) xor (x(4) and (x(2)))xor x(4)xor
(x(3) and (x(2) xor x(0)))xor (x(2)) xor (x(1)) xor (x(0));

q(0) <=(x(7) and (x(4) xor x(0))) xor (x(6) and (x(5) xor x(4)
xor x(1))) xor (x(5) and x(4)) xor (x(4) and (x(3) xor x(2) xor
x(1))) xor x(4) xor (x(3) and (x(2) xor x(0))) xor x(3) xor (x(1)
and x(0)) xor '1';

--exodos apo Block II

y(3) <= q(3) xor (q(3)and q(2)and q(1)) xor (q(3)and q(0)) xor
q(2);

y(2) <= (q(3)and q(2)and q(1)) xor (q(3)and q(2)and q(0))xor

(q(3)and q(0))xor q(2) xor (q(2)and q(1));

y(1) <= q(3) xor (q(3)and q(2)and q(1))xor (q(3)and q(1)and q(0))
xor q(2) xor (q(2)and q(0)) xor q(1);

y(0) <= (q(3)and q(2)and q(1)) xor (q(3)and q(2)and q(0)) xor
(q(3)and q(1)) xor (q(3)and q(1)and q(0)) xor (q(3)and q(0)) xor
q(2) xor (q(2)and q(1))xor (q(2)and q(1)and q(0)) xor q(1) xor
q(0);

--exodos apo Block III

t(7)<=(y(3)and(x(4)xor x(0)xor '1'))

xor(y(2)and(x(2)xor x(1)xor '1'))
xor(y(1)and(x(5)xor x(0)))
xor(y(0)and(x(5)xor x(1)xor x(0)xor '1'));

t(6)<=(y(3)and(x(7)xor x(3)xor x(1)xor '1'))

xor(y(2)and(x(5)xor x(1)))
xor(y(1)and(x(7)xor x(5)xor '1'))
xor(y(0)and(x(7)xor x(6)xor x(5)xor x(2)xor x(1)xor '1'));

t(5)<=(y(3)and(x(6)xor x(4)xor x(0)))

xor(y(2)and(x(7)xor x(5)xor x(4) xor x(0)))
xor(y(1)and(x(5)xor x(3)xor '1'))
xor(y(0)and(x(7)xor x(6)xor x(5)xor x(2)xor x(0)xor '1'));

t(4)<=(y(3)and(x(6)xor x(5)xor x(2)xor x(0)xor '1'))

xor(y(2)and(x(7)xor x(5)xor x(1)))
xor(y(1)and(x(5)xor x(4)xor x(3)xor x(2)xor x(1)xor x(0)xor
'1'))
xor(y(0)and(x(7)xor x(6)xor x(5)xor x(4)xor x(2)));

t(3)<=(y(3)and(x(5)xor x(4)xor x(3)xor x(1)))

xor(y(2)and(x(6)xor x(5)xor x(3)))
xor(y(1)and(x(7)xor x(5)xor x(4)xor x(2)xor x(1)))
xor(y(0)and(x(6)xor x(4)xor x(3)xor x(2)xor x(0)));

t(2)<=(y(3)and(x(7)xor x(5)xor x(4)xor x(2)xor x(0)))

xor(y(2)and(x(7)xor x(6)xor x(4)xor x(2)xor x(1)))
xor(y(1)and(x(7)xor x(6)xor x(5)xor x(4)xor x(2)xor x(1)xor
'1'))
xor(y(0)and(x(7)xor x(6)xor x(5)xor x(3)xor x(1)xor '1'));

151
t(1)<=(y(3)and(x(7)xor x(6)xor x(2)xor x(1)))
xor(y(2)and(x(7)xor x(6)xor x(3)xor x(2)xor x(1)xor x(0)xor
'1'))
xor(y(1)and(x(5)xor x(4)xor x(3)xor '1'))
xor(y(0)and(x(6)xor x(3) xor x(0)));

t(0)<=(y(3)and(x(1)xor x(0)))xor(y(2)and(x(7)xor x(3)xor x(1)xor

x(0)))
xor(y(1)and(x(7)xor x(6)xor x(1)xor x(0)xor '1'))
xor(y(0)and(x(6)xor x(4)xor x(1)xor x(0)xor '1'));

end structural;

Μετασχηματισμός SubBytes για 128 bits

library ieee;
use ieee.std_logic_1164.all;

entity SubBytes128 is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture struc of SubBytes128 is

component SubBytes is
generic (n : integer :=8);
port ( x :in std_logic_vector(n-1 downto 0);
t :out std_logic_vector(n-1 downto 0));
end component;

begin

g1:SubBytes generic map(n=>8)port map(state_in(127 downto

120),state_out(127 downto 120));
g2:SubBytes generic map(n=>8)port map(state_in(119 downto
112),state_out(119 downto 112));
g3:SubBytes generic map(n=>8)port map(state_in(111 downto
104),state_out(111 downto 104));
g4:SubBytes generic map(n=>8)port map(state_in(103 downto
96),state_out(103 downto 96));
g5:SubBytes generic map(n=>8)port map(state_in(95 downto
88),state_out(95 downto 88));
g6:SubBytes generic map(n=>8)port map(state_in(87 downto
80),state_out(87 downto 80));
g7:SubBytes generic map(n=>8)port map(state_in(79 downto
72),state_out(79 downto 72));
g8:SubBytes generic map(n=>8)port map(state_in(71 downto
64),state_out(71 downto 64));
g9:SubBytes generic map(n=>8)port map(state_in(63 downto
56),state_out(63 downto 56));
g10:SubBytes generic map(n=>8)port map(state_in(55 downto
48),state_out(55 downto 48));
g11:SubBytes generic map(n=>8)port map(state_in(47 downto
40),state_out(47 downto 40));
g12:SubBytes generic map(n=>8)port map(state_in(39 downto
32),state_out(39 downto 32));

152
g13:SubBytes generic map(n=>8)port map(state_in(31 downto
24),state_out(31 downto 24));
g14:SubBytes generic map(n=>8)port map(state_in(23 downto
16),state_out(23 downto 16));
g15:SubBytes generic map(n=>8)port map(state_in(15 downto
8),state_out(15 downto 8));
g16:SubBytes generic map(n=>8)port map(state_in(7 downto
0),state_out(7 downto 0));

end struc;

Μετασχηματισμός InvSubBytes για 128 bits

library ieee;
use ieee.std_logic_1164.all;

entity InvSubBytes128 is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture struc of InvSubBytes128 is

component InvSubBytes is
generic (n : integer :=8);
port ( x :in std_logic_vector(n-1 downto 0);
t :out std_logic_vector(n-1 downto 0));
end component;

begin

g1:InvSubBytes generic map(n=>8)port map(state_in(127 downto

120),state_out(127 downto 120));
g2:InvSubBytes generic map(n=>8)port map(state_in(119 downto
112),state_out(119 downto 112));
g3:InvSubBytes generic map(n=>8)port map(state_in(111 downto
104),state_out(111 downto 104));
g4:InvSubBytes generic map(n=>8)port map(state_in(103 downto
96),state_out(103 downto 96));
g5:InvSubBytes generic map(n=>8)port map(state_in(95 downto
88),state_out(95 downto 88));
g6:InvSubBytes generic map(n=>8)port map(state_in(87 downto
80),state_out(87 downto 80));
g7:InvSubBytes generic map(n=>8)port map(state_in(79 downto
72),state_out(79 downto 72));
g8:InvSubBytes generic map(n=>8)port map(state_in(71 downto
64),state_out(71 downto 64));
g9:InvSubBytes generic map(n=>8)port map(state_in(63 downto
56),state_out(63 downto 56));
g10:InvSubBytes generic map(n=>8)port map(state_in(55 downto
48),state_out(55 downto 48));
g11:InvSubBytes generic map(n=>8)port map(state_in(47 downto
40),state_out(47 downto 40));
g12:InvSubBytes generic map(n=>8)port map(state_in(39 downto
32),state_out(39 downto 32));
g13:InvSubBytes generic map(n=>8)port map(state_in(31 downto
24),state_out(31 downto 24));

153
g14:InvSubBytes generic map(n=>8)port map(state_in(23 downto
16),state_out(23 downto 16));
g15:InvSubBytes generic map(n=>8)port map(state_in(15 downto
8),state_out(15 downto 8));
g16:InvSubBytes generic map(n=>8)port map(state_in(7 downto
0),state_out(7 downto 0));

end struc;

Μετασχηματισμός ShiftRows

library ieee;
use ieee.std_logic_1164.all;

entity ShiftRows is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture struc of ShiftRows is

begin
state_out(127 downto 96)<=state_in(127 downto 120)&state_in(87
downto 80)&state_in(47 downto 40)&state_in(7 downto 0);
state_out(95 downto 64)<=state_in(95 downto 88)&state_in(55 downto
48)&state_in(15 downto 8)&state_in(103 downto 96);
state_out(63 downto 32)<=state_in(63 downto 56)&state_in(23 downto
16)&state_in(111 downto 104)&state_in(71 downto 64);
state_out(31 downto 0)<=state_in(31 downto 24)&state_in(119 downto
112)&state_in(79 downto 72)&state_in(39 downto 32);

end struc;

Μετασχηματισμός InvShiftRows

library ieee;
use ieee.std_logic_1164.all;

entity InvShiftRows is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture struc of InvShiftRows is

begin
state_out(127 downto 96)<=state_in(127 downto 120)&state_in(23
downto 16)&state_in(47 downto 40)&state_in(71 downto 64);
state_out(95 downto 64)<=state_in(95 downto 88)&state_in(119 downto
112)&state_in(15 downto 8)&state_in(39 downto 32);
state_out(63 downto 32)<=state_in(63 downto 56)&state_in(87 downto
80)&state_in(111 downto 104)&state_in(7 downto 0);
state_out(31 downto 0)<=state_in(31 downto 24)&state_in(55 downto
48)&state_in(79 downto 72)&state_in(103 downto 96);

end struc;

154
Πολλαπλασιασμός XTime

library ieee;
use ieee.std_logic_1164.all;

entity x_time is

port (input :in std_logic_vector(7 downto 0);

output :out std_logic_vector(7 downto 0));

end entity;

architecture structural of x_time is

begin
output<=(input(6)&input(5)&input(4)&(input(3)xor input(7))
&(input(2)xor input(7))
& input(1)
&(input(0)xor input(7))&input(7));
end;

library ieee;
use ieee.std_logic_1164.all;

entity x_time4 is

port (input :in std_logic_vector(7 downto 0);

output :out std_logic_vector(7 downto 0));

end entity;

architecture structural of x_time4 is

begin
output<=(input(5)&input(4)&(input(3)xor input(7))
&(input(2)xor (input(6)xor input(7)))
&(input(1)xor input(6))
&(input(0)xor input(7))
&(input(6)xor input(7))
&input(6));
end;

Πακέτο για XTime

library ieee;
use ieee.std_logic_1164.all;
package xtime_pack is

component x_time is
port (input :in std_logic_vector(7 downto 0);
output :out std_logic_vector(7 downto 0));
end component;
component x_time4 is
port (input :in std_logic_vector(7 downto 0);
output :out std_logic_vector(7 downto 0));
end component;

end xtime_pack;

155
Μετασχηματισμός Inv/MixColumns για 32 bits

library ieee;
use ieee.std_logic_1164.all;
use work.xtime_pack.all;

entity MixColumn_Inv32 is
generic(n:integer :=32);
port( state_in :in std_logic_vector(n-1 downto 0);
state_out,inv_state_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture arc of MixColumn_Inv32 is

signal S0,S1,S2,S3,Sout0,Sout1,Sout2,Sout3,x0,x1,x2,x3,y1,y2,invx1
:std_logic_vector(7 downto 0);

begin

--Xwrizetai se 4 bytes
S3<=state_in(7 downto 0);
S2<=state_in(15 downto 8);
S1<=state_in(23 downto 16);
S0<=state_in(31 downto 24);

--Gia MixColumns
e0:x_time port map(S0 xor S1,x0);
Sout3<=x0 xor S2 xor S3 xor S1;
state_out(31 downto 24)<=Sout3;

e1:x_time port map(S1 xor S2,x1);

Sout2<=x1 xor S3 xor S0 xor S2;
state_out(23 downto 16)<=Sout2;

e2:x_time port map(S2 xor S3,x2);

Sout1<=x2 xor S0 xor S1 xor S3;
state_out(15 downto 8)<=Sout1;

e3:x_time port map(S0 xor S3,x3);

Sout0<=x3 xor S1 xor S2 xor S0;
state_out(7 downto 0)<=Sout0;

--Gia InvMixColumns
d00:x_time4 port map(S0 xor S2,y1);
d01:x_time4 port map(S1 xor S3,y2);
d02:x_time port map(y1 xor y2,invx1);

inv_state_out(31 downto 24)<=(invx1 xor Sout3 xor y1);

inv_state_out(23 downto 16)<=(invx1 xor Sout2 xor y2);
inv_state_out(15 downto 8)<=(invx1 xor Sout1 xor y1);
inv_state_out(7 downto 0)<=(invx1 xor Sout0 xor y2);
end;

Μετασχηματισμός Inv/MixColumns για 128 bits

library ieee;
use ieee.std_logic_1164.all;
use work.xtime_pack.all;

156
entity InvMixColumn128 is
generic(n:integer :=128);
port( state_in :in std_logic_vector(n-1 downto 0);
state_out,inv_state_out :out std_logic_vector(n-1 downto 0));
end entity;

architecture struc of InvMixColumn128 is

component MixColumn_Inv32 is
generic(n:integer :=32);
port( state_in :in std_logic_vector(n-1 downto 0);
state_out,inv_state_out :out std_logic_vector(n-1 downto 0));
end component;

begin

g1:MixColumn_Inv32 generic map(n=>32)port map(state_in(127 downto

96),state_out(127 downto 96),inv_state_out(127 downto 96));
g2:MixColumn_Inv32 generic map(n=>32)port map(state_in(95 downto
64),state_out(95 downto 64),inv_state_out(95 downto 64));
g3:MixColumn_Inv32 generic map(n=>32)port map(state_in(63 downto
32),state_out(63 downto 32),inv_state_out(63 downto 32));
g4:MixColumn_Inv32 generic map(n=>32)port map(state_in(31 downto
0),state_out(31 downto 0),inv_state_out(31 downto 0));

end struc;

Επέκταση κλειδιού 128 bits

Μονάδα ελέγχου κλειδιού

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity ControlKey is
port(newkey,Clk :in std_logic;
sel,En :out std_logic;
ld :out std_logic_vector(10 downto 0);
Rcon :buffer std_logic_vector(7 downto 0));
end entity;

architecture behavioural of ControlKey is

signal count :integer;

begin
process (newkey)
begin
if (newkey='1') then
sel<='0';
En<='1';
count<=0;
ld<=(others=>'0');
Rcon<=X"01";
else
if rising_edge(Clk) then
ld(0)<='1';
ld(1)<='1';

157
 sel<='1';
count<=count+1;
ld(count+1)<='1';
Rcon<=Rcon+Rcon;
if (count=7) then
Rcon<=X"1b";
elsif (count=8) then
Rcon<=X"36";
elsif (count>8) then
Rcon<=X"00";
end if;

end if;
end if;
end process;
end behavioural;

Πακέτο για επέκταση κλειδιού

library ieee;
use ieee.std_logic_1164.all;

package key_pack is

component reg_nbits is
generic (n:integer :=32);
port( input_reg : in std_logic_vector(n-1 downto
0);
Clk,load : in std_logic;
output_reg : buffer std_logic_vector(n-1
downto 0));
end component;

component mux_nbits is
generic (n: integer :=32);
port(
L_in,R_in :in std_logic_vector(n-1 downto 0);
En,sel :in std_logic;
mux_out :out std_logic_vector(n-1 downto 0));
end component;

component SubBytes is
generic (n : integer :=8);
port ( x :in std_logic_vector(n-1 downto 0);
t :out std_logic_vector(n-1 downto 0));
end component;

component ControlKey is
port(newkey,Clk :in std_logic;
sel,En :out std_logic;
ld :out std_logic_vector(10 downto 0);
Rcon :buffer std_logic_vector(7 downto 0));
end component;

end key_pack;

158
Επέκταση κλειδιού

library ieee;
use ieee.std_logic_1164.all;
use work.key_pack.all;

entity KeyExpansion is
generic (n: integer :=128);
port ( key_in :in std_logic_vector(n-1 downto 0);
newkey,Clk :in std_logic;
round :in std_logic_vector(3 downto 0);
key :out std_logic_vector(n-1 downto 0));
end entity;

architecture structural of KeyExpansion is

signal mux_sel,mux_En :std_logic;

signal load_reg :std_logic_vector(10 downto 0);
signal
reg_to_mux0,mux_output0,reg_to_mux1,mux_output1,reg_to_mux2,mux_out
put2,reg_to_mux3,mux_output3 :std_logic_vector(31 downto 0);
signal reg_in3,reg_in2,reg_in1,reg_in0 :std_logic_vector
(31 downto 0);
signal sub_out0,sub_out1,sub_out2,sub_out3,Rcon,sub_out3xor
:std_logic_vector(7 downto 0);
signal
rkey_0,rkey_1,rkey_2,rkey_3,rkey_4,rkey_5,rkey_6,rkey_7,rkey_8,rkey
_9,rkey_10 :std_logic_vector(127 downto 0);

begin

control:ControlKey port
map(newkey,Clk,mux_sel,mux_En,load_reg,Rcon);

key_to_mux0: mux_nbits generic map(n=>32) port map(key_in(31 downto

0),reg_to_mux0,mux_En,mux_sel,mux_output0);
key_to_mux1: mux_nbits generic map(n=>32) port map(key_in(63 downto
32),reg_to_mux1,mux_En,mux_sel,mux_output1);
key_to_mux2: mux_nbits generic map(n=>32) port map(key_in(95 downto
64),reg_to_mux2,mux_En,mux_sel,mux_output2);
key_to_mux3: mux_nbits generic map(n=>32) port map(key_in(127
downto 96),reg_to_mux3,mux_En,mux_sel,mux_output3);

subbytes0:SubBytes generic map(n=>8)port map(mux_output0(31 downto

24),sub_out0);
subbytes1:SubBytes generic map(n=>8)port map(mux_output0(7 downto
0),sub_out1);
subbytes2:SubBytes generic map(n=>8)port map(mux_output0(15 downto
8),sub_out2);
subbytes3:SubBytes generic map(n=>8)port map(mux_output0(23 downto
16),sub_out3);

reg_in3<=((sub_out3 xor Rcon)&sub_out2&sub_out1&sub_out0)xor

mux_output3;
reg_in2<=reg_in3 xor mux_output2;
reg_in1<=reg_in2 xor mux_output1;
reg_in0<=reg_in1 xor mux_output0;

159
reg32_0:reg_nbits generic map(n=>32)port
map(reg_in0,Clk,'1',reg_to_mux0);
reg32_1:reg_nbits generic map(n=>32)port
map(reg_in1,Clk,'1',reg_to_mux1);
reg32_2:reg_nbits generic map(n=>32)port
map(reg_in2,Clk,'1',reg_to_mux2);
reg32_3:reg_nbits generic map(n=>32)port
map(reg_in3,Clk,'1',reg_to_mux3);

rkey0:reg_nbits generic map(n=>128)port map(key_in,Clk,'1',rkey_0);

rkey1:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(1),'1'
,rkey_1);
rkey2:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(2),'1'
,rkey_2);
rkey3:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(3),'1'
,rkey_3);
rkey4:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(4),'1'
,rkey_4);
rkey5:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(5),'1'
,rkey_5);
rkey6:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(6),'1'
,rkey_6);
rkey7:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(7),'1'
,rkey_7);
rkey8:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(8),'1'
,rkey_8);
rkey9:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(9),'1'
,rkey_9);
rkey10:reg_nbits generic map(n=>128)port
map(reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0,load_reg(10),'1
',rkey_10);

process(round,Clk)
begin
if (round="0000") then key<=rkey_0;
elsif (round="0001") then key<=rkey_1;
elsif (round="0010") then key<=rkey_2;
elsif (round="0011") then key<=rkey_3;
elsif (round="0100") then key<=rkey_4;
elsif (round="0101") then key<=rkey_5;
elsif (round="0110") then key<=rkey_6;
elsif (round="0111") then key<=rkey_7;
elsif (round="1000") then key<=rkey_8;
elsif (round="1001") then key<=rkey_9;
elsif (round="1010") then key<=rkey_10;
end if;

end process;
end structural;

160
Μονάδα ελέγχου

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity counter is
generic (n:integer :=4);
port(Clk,Res,U_D : in std_logic;
Sel,En,stop,key_sel : out std_logic;
count : out std_logic_vector (n-1 downto 0));
end entity;

architecture behavioral of counter is

signal sgn,temp: std_logic_vector((n-1) downto 0);
signal ene: std_logic;
begin
process(Clk,Res,U_D)
begin
if rising_edge (Clk) then
if U_D ='0' then
if Res = '1' then sgn <= (others => '0');Sel<='0';
elsif (sgn <= "1001")then
sgn <= sgn + 1;

Sel<='1';

if (sgn >= "1001")then ene<='1';

else ene<='0';
end if;

if (sgn >= "1010")then stop<='1';

else stop<='0';
end if;
key_sel<=U_D;
end if;

elsif U_D='1' then

if Res = '1' then
sgn <= "1010";
temp<="1010";
end if;
if temp >"0000" then temp <= temp - 1;sgn <= "1010";Sel<='0';
elsif temp="0000" nand sgn <= "0000"then
sgn <= sgn - 1;
Sel<='1';
end if;

if (sgn > "0001")then ene<='0';

else ene<='1';
end if;

if (sgn >= "0000")then stop<='0';

else stop<='1';
end if;
end if;
end if;

if U_D='1' then
key_sel<=not ene;

161
 else key_sel<=U_D;
end if;
En<=ene;
count<=sgn;
end process;
end behavioral;

Πακέτο για όλα

library ieee;
use ieee.std_logic_1164.all;

package pack_for_all is

component reg_nbits is
generic (n:integer :=32);
port( input_reg : in std_logic_vector(n-1 downto
0);
Clk,load : in std_logic;
output_reg : buffer std_logic_vector(n-1
downto 0));
end component;

component mux_nbits is
generic (n: integer :=32);
port(
L_in,R_in :in std_logic_vector(n-1 downto 0);
En,sel :in std_logic;
mux_out :out std_logic_vector(n-1 downto 0));
end component;

component mux3in1 is
generic (n: integer :=128);
port(
MC,IMC,last_round :in std_logic_vector(n-1 downto 0);
En :in std_logic;
sel :in std_logic_vector(1 downto 0);
mux_out :out std_logic_vector(n-1 downto 0));
end component;

component SubBytes is
generic (n : integer :=8);
port ( x :in std_logic_vector(n-1 downto 0);
t :out std_logic_vector(n-1 downto 0));
end component;

component ControlKey is
port(newkey,Clk :in std_logic;
sel,En :out std_logic;
ld :out std_logic_vector(10 downto 0);
Rcon :buffer std_logic_vector(7 downto 0));
end component;

component x_time is
port (input :in std_logic_vector(7 downto 0);
output :out std_logic_vector(7 downto 0));
end component;

component x_time4 is

162
port (input :in std_logic_vector(7 downto 0);
output :out std_logic_vector(7 downto 0));
end component;

component MixColumn_Inv32 is
generic(n:integer :=32);
port( state_in :in std_logic_vector(n-1 downto
0);
state_out,inv_state_out :out std_logic_vector(n-1
downto 0));
end component;

component InvMixColumn128 is
generic(n:integer :=128);
port( state_in :in std_logic_vector(n-1 downto
0);
state_out,inv_state_out :out std_logic_vector(n-1
downto 0));
end component;

component ShiftRows is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end component;

component InvShiftRows is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end component;

component SubBytes128 is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end component;

component InvSubBytes128 is
generic (n : integer :=128);
port ( state_in :in std_logic_vector(n-1 downto 0);
state_out :out std_logic_vector(n-1 downto 0));
end component;

component KeyExpansion is
generic (n: integer :=128);
port ( key_in :in std_logic_vector(n-1 downto 0);
newkey,Clk :in std_logic;
round :in std_logic_vector(3 downto 0);
key :out std_logic_vector(n-1 downto 0));
end component;

component counter is
generic (n:integer :=4);
port(Clk,Res, U_D : in std_logic;
Sel,En,stop,key_sel : out std_logic;
count : out std_logic_vector (n-1
downto 0));
end component;

163
component mux_clk is
generic (n: integer :=32);
port(
L_in,R_in :in std_logic_vector(n-1 downto 0);
En,sel,Clk :in std_logic;
mux_out :out std_logic_vector(n-1 downto 0));
end component;

end pack_for_all;

AES128

library ieee;
use ieee.std_logic_1164.all;
use work.pack_for_all.all;

entity AES128 is
generic(n:integer :=128);
port( KEY,plaintext :in std_logic_vector(n-1 downto 0);
Clk,Operation,newkey :in std_logic;
Rnd :out std_logic_vector(3 downto 0);
ciphertext :out std_logic_vector(n-1 downto 0));
end entity;

architecture arc of AES128 is

signal
roundkey,state,st,st_sbox,ist_sbox,temp,mux_out,mux_out1,mux_out2,m
ux_out3,
st_SR,st_ISR,st_MC,st_IMC,add_key,inv_add_key,Operation_KEY,mixroun
dkey,nothing :std_logic_vector(127 downto 0);
signal coun :std_logic_vector(3 downto 0);
signal SEL,En,stop,key_sel :std_logic;

begin
count:counter generic map(n=>4)port
map(Clk,newkey,Operation,SEL,En,stop,key_sel,coun);
Operation_KEY<=roundkey;

mux_start:mux_clk generic map(n=>128)port map(plaintext xor

Operation_KEY,state ,not En,SEL,Clk,st);

sbox:SubBytes128 generic map(n=>128)port map(st,st_sbox);

isbox:InvSubBytes128 generic map(n=>128)port map(st,ist_sbox);

mux_sbox:mux_nbits generic map(n=>128)port

map(st_sbox,ist_sbox,'1',Operation,mux_out);

SR:ShiftRows generic map(n=>128)port map(mux_out,st_SR);

ISR:InvShiftRows generic map(n=>128)port map(mux_out,st_ISR);

mux_SR:mux_nbits generic map(n=>128)port

map(st_SR,st_ISR,'1',Operation,mux_out1);

MixCol:InvMixColumn128 generic map(n=>128)port

map(mux_out1,st_MC,st_IMC);

164
mux_MC:mux3in1 generic map(n=>128)port
map(st_MC,st_IMC,mux_out1,not stop,En&Operation,mux_out2);

MixKey:InvMixColumn128 generic map(n=>128)port

map(roundkey,nothing,mixroundkey);

mux_key:mux_nbits generic map(n=>128)port

map(roundkey,mixroundkey,'1',key_sel,mux_out3);

state<=mux_out2 xor mux_out3;

rnd<=coun;
ciphertext<=state;

round_key_creation:KeyExpansion generic map(n=>128)port

map(KEY,newkey,Clk,coun,roundkey);

end arc;

Για τον αλγόριθμο AES_128_192_256 τα βασικά τμήματα παραμένουν ίδια αλλά

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

Επέκταση κλειδιού για AES_128_192_256

Μονάδα ελέγχου κλειδιού

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity ControlKey is
port(newkey,Clk :in std_logic;
KeySel :in std_logic_vector(1 downto 0);
sel,En :out std_logic;
mux_sel :out std_logic_vector(1 downto 0);
ld :out std_logic_vector(14 downto 0);
Rcon :buffer std_logic_vector(7 downto 0));
end entity;

architecture behavioural of ControlKey is

signal count :integer;
begin
process (newkey,KeySel)
begin
if (newkey='1') then
sel<='0';
En<='1';
count<=0;
ld<=(others=>'0');
Rcon<=X"01";
else
if rising_edge(Clk) then

if KeySel="10" then
mux_sel<="00";
ld(0)<='1';
ld(1)<='1';
sel<='1';

165
 count<=count+1;
Rcon<=Rcon+Rcon;
if (count=1) then ld(2)<='1';ld(3)<='1';
elsif (count=2) then ld(2)<='1';
elsif (count=3) then ld(4)<='1'; ld(5)<='1';
elsif (count=4) then ld(6)<='1';
elsif (count=5) then ld(7)<='1'; ld(8)<='1';
elsif (count=6) then ld(9)<='1';
elsif (count=7) then ld(10)<='1'; ld(11)<='1';
elsif (count=8) then ld(12)<='1';
end if;
elsif KeySel="11" then
mux_sel<="10";
ld(0)<='1';
ld(1)<='1';
ld(2)<='1';
sel<='1';
count<=count+1;

if (count=1) then ld(2)<='1';ld(3)<='1';Rcon<=Rcon+Rcon;

elsif (count=2) then ld(4)<='1'; Rcon<=Rcon+Rcon;
elsif (count=3) then ld(5)<='1'; ld(6)<='1';Rcon<=X"04";
elsif (count=4) then ld(7)<='1'; Rcon<=X"08";
elsif (count=6) then ld(8)<='1';ld(9)<='1'; Rcon<=Rcon+Rcon;
elsif (count=8) then ld(10)<='1';ld(11)<='1'; Rcon<=Rcon+Rcon;
elsif (count=10) then ld(12)<='1';ld(13)<='1';Rcon<=Rcon+Rcon;
elsif (count=12) then ld(14)<='1';
end if;
else
mux_sel<="01";
ld(0)<='1';
ld(1)<='1';
sel<='1';
count<=count+1;
ld(count+1)<='1';
Rcon<=Rcon+Rcon;
if (count=7) then
Rcon<=X"1b";
elsif (count=8) then
Rcon<=X"36";
elsif (count>8) then
Rcon<=X"00";
end if;
end if;
end if;
end if;
end process;
end behavioural;

Επέκταση κλειδιού για AES_128_192_256

library ieee;
use ieee.std_logic_1164.all;
use work.key_pack.all;

entity KeyExpansion is
port(key_in :in std_logic_vector(255 downto 0);
newkey,Clk :in std_logic;
key_sel :in std_logic_vector(1 downto 0);
round :in std_logic_vector(3 downto 0);

166
 key :out std_logic_vector(127 downto 0));
end entity;

architecture structural of KeyExpansion is

signal mux_sel,mux_En :std_logic;
signal
reg_to_mux0,mux_output0,reg_to_mux1,mux_output1,reg_to_mux2,mux_out
put2,reg_to_mux3,mux_output3,
reg_to_mux4,mux_output4,reg_to_mux5,mux_output5,reg_to_mux6,mux_out
put6,reg_to_mux7,mux_output7,mux_256,
rot,sub,mux2_out0,mux2_out1,mux0,mux1,mux2,mux4,mux5,mux6,mux7
:std_logic_vector(31 downto 0);
signal
reg_in7,reg_in6,reg_in5,reg_in4,reg_in3,reg_in2,reg_in1,reg_in0,del
ay0,delay1,reg0,reg1,reg2,reg3,reg4,reg5,reg6,reg7
:std_logic_vector(31 downto 0);
signal
sub_out0,sub_out1,sub_out2,sub_out3,sub_out4,sub_out5,sub_out6,sub_
out7,Rcon :std_logic_vector(7 downto 0);
signal load_reg :std_logic_vector(14 downto 0);
signal
rkey_0,rkey_1,rkey_2,rkey_3,rkey_4,rkey_5,rkey_6,rkey_7,rkey_8,rkey
_9,rkey_10,rkey_11,rkey_12,rkey_13,rkey_14,
regin0,regin1,regin2,regin3,regin4,regin5,regin6,regin7,regin8,regi
n9,regin10,regin11,regin12,regin13,regin14
:std_logic_vector(127 downto 0);
signal muxSel :std_logic_vector(1 downto 0);

begin
control:ControlKey port
map(newkey,Clk,key_sel,mux_sel,mux_En,muxSel,load_reg,Rcon);

key_to_mux0: mux_nbits generic map(n=>32) port map(key_in(31 downto

0),reg_to_mux0,'1',mux_sel,mux_output0);
key_to_mux1: mux_nbits generic map(n=>32) port map(key_in(63 downto
32),reg_to_mux1,'1',mux_sel,mux_output1);
key_to_mux2: mux_nbits generic map(n=>32) port map(key_in(95 downto
64),reg_to_mux2,'1',mux_sel,mux_output2);
key_to_mux3: mux_nbits generic map(n=>32) port map(key_in(127
downto 96),reg_to_mux3,'1',mux_sel,mux_output3);
key_to_mux4: mux_nbits generic map(n=>32) port map(key_in(159
downto 128),reg_to_mux4,key_sel(1),mux_sel,mux_output4);
key_to_mux5: mux_nbits generic map(n=>32) port map(key_in(191
downto 160),reg_to_mux5,key_sel(1),mux_sel,mux_output5);
key_to_mux6: mux_nbits generic map(n=>32) port map(key_in(223
downto 192),reg_to_mux6,key_sel(1)and
key_sel(0),mux_sel,mux_output6);
key_to_mux7: mux_nbits generic map(n=>32) port map(key_in(255
downto 224),reg_to_mux7,key_sel(1)and
key_sel(0),mux_sel,mux_output7);

rotword0:RotWord generic map(n=>32)port map(mux_output0,rot);

subbytes0:SubBytes generic map(n=>8)port map(rot(7 downto
0),sub_out0);
subbytes1:SubBytes generic map(n=>8)port map(rot(15 downto
8),sub_out1);
subbytes2:SubBytes generic map(n=>8)port map(rot(23 downto
16),sub_out2);
subbytes3:SubBytes generic map(n=>8)port map(rot(31 downto
24),sub_out3);

167
subbytes4:SubBytes generic map(n=>8)port map(mux_output4(7 downto
0),sub_out4); --gia AES 256
subbytes5:SubBytes generic map(n=>8)port map(mux_output4(15 downto
8),sub_out5);
subbytes6:SubBytes generic map(n=>8)port map(mux_output4(23 downto
16),sub_out6);
subbytes7:SubBytes generic map(n=>8)port map(mux_output4(31 downto
24),sub_out7);

sub<=(sub_out3 xor Rcon)&sub_out2&sub_out1&sub_out0;

reg_in7<=sub xor mux7;
reg_in6<=reg_in7 xor mux6;
reg_in5<=mux2_out1 xor mux5;
reg_in4<=reg_in5 xor mux4;
reg_in3<=mux2_out0 xor mux_256;
reg_in2<=reg_in3 xor mux2;
reg_in1<=reg_in2 xor mux1;
reg_in0<=reg_in1 xor mux0;

mux_rcon0:mux3in1 generic map(n=>32) port

map(reg_in4,sub,reg3,'1',muxSel,mux2_out0);
mux_rcon1:mux_nbits generic map(n=>32) port map(sub,reg_in6,'1',
key_sel(0),mux2_out1);
mux_for256:mux_nbits generic map(n=>32) port
map(mux_output3,sub_out7&sub_out6&sub_out5&sub_out4,'1',key_sel(1)a
nd key_sel(0),mux_256);
mux_0:mux_nbits generic map(n=>32) port map(mux_output0,reg0,'1',
key_sel(0)and key_sel(1),mux0);
mux_1:mux_nbits generic map(n=>32) port map(mux_output1,reg1,'1',
key_sel(0)and key_sel(1),mux1);
mux_2:mux_nbits generic map(n=>32) port map(mux_output2,reg2,'1',
key_sel(0)and key_sel(1),mux2);
mux_4:mux_nbits generic map(n=>32) port map(mux_output4,reg4,'1',
muxSel(0)or muxSel(1),mux4);
mux_5:mux_nbits generic map(n=>32) port map(mux_output5,reg5,'1',
muxSel(0)or muxSel(1),mux5);
mux_6:mux_nbits generic map(n=>32) port map(mux_output6,reg6,'1',
key_sel(0)and key_sel(1),mux6);
mux_7:mux_nbits generic map(n=>32) port map(mux_output7,reg7,'1',
key_sel(0)and key_sel(1),mux7);

reg32_0:reg_nbits generic map(n=>32)port

map(reg_in0,Clk,'1',reg_to_mux0);
reg32_1:reg_nbits generic map(n=>32)port
map(reg_in1,Clk,'1',reg_to_mux1);
reg32_2:reg_nbits generic map(n=>32)port
map(reg_in2,Clk,'1',reg_to_mux2);
reg32_3:reg_nbits generic map(n=>32)port
map(reg_in3,Clk,'1',reg_to_mux3);
reg32_4:reg_nbits generic map(n=>32)port
map(reg_in4,Clk,'1',reg_to_mux4);
reg32_5:reg_nbits generic map(n=>32)port
map(reg_in5,Clk,'1',reg_to_mux5);
reg32_6:reg_nbits generic map(n=>32)port
map(reg_in6,Clk,'1',reg_to_mux6);
reg32_7:reg_nbits generic map(n=>32)port
map(reg_in7,Clk,'1',reg_to_mux7);

reg32_delay0:reg_nbits generic map(n=>32)port

map(reg_to_mux0,Clk,'1',delay0);

168
reg32_delay1:reg_nbits generic map(n=>32)port
map(reg_to_mux1,Clk,'1',delay1);
reg32_d0:reg_nbits generic map(n=>32)port
map(mux_output0,Clk,'1',reg0);
reg32_d1:reg_nbits generic map(n=>32)port
map(mux_output1,Clk,'1',reg1);
reg32_d2:reg_nbits generic map(n=>32)port
map(mux_output2,Clk,'1',reg2);
reg32_d3:reg_nbits generic map(n=>32)port
map(mux_output3,Clk,'1',reg3);
reg32_d4:reg_nbits generic map(n=>32)port
map(mux_output4,Clk,'1',reg4);
reg32_d5:reg_nbits generic map(n=>32)port
map(mux_output5,Clk,'1',reg5);
reg32_d6:reg_nbits generic map(n=>32)port
map(mux_output6,Clk,'1',reg6);
reg32_d7:reg_nbits generic map(n=>32)port
map(mux_output7,Clk,'1',reg7);

rkey0:reg_nbits generic map(n=>128)port map(regin0,Clk,'1',rkey_0);

rkey1:reg_nbits generic map(n=>128)port
map(regin1,load_reg(1),'1',rkey_1);
rkey2:reg_nbits generic map(n=>128)port
map(regin2,load_reg(2),'1',rkey_2);
rkey3:reg_nbits generic map(n=>128)port
map(regin3,load_reg(3),'1',rkey_3);
rkey4:reg_nbits generic map(n=>128)port
map(regin4,load_reg(4),'1',rkey_4);
rkey5:reg_nbits generic map(n=>128)port
map(regin5,load_reg(5),'1',rkey_5);
rkey6:reg_nbits generic map(n=>128)port
map(regin6,load_reg(6),'1',rkey_6);
rkey7:reg_nbits generic map(n=>128)port
map(regin7,load_reg(7),'1',rkey_7);
rkey8:reg_nbits generic map(n=>128)port
map(regin8,load_reg(8),'1',rkey_8);
rkey9:reg_nbits generic map(n=>128)port
map(regin9,load_reg(9),'1',rkey_9);
rkey10:reg_nbits generic map(n=>128)port
map(regin10,load_reg(10),'1',rkey_10);
rkey11:reg_nbits generic map(n=>128)port
map(regin11,load_reg(11),'1',rkey_11);
rkey12:reg_nbits generic map(n=>128)port
map(regin12,load_reg(12),'1',rkey_12);
rkey13:reg_nbits generic map(n=>128)port
map(regin13,load_reg(13),'1',rkey_13);
rkey14:reg_nbits generic map(n=>128)port
map(regin14,load_reg(14),'1',rkey_14);

process (key_sel,round,Clk)
begin
if (key_sel = "10") then
regin0<= key_in(191 downto 64);

if rising_edge (Clk) then

regin1<=key_in(63 downto 0)&reg_in5&reg_in4;

regin2<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin3<=reg_in5&reg_in4&reg_in3&reg_in2;
regin4<=delay1&delay0&reg_to_mux5&reg_to_mux4;
regin5<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;

169
regin6<=reg_to_mux5&reg_to_mux4&reg_to_mux3&reg_to_mux2;
regin7<=delay1&delay0&reg_to_mux5&reg_to_mux4;
regin8<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin9<=reg_to_mux5&reg_to_mux4&reg_to_mux3&reg_to_mux2;
regin10<=delay1&delay0&reg_to_mux5&reg_to_mux4;
regin11<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin12<=reg_to_mux5&reg_to_mux4&reg_to_mux3&reg_to_mux2;
end if;
elsif (key_sel = "11") then
regin0<= key_in(255 downto 128);
regin1<=key_in(127 downto 0);
regin2<=reg_to_mux7&reg_to_mux6&reg_to_mux5&reg_to_mux4;
regin3<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin4<=reg_to_mux7&reg_to_mux6&reg_to_mux5&reg_to_mux4;
regin5<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin6<=reg_in7&reg_in6&reg_in5&reg_in4;
regin7<=reg_in3&reg_in2&reg_in1&reg_in0;
regin8<=reg_to_mux7&reg_to_mux6&reg_to_mux5&reg_to_mux4;
regin9<=reg_in3&reg_in2&reg_in1&reg_in0;
regin10<=reg_to_mux7&reg_to_mux6&reg_to_mux5&reg_to_mux4;
regin11<=reg_in3&reg_in2&reg_in1&reg_in0;
regin12<=reg_to_mux7&reg_to_mux6&reg_to_mux5&reg_to_mux4;
regin13<=reg_in3&reg_in2&reg_in1&reg_in0;
regin14<=reg_to_mux7&reg_to_mux6&reg_to_mux5&reg_to_mux4;
else
regin0<= key_in(127 downto 0);
regin1<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin2<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin3<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin4<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin5<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin6<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin7<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin8<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin9<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
regin10<=reg_to_mux3&reg_to_mux2&reg_to_mux1&reg_to_mux0;
end if;

if (round="0000") then key<=rkey_0;

elsif (round="0001") then key<=rkey_1;
elsif (round="0010") then key<=rkey_2;
elsif (round="0011") then key<=rkey_3;
elsif (round="0100") then key<=rkey_4;
elsif (round="0101") then key<=rkey_5;
elsif (round="0110") then key<=rkey_6;
elsif (round="0111") then key<=rkey_7;
elsif (round="1000") then key<=rkey_8;
elsif (round="1001") then key<=rkey_9;
elsif (round="1010") then key<=rkey_10;
elsif (round="1011") then key<=rkey_11;
elsif (round="1100") then key<=rkey_12;
elsif (round="1101") then key<=rkey_13;
elsif (round="1110") then key<=rkey_14;
end if;
end process;
end structural;

170
Μονάδα ελέγχου 128

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity counter_128 is
generic (n:integer :=4);
port(Clk,Res,U_D,Start : in std_logic;
Sel,En,stop,key_sel : out std_logic;
count : out std_logic_vector (n-1 downto 0));
end entity;

architecture behavioral of counter_128 is

signal sgn,temp: std_logic_vector((n-1) downto 0);
signal ene,sele,ksel,stp: std_logic;
begin
process(Clk,Res,U_D,Start)
begin
if rising_edge (Clk) then
if Start = '1' then
if U_D ='0' then
if Res = '1' then sgn <= (others =>
'0');sele<='0';ksel<='0';
elsif (sgn <= "1001")then
sgn <= sgn + 1;

sele<='1';
if (sgn >= "1001")then ene<='1';
else ene<='0';
end if;

if (sgn >= "1010")then stp<='1';

else stp<='0';
end if;
ksel<=U_D;
end if;

elsif U_D='1' then

if Res = '1' then

sele<='0';ksel<='0';
sgn <= "1010";
temp<="1010";
end if;
if temp >"0000" then temp <= temp - 1;sgn <=
"1010";sele<='0';
elsif temp="0000" nand sgn <= "0000"then
sgn <= sgn - 1;
sele<='1';
end if;

if (sgn > "0001")then ene<='0';

else ene<='1';
end if;

if (sgn >= "0000")then stp<='0';

else stp<='1';
end if;

end if;

171
 end if;
end if;

if U_D='1' then
ksel<=not ene;
else ksel<=U_D;
end if;
if Start= '1' then

En<=ene;
count<=sgn;
key_sel<=ksel;
Sel<=sele;
stop<=stp;
else
En<='0';
count<="0000";
key_sel<='0';
Sel<='0';
stop<='0';
end if;
end process;
end behavioral;

Μονάδα ελέγχου 192

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity counter_192 is
generic (n:integer :=4);
port(Clk,Res,U_D,Start : in std_logic;
Sel,En,stop,key_sel : out std_logic;
count : out std_logic_vector (n-1 downto 0));
end entity;

architecture behavioral of counter_192 is

signal sgn,temp: std_logic_vector((n-1) downto 0);
signal ene,sele,ksel,stp: std_logic;
begin
process(Clk,Res,U_D,Start)
begin
if rising_edge (Clk) then
--if Start = '1' then
if U_D ='0' then
if Res = '1' then sgn <= (others =>
'0');sele<='0';ksel<='0';
elsif (sgn <= "1011")then
sgn <= sgn + 1;
sele<='1';
if (sgn >= "1011")then ene<='1';
else ene<='0';
end if;

if (sgn >= "1100")then stp<='1';

else stp<='0';
end if;
ksel<=U_D;

172
 end if;

elsif U_D='1' then

if Res = '1' then
sele<='0';ksel<='0';
sgn <= "1100";
temp<="1100";
end if;
if temp >"0000" then temp <= temp - 1;sgn <=
"1100";sele<='0';
elsif temp="0000" nand sgn <= "0000"then
sgn <= sgn - 1;
sele<='1';
end if;

if (sgn > "0001")then ene<='0';

else ene<='1';
end if;

if (sgn >= "0000")then stp<='0';

else stp<='1';
end if;
end if;
end if;

if U_D='1' then
ksel<=not ene;
else ksel<=U_D;
end if;
if Start= '1' then

En<=ene;
count<=sgn;
key_sel<=ksel;
Sel<=sele;
stop<=stp;
else
En<='0';
count<="0000";
key_sel<='0';
Sel<='0';
stop<='0';
end if;

end process;
end behavioral;

Μονάδα ελέγχου 256

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity counter_256 is
generic (n:integer :=4);
port(Clk,Res,U_D,Start : in std_logic;
Sel,En,stop,key_sel : out std_logic;
count : out std_logic_vector (n-1 downto 0));
end entity;
architecture behavioral of counter_256 is

173
signal sgn,temp: std_logic_vector((n-1) downto 0);
signal ene,sele,ksel,stp: std_logic;
begin
process(Clk,Res,U_D,Start)
begin
if rising_edge (Clk) then
if U_D ='0' then
if Res = '1' then sgn <= (others =>
'0');sel<='0';ksel<='0';
elsif (sgn <= "1101")then
sgn <= sgn + 1;
sele<='1';
if (sgn >= "1101")then ene<='1';
else ene<='0';
end if;

if (sgn >= "1110")then stp<='1';

else stp<='0';
end if;
ksel<=U_D;
end if;

elsif U_D='1' then

if Res = '1' then

sele<='0';ksel<='0';
sgn <= "1110";
temp<="1110";
end if;
if temp >"0000" then temp <= temp - 1;sgn <=
"1110";sele<='0';
elsif temp="0000" nand sgn <= "0000"then
sgn <= sgn - 1;
sele<='1';
end if;

if (sgn > "0001")then ene<='0';

else ene<='1';
end if;

if (sgn >= "0000")then stp<='0';

else stp<='1';
end if;
end if;
end if;

if U_D='1' then
ksel<=not ene;
else ksel<=U_D;
end if;

if Start= '1' then

En<=ene;
count<=sgn;
key_sel<=ksel;
Sel<=sele;
stop<=stp;
else
En<='0';
count<="0000";

174
 key_sel<='0';
Sel<='0';
stop<='0';
end if;
end process;
end behavioral;

AES_128_192_256

library ieee;
use ieee.std_logic_1164.all;
use work.pack_for_all_128_192_256.all;

entity AES_128_192_256 is
port( plaintext :in std_logic_vector(127 downto 0);
KEY :in std_logic_vector(255 downto 0);
Clk,Operation,newkey :in std_logic;
algorithm :in std_logic_vector(1 downto 0);
rnd :out std_logic_vector(3 downto 0);
ciphertext :out std_logic_vector(127 downto 0));
end entity;

architecture arc of AES_128_192_256 is

signal
roundkey,state,st,st_sbox,ist_sbox,temp,mux_out,mux_out1,mux_out2,m
ux_out3,
st_SR,st_ISR,st_MC,st_IMC,add_key,inv_add_key,Operation_KEY,mixroun
dkey,nothing :std_logic_vector(127 downto 0);
signal coun,coun_128,coun_192,coun_256 :std_logic_vector(3 downto
0);
signal
SEL,SEL_128,SEL_192,SEL_256,En,En_128,En_192,En_256,stop,stop_128,s
top_192,stop_256,key_sel,key_sel_128,key_sel_192,key_sel_256
:std_logic;

begin
count128:counter_128 generic map(n=>4)port
map(Clk,newkey,Operation, not
algorithm(1),SEL_128,En_128,stop_128,key_sel_128,coun_128);

count192:counter_192 generic map(n=>4)port

map(Clk,newkey,Operation, algorithm(1) and (not
algorithm(0)),SEL_192,En_192,stop_192,key_sel_192,coun_192);

count256:counter_256 generic map(n=>4)port

map(Clk,newkey,Operation, algorithm(0) and
algorithm(1),SEL_256,En_256,stop_256,key_sel_256,coun_256);

coun<=coun_128 or coun_192 or coun_256;

SEL<=SEL_128 or SEL_192 or SEL_256;
En<=En_128 or En_192 or En_256;
stop<=stop_128 or stop_192 or stop_256;
key_sel<=key_sel_128 or key_sel_192 or key_sel_256;

Operation_KEY<=roundkey;
mux_start:mux_clk generic map(n=>128)port map(plaintext xor
Operation_KEY,state ,not En,SEL,Clk,st);
sbox:SubBytes128 generic map(n=>128)port map(st,st_sbox);

175
isbox:InvSubBytes128 generic map(n=>128)port map(st,ist_sbox);

mux_sbox:mux_nbits generic map(n=>128)port

map(st_sbox,ist_sbox,'1',Operation,mux_out);

SR:ShiftRows generic map(n=>128)port map(mux_out,st_SR);

ISR:InvShiftRows generic map(n=>128)port map(mux_out,st_ISR);

mux_SR:mux_nbits generic map(n=>128)port

map(st_SR,st_ISR,'1',Operation,mux_out1);

MixCol:InvMixColumn128 generic map(n=>128)port

map(mux_out1,st_MC,st_IMC);

mux_MC:mux3in1 generic map(n=>128)port

map(st_MC,st_IMC,mux_out1,not stop,En&Operation,mux_out2);

MixKey:InvMixColumn128 generic map(n=>128)port

map(roundkey,nothing,mixroundkey);

mux_key:mux_nbits generic map(n=>128)port

map(roundkey,mixroundkey,'1',key_sel,mux_out3);

state<=mux_out2 xor mux_out3;

rnd<=coun;
ciphertext<=state;

round_key_creation:KeyExpansion port
map(KEY,newkey,Clk,algorithm,coun,roundkey);

end arc;

176
177