algorithmiki-epilusi-duskolon

Αριστοτέλειο Πανεπιστήμιο Θεσσαλονίκης
Σχολή Θετικών Επιστημών
Τμήμα Πληροφορικής
Αλγοριθμική επίλυση δύσκολων προβλημάτων
Knapsack
Πτυχιακή Εργασία
Ευάγγελος Δαραβίγκας
Επιβλέπων: Κωνσταντίνος Δραζιώτης
Λέκτορας
Θεσσαλονίκη, Σεπτέμβριος 2016

Αριστοτέλειο Πανεπιστήμιο Θεσσαλονίκης
Σχολή Θετικών Επιστημών
Τμήμα Πληροφορικής
Copyright c –All rights reserved Ευάγγελος Δαραβίγκας, 2016.
Με την επιφύλαξη παντός δικαιώματος.
Απαγορεύεται η αντιγραφή, αποθήκευση και διανομή της παρούσας εργασίας, εξ ολοκλήρου
ή τμήματος αυτής, για εμπορικό σκοπό. Επιτρέπεται η ανατύπωση, αποθήκευση και διανομή
για σκοπό μη κερδοσκοπικό, εκπαιδευτικής ή ερευνητικής φύσης, υπό την προϋπόθεση να
αναφέρεται η πηγή προέλευσης και να διατηρείται το παρόν μήνυμα.
Το περιεχόμενο αυτής της εργασίας δεν απηχεί απαραίτητα τις απόψεις του Τμήματος, του
Επιβλέποντα, ή της επιτροπής που την ενέκρινε.
Υπεύθυνη Δήλωση
Βεβαιώνω ότι είμαι συγγραφέας αυτής της πτυχιακής εργασίας, και ότι κάθε βοήθεια την οποία
είχα για την προετοιμασία της είναι πλήρως αναγνωρισμένη και αναφέρεται στην πτυχιακή
εργασία. Επίσης έχω αναφέρει τις όποιες πηγές από τις οποίες έκανα χρήση δεδομένων,
ιδεών ή λέξεων, είτε αυτές αναφέρονται ακριβώς είτε παραφρασμένες. Επίσης, βεβαιώνω ότι
αυτή η πτυχιακή εργασία προετοιμάστηκε από εμένα προσωπικά ειδικά για τις απαιτήσεις
του προγράμματος σπουδών του Τμήματος Πληροφορικής του Αριστοτέλειου Πανεπιστημίου
Θεσσαλονίκης.
(Υπογραφή)
.............................
Ευάγγελος Δαραβίγκας

Περίληψη
Η συγκεκριμένη εργασία αποτελεί μια πρακτική εφαρμογή της αλγοριθμικής τυχαιοποιημένης
μεθόδου του BKZ, που αναπτύχθηκε από τους Schnorr και Shevchenko για την επίλυση του
Προβλήματος του Σακιδίου (Subset Sum Problem). Αρχικά, περιγράφονται οι απαραίτητες
μαθηματικές έννοιες και στοιχεία που χρειάζονται για την ανάλυση του προβλήματος και την
ανάπτυξη του αλγορίθμου. Στη συνέχεια γίνεται συσχέτιση με το πεδίο της Κρυπτογραφίας.
Ακολουθεί η ανάπτυξη του αλγορίθμου με χρήση του αλγεβρικού υπολογιστικού συστήμα-
τος SageMath και παρουσιάζονται τα αποτελέσματα που προέκυψαν. ΄Επειτα, αναπτύσσεται
ο αλγόριθμος στη γλώσσα προγραμματισμού C/C++, με χρήση της βιβλιοθήκης fpLLL, με
στόχο την αποδοτικότερη εκτέλεσή του. ΄Οπως και προηγουμένως, παρουσιάζονται τα αποτε-
λέσματα των πειραμάτων που εκτελέστηκαν με την τελευταία υλοποίηση σε C/C++. Τέλος,
προτείνονται πιθανές μελλοντικές επεκτάσεις που θα μπορούσε να έχει αυτή η εργασία.
Λέξεις Κλειδιά
Κρυπτογραφία, Πρόβλημα του Σακιδίου, Πρόβλημα Subset Sum, Πλέγμα, LLL-ανηγμένη
βάση πλέγματος, BKZ-ανηγμένη βάση πλέγματος, SageMath, fpLLL
i

Abstract
The project is the practical implementation of the ”randomized” BKZ algorithm as de-
scribed by Schnorr and Shevchenko in order to solve the Problem of Knapsack (Subset
Sum Problem). Initially are described the required mathematical preliminaries for the
problem analysis and the deployment of the algorithm. Following that, there is the corre-
lation with the ﬁeld of Cryptography. Afterwards, the algorithm is developed with the use
of the algebraic computational system SageMath and the generated results are presented.
Next, the algorithm is developed with the use of the programming language C/C++ and
the fpLLL library, by aiming to a more eﬃcient execution. As before, the generated re-
sults are presented. Finally, there are suggested some possible future expansions that this
project may have.
Keywords
Cryptography, Knapsack problem, Subset sum problem, Lattice, LLL-lattice basis reduc-
tion, BKZ-lattice basis reduction, SageMath, fpLLL
iii

στους γονείς μου

Περιεχόμενα
Περίληψη i
Abstract iii
Περιεχόμενα viii
1 Εισαγωγή 1
1.1 Αντικείμενο της διπλωματικής . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Λόγος Επίλυσης του Προβλήματος . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Μαθηματικές ΄Εννοιες 3
2.1 Πλέγμα (Lattice) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Διαδοχικά Ελάχιστα Πλέγματος (Successive Minima) . . . . . . . . . 4
2.1.2 Σταθερά Hermite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Αλγόριθμοι σε Πλέγματα . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.1 Gauss – Lagrange Algorithm . . . . . . . . . . . . . . . . . . . . . . 5
2.2.2 Gram–Schmidt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.3 LLL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.4 Αλγόριθμος Enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.5 Hermite Korkine Zolotarev (HKZ) . . . . . . . . . . . . . . . . . . . 9
2.2.6 Kannan’s Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.7 Blockwise Korkine Zolotarev (BKZ) . . . . . . . . . . . . . . . . . . 10
3 Το Subset Sum Problem στην Κρυπτογραφία 13
3.1 Subset Sum Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.1 Περιγραφή . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.2 Το Subset Sum Problem στην Κρυπτογραφία . . . . . . . . . . . . . . 14
3.2 Κρυπτοσυστήματα με το Πρόβλημα του Σακιδίου . . . . . . . . . . . . . . . . 16
3.2.1 Merkle–Hellman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.2 Chor–Rivest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.3 Okamoto–Tanaka–Uchiyama (OTU) Scheme . . . . . . . . . . . . . 16
3.3 Επιθέσεις στα Κρυπτοσυστήματα του Σακιδίου . . . . . . . . . . . . . . . . . 17
vii

viii Περιεχόμενα
3.3.1 Επιθέσεις Χαμηλής Πυκνότητας (Low Density Attacks) . . . . . . . . 17
3.3.2 Επιθέσεις που βασίζονται στο Παράδοξο των Γενεθλίων . . . . . . . . 19
3.4 Επίλυση προβλημάτων με πυκνότητα περίπου ίση με ένα . . . . . . . . . . . . 20
3.4.1 Περιγραφή Αλγορίθμου . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4.2 Σχόλια . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4.3 Ψευδοκώδικας . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4.4 Εκτέλεση . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4 Πλατφόρμα SAGE 25
4.1 Εισαγωγή . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.2 Ιστορία Ανάπτυξης . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.3 Κώδικας . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.4 Στατιστικά . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5 C/C++ και fpLLL 33
5.1 Βιβλιοθήκη fpLLL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.2 Κώδικας . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.3 Εκτέλεση Παραδειγμάτων . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.4 Συμπεράσματα . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.5 Εκτέλεση του BKZ 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.6 Πιθανές Βελτιώσεις . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6 Επίλογος 45
Αʹ Εγκατάσταση βιβλιοθήκης fpLLL 47
Αʹ.1 Προαπαιτούμενα . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Αʹ.1.1 g++ Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Αʹ.1.2 autotools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Αʹ.1.3 git . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Αʹ.1.4 Βιβλιοθήκη GNU MP . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Αʹ.1.5 Βιβλιοθήκη MPFR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Αʹ.1.6 Βιβλιοθήκη QD (προαιρετικά) . . . . . . . . . . . . . . . . . . . . . . 49
Αʹ.2 Βιβλιοθήκη fpLLL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Αʹ.3 Πιθανά Σφάλματα . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Αʹ.4 Εκτέλεση Παραδειγμάτων . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Αʹ.5 Ενσωμάτωση σε Ολοκληρωμένο Περιβάλλον Ανάπτυξης (IDE) . . . . . . . . 51
Βʹ Σημειογραφία 53

Κεφάλαιο 1
Εισαγωγή
1.1 Αντικείμενο της διπλωματικής
Ως αντικείμενο της παρούσας εργασίας επιλέχθηκε η κατασκευή του τυχαιοποιημένου αλγορίθ-
μου που βασίζεται στον αλγόριθμο BKZ και αναπτύχθηκε από τους Schnorr και Shevchenko.
Ο αλγόριθμος αυτός στοχεύει στην κρυπτανάλυση των κρυπτοσυστημάτων που βασίζουν την
ασφάλειά τους στο Πρόβλημα του Σακιδίου. Η αποδοτική και αποτελεσματική εκτέλεση του
συγκεκριμένου αλγορίθμου, αναφορικά με την χρονική και χωρική πολυπλοκότητα, συγκριτι-
κά με την αντίστοιχη αρχική ανάπτυξη αποτέλεσε τον κεντρικό στόχο της εργασίας. Για την
υλοποίηση αυτού, χρησιμοποιήθηκε η γλώσσα προγραμματισμού C++ σε συνδυασμό με την
βιβλιοθήκη fpLLL, η οποία παρέχει έτοιμες υλοποιήσεις γνωστών αλγορίθμων και διαδικασιών
πάνω σε μητρώα/πίνακες.
1.2 Λόγος Επίλυσης του Προβλήματος
Τα κρυπτοσυστήματα που βασίζονται στο Πρόβλημα του Σακιδίου έχουν αποτελέσει αντικε-
ίμενο μελέτης εδώ και πολλές δεκαετίες. Τα περισσότερα από αυτά έχουν τελικώς σπάσει.
Παρ΄όλα αυτά υπάρχουν παραλλαγές αυτών των συστημάτων που ακόμη αντέχουν στην κρυ-
πτανάλυση. Πλεονέκτημα αυτών, είναι η πολύ πιθανή αντίσταση τους σε κβαντικές επιθέσεις.
Τα συστήματα που βασίζονται στον αλγόριθμο RSA και στον διακριτό λογάριθμο είναι ευάλωτα
σε κβαντικές επιθέσεις, όπως αποδείχτηκε από τον Shor. Δηλαδή, ένας κβαντικός υπολογι-
στής με αρκετά μεγάλη μνήμη, είναι ικανός να σπάσει τη σημερινή ασφάλεια των υπολογιστικών
συστημάτων. Μέχρι την ημέρα συγγραφής της παρούσας εργασίας δεν είναι γνωστή κάποια
τέτοια κατασκευή. Επομένως, καθώς τα συστήματα που βασίζονται στο Πρόβλημα του Σα-
κιδίου, είναι δυνητικά κβαντικά ασφαλή, αυτό και μονό είναι ικανό να διατηρήσει ενεργή την
έρευνα πάνω σε αυτό το πρόβλημα. Εκτός αυτού όμως, από καθαρά αλγοριθμική σκοπιά, έχει
ξεχωριστό ενδιαφέρον καθώς –ως πρόβλημα απόφασης– ανήκει στην κλάση πολυπλοκότητας
NP-complete. Εξ άλλου, δεν είναι τυχαίο που μέχρι σήμερα αναπτύσσονται επιθέσεις γιάυτό
το πρόβλημα.
1

Κεφάλαιο 2
Μαθηματικές ΄Εννοιες
Διευκρινίζεται ότι όλα τα διανύσματα αναγράφονται σαν γραμμές ενός πίνακα, εκτός και αν
αναφέρεται κάτι διαφορετικό. Επιπροσθέτως, ως μέτρο του διανύσματος εννοείται η ευκλείδεια
νόρμα του διανύσματος. Η παράθεση των μαθηματικών ορισμών έχει γίνει από τα βιβλία
[2, 8, 10].
2.1 Πλέγμα (Lattice)
Ορισμός:
΄Εστω τα γραμμικώς ανεξάρτητα διανύσματα x1, x2, . . . , xn στο Rm(m ≤ n). Το σύνολο
L =
n
i=1
lixi : li ∈ Z
ονομάζεται πλέγμα (lattice), διάστασης (dimension) m και βαθμίδας (rank) n. Τα
διανύσματα x1, x2, . . . , xn αποτελούν μία βάση του πλέγματος (lattice basis) L. Με
άλλα λόγια, ένα πλέγμα L είναι το σύνολο που παράγεται (span) υπεράνω του Z από την
βάση αυτή και ισχύει:
L = spanZ{x1, x2, . . . , xn}
Στην ειδική περίπτωση όπου m = n, το L ονομάζεται πλέγμα μέγιστης βαθμίδας.
Τέλος, το υποσύνολο L του L, ονομάζεται υποπλέγμα του L (sublattice) αν το ίδιο
αποτελεί ένα πλέγμα.
Το μητρώο βάσης (basis matrix) B του πλέγματος L είναι ένα μητρώο διαστάσεων
n × m, το οποίο έχει ως γραμμές τα διανύσματα xi (1 ≤ i ≤ n) της βάσης του πλέγματος.
΄Ετσι, αν το Bi,j είναι το στοιχείο στην θέση j του διανύσματος xi τότε ισχύει:
L = yB : y ∈ Zn
3

4 Κεφάλαιο 2. Μαθηματικές ΄Εννοιες
΄Ενα πλέγμα L μπορεί να έχει πάνω από μία βάσεις, διαφορετικές μεταξύ τους. Οι βάσεις
που μπορούν να κατασκευάσουν το ίδιο πλέγμα προκύπτουν με την εφαρμογή στοιχειωδών
γραμμο-πράξεων επί του μητρώου βάσης. ΄Ετσι, κάποιες βάσεις μπορεί να είναι καλύτερες από
κάποιες άλλες, αναφορικά με το μήκος των διανυσμάτων και την μεταξύ τους ορθογωνιοποι-
ημένη σχέση.
Εφαρμογές
Τα πλέγματα βρίσκουν εφαρμογές σε διάφορα επιστημονικά πεδία, όπως την Συνδυαστική
Βελτιστοποίηση, την Κρυπτογραφία, την Θεωρία Πολυπλοκότητας, την Αρμονική Ανάλυση
και την Αλγεβρική Θεωρία Αριθμών1. Γνωστά υπολογιστικά προβλήματα που σχετίζονται με
πλέγματα αποτελούν τα:
• Πρόβλημα μικρότερου διανύσματος (Shortest Vector Problem (SVP))
Εύρεση του ελάχιστου μη μηδενικού διανύσματος στο πλέγμα L.
• Πρόβλημα εγγύτερου διανύσματος (Closest Vector Problem (CVP))
Δεδομένου ενός διανύσματος t ∈ Rm το οποίο δεν ανήκει στο πλέγμα L, ζητείται εύρεση
του διανύσματος στο L, που βρίσκεται πιο κοντά στο t.
Η ορίζουσα (determinant) ενός πλέγματος L είναι ο όγκος του θεμελιώδους παραλλη-
λεπιπέδου μιας βάσης X του L. ΄Οταν το πλέγμα είναι μέγιστης βαθμίδας ισχύει:
det(L) = | det(X)|
Παρατήρηση
Αποδεικνύεται ότι η ορίζουσα ενός πλέγματος δεν εξαρτάται από την βάση του.
Προβολή Πλέγματος
΄Εστω B = {b1, . . . , bn} ∈ Rm μια βάση ενός πλέγματος L (με m > n). Υπάρχει μία
γραμμική απεικόνιση P: Rm → Rn, ώστε το P(L) να είναι ένα πλέγμα βαθμίδας n και ισχύει
ότι ||P(xi)|| = ||xi|| για όλα τα διανύσματα του L. Επιπλέον, ισχύει και ότι bi, bj = biP,
bjP για κάθε 1 ≤ i < j ≤ n. Αν η γραμμική απεικόνιση αναπαριστάται από ένα μητρώο
διαστάσεων m × n, τότε το μητρώο βάσης για την εικόνα του L υπό την προβολή P είναι το
μητρώο BP διάστασης n × n, που είναι αντιστρέψιμο.
2.1.1 Διαδοχικά Ελάχιστα Πλέγματος (Successive Minima)
Ως i−διαδοχικό ελάχιστο ενός πλέγματος L ορίζεται ο μικρότερος πραγματικός αριθμός r
που περιέχει i−γραμμικώς ανεξάρτητα διανύσματα το πολύ μήκους r. Συμβολίζεται ως λi(L)
(1 ≤ i ≤ n), όπου n = rank(L). Για παράδειγμα, το πρώτο διαδοχικό ελάχιστο λ1(L) ισούται
με το μήκος του μικρότερου διανύσματος του πλέγματος.
1
http://cseweb.ucsd.edu/classes/wi10/cse206a/

2.2 Αλγόριθμοι σε Πλέγματα 5
2.1.2 Σταθερά Hermite
Δεδομένου ότι n ∈ N, υπάρχει σταθερά 0 < γn ≤ n, τέτοια ώστε για κάθε πλέγμα L βαθμίδας
n ισχύει:
γn ≥
λ1(L)
(det(L))2/n
γn/2
n ≥
λ1(L)λ2(L) · · · λn(L)
(det(L))
Ο ελάχιστος πραγματικός αριθμός γn για τον οποίον ισχύει η παραπάνω σχέση ονομάζεται
σταθερά Hermite (Hermite constant).
2.2 Αλγόριθμοι σε Πλέγματα
2.2.1 Gauss – Lagrange Algorithm
Ο αλγόριθμος αυτός αναπτύχθηκε αρχικά από τον Lagrange και στη συνέχεια από τον Gauss
το 1810. Αποτελεί τον πρώτο αλγόριθμο για το πρόβλημα της αναγωγής βάσης πλέγματος 2
και συγκεκριμένα για πλέγματα διάστασης ίση με δύο, δηλαδή n = 2.
΄Εστω x1, x2 ∈ R2 τα γραμμικώς ανεξάρτητα διανύσματα βάσης του πλέγματος L. Μία βάση
είναι διατεταγμένη Lagrange–Gauss-ανηγμένη βάση αν και μόνο αν ισχύει η παρακάτω σχέση:
||x1|| ≤ ||x2|| ≤ ||x2 ± x1||
Ο αλγόριθμος έχει πολυπλοκότητα ίση με O(log n3) όπου το n αποτελεί την μεγαλύτερη τιμή
νόρμας δευτέρου βαθμού μεταξύ των διανυσμάτων. Παρακάτω, παραθέτεται ο ψευδοκώδικας
του αλγορίθμου:
Ψευδοκώδικας:
INPUT: Lattice basis x1, x2 ∈ Z2 of L
OUTPUT: Gauss-Lagrange - reduced basis for L(X) such that ||xi|| = li
01. X1 = ||x1||2
02. µ = x1, x2 /X1
03. x2 = x2 − µ x1
04. X2 = ||x2||2
05. while X2 < X1 do
06. Swap x2, x1
07. X1 = X2
08. µ = x1, x2 /X1
2
https://en.wikipedia.org/wiki/Gaussian elimination

09. x2 = x2 − µ x1
10. X2 = ||x2||2
11. end while
12. return(x1, x2)
2.2.2 Gram–Schmidt
Ο αλγόριθμος αυτός αναπτύχθηκε από τους Gram και Schmidt 3 το 1907 και αποτελεί μία
μέθοδο για την ορθογωνιοποίηση ενός συνόλου διανυσμάτων στον χώρο Rm. ΄Εστω ένα σύνο-
λο γραμμικά ανεξάρτητων διανυσμάτων ενός συνόλου S ⊂ Rm, το αποτέλεσμα του αλγορίθμου
είναι ένα σύνολο ορθογώνιων διανυσμάτων το οποίο παράγει το ίδιο χώρο που παράγεται από
το S. Η διαδικασία αυτή αποτελεί κομμάτι του αλγορίθμου LLL, που περιγράφεται παρακάτω,
και στοχεύει στον δεύτερο σκοπό των προβλημάτων αναγωγής βάσης πλέγματος, δηλαδή αυ-
τού της ορθογωνιοποίησης μεταξύ των διανυσμάτων βάσης του πλέγματος.
INPUT: {x1, . . . , xn} ⊂ Rm
OUTPUT: {x∗
1, . . . , x∗
n} ⊂ Rm
01. x∗
1 = x1
02. for i = 2 to n do
03. u = xi
04. for j ← i − 1 to 1 do
05. µi,j = xi, x∗
j / x∗
j , x∗
j
06. u = u − µi,jx∗
j
07. end for
08. x∗
i = u
09. end for
10. return {x∗
1, . . . , x∗
n}
2.2.3 LLL
Ο αλγόριθμος αυτός αναπτύχθηκε από τους Lenstra, Lenstra και Lov`asz [18] το 1982 και
αποτελεί έναν από τους πρώτους και πιο σημαντικούς αλγορίθμους αναφορικά με το πρόβλημα
αναγωγής βάσης πλέγματος. Το όνομά του, LLL (γνωστό και ως L3) προκύπτει από τα
αρχικά γράμματα των κατασκευαστών του 4.
Ο αλγόριθμος είναι πολυωνυμικού χρόνου. Η ακριβής χρονική bit-πολυπλοκότητα του είναι
O(d5
n log3
B)
3
https://en.wikipedia.org/wiki/Gram-Schmidt process
4
https://en.wikipedia.org/wiki/Lenstra-Lenstra-Lov´asz lattice basis reduction algorithm

όπου το d είναι ο βαθμίδα του πλέγματος, και B η μεγαλύτερη Ευκλείδεια νόρμα των διανυ-
σμάτων της βάσης εισόδου.
Το βασικό ζητούμενο του αλγορίθμου είναι η εύρεση μίας «ανηγμένης» βάσης ενός πλέγμα-
τος L, έχοντας ως δεδομένο μία βάση B = [b1, . . . , bd] με (d ≤ n) του ίδιου πλέγματος που
αποτελείται κυρίως από διανύσματα μεγάλου μήκους («κακή» βάση).
Περιγραφή αλγορίθμου:
Δεδομένης της βάσης B = {b0, b1, . . . , bn}
ορίζεται η ορθογωνιοποιημένη βάση Gram – Schmidt B∗ = {b∗
0, b∗
1, . . . , b∗
n}
καθώς επίσης και οι συντελεστές Gram – Schmidt µi,j =
bi,b∗
j
b∗
j ,b∗
j
, ∀1 ≤ j < i ≤ n
Εν συνεχεία η βάση B είναι LLL–ανηγμένη (LLL–reduced), αν υπάρχει μία παράμετρος
δ στο εύρος (0.25, 1] για την οποία ισχύουν οι εξής συνθήκες:
• ανηγμένου μεγέθους (size–reduced)
Για 1 ≤ j < i ≤ n: |µi,j| ≤ 0.5. Εξ ορισμού, αυτή είναι η ιδιότητα εξασφαλίζει το
μήκος αναγωγής της διατεταγμένης βάσης.
• συνθήκη του Lov´asz
Για k = 2, .., n: δ b∗
k−1
2 ≤ b∗
k
2 + µ2
k,k−1 b∗
k−1
2.
Οι διάφορες προσεγγιστικές τιμές που μπορεί να πάρει η τιμή δ, έχουν ως απόρροια το κατά
πόσο ανάγεται η βάση αυτή. Αξίζει να σημειωθεί ότι ο πολυωνυμικός χρόνος εξασφαλίζεται
μόνον για τιμές στο εύρος (0.25, 1).
INPUT: Lattice basis b1, . . . , bn ∈ Zn
OUTPUT: δ-LLL-reduced basis for L
01. Start: compute b∗
1, . . . , b∗
n Gram-Schmidt orthogonalization, without normalization.
02. Reduction Step:
03. for i = 2 to n do
04. for j = i − 1 to 1 do
05. bi ← bi − ci,jbj, ci,j = bi, b∗
j b∗
j , b∗
j
06. Swap step:
07. if ∃i : δ||b∗
i ||2
> ||µi+1,ib∗
i + b∗
i+1||2
then
08. bi ↔ bi+1
09. goto Start
10. Output b1, . . . , bn

2.2.4 Αλγόριθμος Enum
Ο αλγόριθμος αυτός αποτελεί μία υπο-ρουτίνα που χρησιμοποιείται από τον αλγόριθμο του
BKZ, που αναπτύσσεται παρακάτω. Αναπτύχθηκε αρχικά από τον Pohst το 1981 [25] και
χρησιμοποιείται για την αποφυγή περιττών υπολογισμών κατά την εύρεση του μικρότερου δια-
νύσματος ενός πλέγματος.
Αναφορικά με τον τρόπο ανάπτυξης της μεθόδου από τους Schnorr και Euchner [28], η α-
ποφυγή των περιττών υπολογισμών γίνεται με την κατασκευή ενός δένδρου, γνωστό και με
την ονομασία enumeration tree, που αποτελείται από διανύσματα των οποίων το μέτρο τους
πρέπει να είναι κάτω από ένα αριθμητικό όριο, Για την εύρεση του ζητούμενου διανύσματος
γίνεται μία Αναζήτηση Πρώτα Κατά Βάθος (Depth First Search – DFS) και στις περιπτώσεις
όπου επιτρέπεται, γίνεται κλάδεμα των επόμενων κλαδιών.
INPUT: j, k : 1 ≤ j < k ≤ m(bj, . . . , bk, ci = ||b∗
i ||2∀i = j, . . . , k and µi,t: j ≤ t < i ≤ k)
OUTPUT: the minimal place (uj, . . . , uk) ∈ Zk−j+1 − k−j+1 and the minimum ¯cj of
cj(uj, . . . , uk) and bnew
j
01. ¯cj ← cj, ~uj ← uj = 1, yj ← ∆j = 0, s ← t ← j, δj = 1
02. for i = j + 1 to k + 1 do
03. ~ci ← ui ← ~ui ← yi ← ∆i = 0, δi = 1
04. while t ≤ k do
05. ~ct ← ~ct+1 + (yt + ~uj)2ct
06. If ~ct < ¯cj then
07. If t > j then
08. t ← t − 1, yt = s
i=t+1 ~uiµi,t, ~ut ← ut ← −yt , ∆t = 0
09. if ~ut > yt then
10. δt = −1
11. else
12. δt = 1
13. else
14. ¯cj ← ˜cj
15. for i = j to k
16. ui ← ˜ui
17. else
18. t ← t + 1, s ← max(s, t)
19. if t < s then
20. ∆t ← −∆t
21. if ∆tδt ≥ 0 then
22. ∆t ← ∆t + δt
23. ˜ut ← ut + ∆t

24. bnew
j ← k
i=j uibi
2.2.5 Hermite Korkine Zolotarev (HKZ)
Το 1850, ο Hermite εισήγαγε την έννοια της αναγωγής βάσης σε πλέγματα, για αυθαίρετη
τιμή διάστασης του πλέγματος [34]. Κάνοντας χρήση του ισχυρισμού αυτού, οι Korkine και
Zolotarev το 1873 ανέπτυξαν τον αλγόριθμο με όνομα HKZ–reduction [15, 21]. Η χαρακτη-
ριστική διαφορά του με τον αλγόριθμο του LLL είναι το γεγονός ότι ενώ ο τελευταίος επιλέγει
υποπλέγματα διάστασης ίση με 2 για την αναγωγή ολόκληρου του πλέγματος, ο HKZ επιλέγει
ολόκληρο το αρχικό πλέγμα. ΄Ετσι διαμορφώνεται μία Hermite–ανηγμένη βάση.
Συγκεκριμένα, μία ανηγμένη βάση Hermite είναι μία βάση η οποία πληρεί τις συνθήκες:
όπως αυτή περιγράφηκε παραπάνω
• συνθήκη Hermite
Για κάθε i, |v∗
i | = λ1(Li)(1 ≤ i ≤ n), όπου η ορθογωνιοποιημένη προβολή του δια-
νύσματος βάσης vi στο υποπλέγμα Li, το οποίο παράγεται από τα διανύσματα βάσης
{v1, . . . , vi−1}, αποτελεί το μικρότερο διάνυσμα της προβολής αυτής.
2.2.6 Kannan’s Algorithm
Ο αλγόριθμος αυτός αναπτύχθηκε από τον Kannan [13] το 1983 που αποτέλεσε, ουσιαστικά
την πρακτική εφαρμογή του αλγορίθμου HKZ. ΄Εστω το πλέγμα L ∈ Rm που έχει ως βάση το
διατεταγμένο σύνολο των διανυσμάτων b1, b2, . . . , bm ∈ Zm. Ο αλγόριθμος στοχεύει στην
εύρεση του μικρότερου διανύσματος που ανήκει στο L υπολογίζοντας μικρά διανύσματα σε
πλέγματα χαμηλότερων διαστάσεων.
Στο πρώτο βήμα του αλγορίθμου γίνεται η εύρεση μίας νέας βάσης πλέγματος, έστω
a1, a2, . . . , am ∈ Zm, για την οποία ισχύουν οι εξής συνθήκες:
1. Για 2 ≤ j ≤ n ισχύει |a∗
j | = λ1(Lj), όπου το Lj είναι το παραγόμενο υποπλέγμα
διάστασης j της νέας βάσης.
2. |a1|2 ≤ 4
3|a2|2
3. |a2(1)|2 ≤ 1
4|a1|2, όπου το στοιχείο a2(1) είναι το στοιχείο του διανύσματος a2, που
είναι παράλληλο στο διάνυσμα a1.
Προκύπτει από τις παραπάνω συνθήκες ότι:
|a1|2
≤ 2n(det(L)2/n
)

όπου προκύπτει ότι ο αλγόριθμος του Kannan υπολογίζει ένα αρκετά μικρότερο διάνυσμα,
συγκριτικά με τον αλγόριθμο LLL, αλλά με μεγαλύτερη χρονική πολυπλοκότητα. Η ακριβής
πολυπλοκότητα του είναι: O(nns), ὀπου το s συμβολίζει το μήκος της εισόδου.
Στο δεύτερο βήμα του αλγορίθμου ικανοποιούνται οι συνθήκες (1) και (3) από αυτές που πε-
ριγράφονται από πάνω, κατά τις οποίες το μικρότερο διάνυσμα πλέγματος πρέπει να ακολουθεί
το παρακάτω σχήμα:
x =
n
i=1
xiai, [x1, x2, . . . , xn] ∈ T ⊂ Zn
με των αριθμό των στοιχείων στο σύνολο T να ικανοποιεί τη σχέση:
|T| ≤
3n|a1|n
det(L)
Ο αλγόριθμος απαριθμεί όλα τα στοιχεία του T και βρίσκει το μικρότερο διάνυσμα x του
πλέγματος.
2.2.7 Blockwise Korkine Zolotarev (BKZ)
Ο αλγόριθμος αυτός αναπτύχθηκε από τους Schnorr και Euchner το 1993 [27] και βασίζε-
ται στην αρχική διατύπωση του Schnorr [26] το 1987, κατά την οποία υπάρχει μία ιεραρχική
συσχέτιση μεταξύ των αλγορίθμων του LLL και του HKZ, βάση της οποίας ανέπτυξε τη νέα
μέθοδο.
Οι τιμές που μπορεί να πάρει η μεταβλητή k αντιπροσωπεύουν το μήκος των κομματιών
(blocks) στην βάση πλέγματος που θα αναχθεί. Για την τιμή k = 2, ο αλγόριθμος είναι ι-
σοδύναμος με τον LLL και για την τιμή k = n, ο αλγόριθμος είναι ισοδύναμος με τον HKZ.
Η ακριβής πολυπλοκότητα του αλγορίθμου είναι:
O(n2
(kk/2+o(k)
+ n2
) log B)
όπου οι ακέραιοι στους οποίους εκτελούνται οι διάφορες αριθμητικές πράξεις έχουν δυαδικά
ψηφία της τάξης O(nlogB).
Η βασική ιδέα του αλγορίθμου αυτού είναι η γενίκευση του αλγορίθμου του LLL, για αναγω-
γή υποπλεγμάτων διάστασης μεγαλύτερης από 2, με χρήση του αλγορίθμου Kannan για την
αναγωγή αυτή.
΄Εστω k ≥ 2. Μία βάση πλέγματος b1, b2, . . . , bn ∈ Rm ονομάζεται k–ανηγμένη αν είναι
όπως αυτή περιγράφηκε παραπάνω.

• Για κάθε i = 1, 2, . . . , n − k + 1 τα διανύσματα
bi(i), bi+1(i), . . . , bi+k−1(i)
διαμορφώνουν μία Hermite–ανηγμένη βάση του υποπλέγματος Li.
Δηλαδή, οι προβολές των k συνεχόμενων διανυσμάτων βάσης bi, bi+1, . . . , bi+k−1 πάνω
στο ορθογώνιο συμπλήρωμα της παραγωγής (span) των πρώτων i − 1 διανυσμάτων βάσης
b1, b2, . . . , bi−1 διαμορφώνουν μία Hermite–ανηγμένη βάση του πλέγματος διάστασης k που
συνθέτουν.
Η έξοδος του αλγορίθμου δίνει ένα διάνυσμα x ∈ L τέτοιο ώστε να ισχύει:
|x| ≤ (6k2
)n/k
λ1(L)2
INPUT: Lattice basis:b1, . . . , bn ∈ Zn, Blocksize:k, Gram-Schmidt triangular matrix
µ, ||b∗
n||2, i = 1, . . . , n
OUTPUT: BKZ-k-reduced basis for L
01. z ← 0
02. j ← 0
03. LLL(b1, . . . , bn, µ)
04. while z < n − 1 do
05. j ← (j mod (n − 1)) + 1
06. d ← min (j + k − 1, n)
07. h ← min (d + 1, n)
08. u ← Enum(µ[j,d], ||b∗
j ||2, . . . , ||b∗
d||2)
09. if u = (1, 0, . . . , 0) then
10. z ← 0
11. LLL(b1, . . . , d
i=j, . . . , bh, µ) at stage j
12. else
13. z ← z + 1
14. LLL(b1, . . . , bh, µ) at stage h − 1
15. end if
16. end while

Κεφάλαιο 3
Το Subset Sum Problem στην
Κρυπτογραφία
3.1 Subset Sum Problem
Το Subset Sum Problem αποτελεί ένα σημαντικό πρόβλημα στην Επιστήμη των Υπολογι-
στών. Είναι μία εκδοχή του Προβλήματος του Σακιδίου (Knapsack Problem), αλλά
στο πλαίσιο της Κρυπτογραφίας τα δύο αυτά προβλήματα είναι συνήθως ταυτόσημα. Αναφορι-
κά με την πολυπλοκότητα, ανήκει στην κλάση NP-complete προβλημάτων. Η πολυπλοκότητα
του προβλήματος και το πως αυτή προκύπτει αναλύονται παρακάτω. ΄Αξιο αναφοράς αποτελεί
το γεγονός ότι τα προβλήματα του Subset Sum Problem1, μπορούν να επιλυθούν μεταξύ
διάφορων αλγορίθμων 2 και με ορισμένους που χρησιμοποιούν Δυναμικό Προγραμματισμό 3
4, αλλά και με τη μέθοδο ανάτρεξης (backtracking) 5.
3.1.1 Περιγραφή
Στην γενική περίπτωση του προβλήματος δίνεται ως δεδομένο ένα σύνολο θετικών ακεραίων
αριθμών και ένας αριθμός s και ζητείται ένα υποσύνολο που να έχει άθροισμα ίσο με το s.
Σε περιπτώσεις προβλημάτων όπου οι ακέραιοι αριθμοί μπορεί να είναι θετικοί και αρνητικοί,
ο αριθμός s μπορεί να πάρει και την τιμή 0. Πιο αναλυτικά:
Πρόβλημα του Σακιδίου (Subset Sum Problem) 6
΄Εστω a1, a2, . . . , an θετικοί ακέραιοι αριθμοί και s θετικός ακέραιος αριθμός, τέτοιος ώστε
max{ai} ≤ s ≤ n
i=1 ai, τότε ζητείται δυαδικό διάνυσμα (x1, x2, . . . , xn) ∈ {0, 1}n, εφόσον
υπάρχει, τέτοιο ώστε:
1
https://en.wikipedia.org/wiki/Subset sum problem
2
http://www.cs.dartmouth.edu/∼ac/Teach/CS105-Winter05/Notes/nanda-scribe-3.pdf
3
https://www.cs.cmu.edu/∼ckingsf/class/02713-s13/lectures/lec15-subsetsum.pdf
4
http://algorithms.tutorialhorizon.com/dynamic-programming-subset-sum-problem/
5
http://algorithms.tutorialhorizon.com/dynamic-programming-subset-sum-problem/
6
http://mathworld.wolfram.com/SubsetSumProblem.html
13

14 Κεφάλαιο 3. Το Subset Sum Problem στην Κρυπτογραφία
n
i=1
aixi = s
Το πρόβλημα αυτό λέμε ότι είναι διάστασης n. Μια ισοδύναμη μορφή του προβλήματος που
βρίσκεται και στο [29] αποτελεί η αντιστροφή του προβλήματος, όπου το s αντιστοιχίζεται
με το n
i=1 ai − s. Για την επίλυση του προβλήματος αυτού αρκεί η αλλαγή της λύσης σε
αρνητική, δηλαδή, αν η λύση του αρχικού προβλήματος είναι της μορφής x1, x2, . . . , xn, η
αντίστροφη μορφή έχει λύση ίση με 1 − x1, 1 − x2, . . . , 1 − xn.
Πυκνότητα (density) ενός προβλήματος Subset Sum ορίζεται η τιμή d για την οποία
ισχύει:
d =
n
log2 max(ai)
Η πολυπλοκότητα του Subset Sum Problem βασίζεται σε δύο παραμέτρους, το n, που αποτε-
λεί τον αριθμό των μεταβλητών απόφασης (διάσταση προβλήματος), καθώς επίσης και το P,
που αποτελεί την ακρίβεια του προβλήματος, δηλαδή τον αριθμό του δυαδικών ψηφίων των με-
ταβλητών που χρειάζονται για τον ορισμό του προβλήματος 7. Ωστόσο, υπάρχουν περιπτώσεις
όπου το συγκεκριμένο πρόβλημα μπορεί να μεταπηδήσει στην κλάση NP-Hard.
3.1.2 Το Subset Sum Problem στην Κρυπτογραφία
Τα Κρυπτοσυστήματα του Σακιδίου (Knapsack Cryptosystems) αποτελούν τα κρυπτοσυ-
στήματα που βασίζουν την ασφάλεια τους στην δυσκολία επίλυσης τους, ως προς την πολυ-
πλοκότητα, στο πρόβλημα του σακιδίου. ΄Ενα σημαντικό πλεονέκτημα τέτοιων κρυπτοσυστη-
μάτων αποτελεί η αποδοτικότητα τους, δεδομένου ότι η κρυπτογράφηση βασίζεται στην πράξη
του πολλαπλασιασμού, η οποία αποτελεί μία απλή πράξη συγκριτικά με άλλα κρυπτοσυστήματα
που βασίζουν τη δυσκολία τους στην παραγοντοποίηση ή στον διακριτό λογάριθμο. Αντίθετα,
η αποκρυπτογράφηση αποτελεί μία δύσκολη διαδικασία, αφού χρειάζεται η γνώση της πλη-
ροφορίας trapdoor, που εδώ είναι ο αριθμός s. Αξίζει να σημειωθεί ότι κατά την ανάπτυξη
αλγορίθμων κρυπτογράφησης, επιλέγεται το Subset Sum Problem. Αυτό οφείλεται στους
δύο παρακάτω λόγους.
Πρώτον, η συγκεκριμένη εκδοχή του προβλήματος χαρακτηρίζεται από μεγαλύτερη σαφήνεια,
δηλαδή ζητείται ένας συγκεκριμένος αριθμός ως λύση και όχι το μέγιστο δυνατό αποτέλεσμα
υπό περιορισμούς. Δεύτερον, είναι πιο απλουστευμένο, αφού εξισώνεται το βάρος με την τιμή
του κάθε αντικειμένου, και επομένως καθίσταται πιο ασφαλές.
Παρά το γεγονός της ύπαρξής τους εδώ και αρκετά χρόνια, παραμένουν μη δημοφιλή διότι
πολλά από αυτά έχουν σπάσει. Ωστόσο, εξακολουθούν να υπάρχουν κρυπτοσυστήματα τα
7
https://en.wikipedia.org/wiki/Subset sum problem#Complexity

3.1 Subset Sum Problem 15
οποία δεν έχουν παραβιαστεί [23]. Παρακάτω γίνεται παράθεση του γενικού σχήματος κρυ-
πτογράφησης που βασίζεται στο Subset Sum πρόβλημα και ήταν το πρώτο που αναπτύχθηκε
από τους Merkle και Hellman. Περισσότερα για το κρυπτοσύστημα αυτό μπορούν να βρεθούν
στην αμέσως επόμενη υπο-ενότητα.
΄Οπως, λοιπόν, περιγράφηκε και στον ορισμό του Subset Sum Problem τα κρυπτοσυ-
στήματα αυτά βασίζονται στην επίλυση της παρακάτω εξίσωσης:
n
i=1
xiai = s
με τα στοιχεία ai να συνθέτουν το διάνυσμα a, το s να είναι ένας μη αρνητικός ακέραιος
αριθμός και τα xi να είναι μη αρνητικοί ακέραιοι τέτοιοι ώστε, για κάποια σταθερά–όριο h,
οποία επιλέγεται τυχαία, να ισχύει η παρακάτω σχέση:
n
i=1
ai < h
Επιπροσθέτως, επιλέγεται τυχαία και ένας ακόμη ακέραιος αριθμός r, για τον οποίο ισχύει:
gcd(r, h) = 1, δηλαδή οι δύο αυτοί τυχαίοι είναι πρώτοι μεταξύ τους.
Το δημόσιο κλειδί παράγεται από τα στοιχεία bi για τα οποία ισχὐει:
bi = rai mod h
για όλα τα στοιχεία i. Το ιδιωτικό κλειδί αποτελείται από την τριάδα (α, h, r).
Για την διαδικασία κρυπτογράφησης, ακολουθείται η εξής διαδικασία:
Το αρχικό μήνυμα αντιστοιχεί σε ένα διάνυσμα της μορφής: M = x = (x0, x1, ..., xn−1).
Το δημόσιο κλειδί b χρησιμοποιείται για την κρυπτογράφηση του μηνύματος έτσι ώστε για τη
συνάρτηση της κρυπτογράφησης να ισχύει:
C = E(M) =
n
i=1
xibi
όπου C αποτελεί το κρυπτογραφημένο μήνυμα.
Στη συνέχεια, για την διαδικασία της αποκρυπτογράφησης, ακολουθείται η παρακάτω δια-
δικασία:
C = Cr−1
mod h ⇒ C =
n
i=1
xibir−1
mod h ⇐ C =
n
i=1
miai mod h

3.2 Κρυπτοσυστήματα με το Πρόβλημα του Σακιδίου
3.2.1 Merkle–Hellman
Το πιο γνωστό σύστημα κρυπτογράφησης που βασίζεται στο Subset Sum Problem, αποτελεί
το Κρυπτοσύστημα Σακιδίου Merkle–Hellman (Merkle–Hellman Knapsack Cryptosystem),
το οποίο αναπτύχθηκε από τους Merkle και Hellman το 1978 [19] και ήταν το πρώτο κρυπτο-
σύστημα που υλοποίησε την ιδέα Κρυπτογράφησης Δημοσίου Κλειδιού των Diﬃe και Hellman
το 1976 [9]. Η συνολική διαδικασία που ακολουθείται τόσο για την παραγωγή των κλειδιών,
όσο και για την κρυπτογράφηση και αποκρυπτογράφηση, είναι αυτή που μόλις περιγράφηκε.
Το κρυπτοσύστημα αυτό έσπασε από τον Shamir το 1983 [31], βασισμένο στην ιδέα του
ότι υπάρχει μια αύξουσα σειρά στους συντελεστές που συνθέτουν το πρόβλημα και έτσι η
κρυπταναλυτική μέθοδος που εφαρμόζεται είναι πολυωνυμικού χρόνου.
3.2.2 Chor–Rivest
Το κρυπτοσύστημα αυτό αναπτύχθηκε από τους Chor και Rivest το 1988 [6] και στηρίζεται
πάνω σε μία διαφορετική βάση, αυτή του διακριτού λογαρίθμου, με πυκνότητα ελεγχόμενη
από τις παραμέτρους κατασκευής, έτσι ώστε να είναι πιο ανθεκτικό σε επιθέσεις τύπου low–
density. Συγκεκριμένα, η κατασκευή του κάνει χρήση της μοναδικής αναπαράστασης των
αθροισμάτων σε πυκνά πεπερασμένα σώματα, ενός θεωρήματος που αναπτύχθηκε από τους
Bose και Chowla [4], με το οποίο εξασφαλίζεται ότι κάθε κείμενο προς κρυπτογράφηση έχει
μοναδική αναπαράσταση).
Μία σύντομη αναπαράσταση για την διαδικασία της κρυπτογράφησης και αποκρυπτογράφησης
του κειμένου μπορεί να βρεθεί στην αναφορά [2].
Το κρυπτοσύστημα αυτό έσπασε από τον Vaudenay το 1998 [33]. Αξιοσημείωτο από αυτήν
την επίθεση αποτελεί το γεγονός ότι η εύρεση του μυστικού κλειδιού χρειάζεται λιγότερο
χρόνο από ότι η παραγωγή του. Οι όποιες πιθανές βελτιώσεις προτάθηκαν αργότερα για να
κάνουν το κρυπτοσύστημα και πάλι ασφαλές το καταστούσαν μη εφαρμόσιμο.
3.2.3 Okamoto–Tanaka–Uchiyama (OTU) Scheme
Το κρυπτοσύστημα αυτό αναπτύχθηκε από τους Okamoto, Tanaka και Uchiyama το 2000 [24]
με τον χαρακτηρισμό του κρυπτοσυστήματος ως κβαντικό (Quantum Knapsack Cryptosy-
stem), ώστε να είναι ασφαλές σε κβαντικές επιθέσεις που κάνουν χρήση του αλγορίθμου του
Shor [32]. Αποτελεί το μοναδικό κρυπτοσύστημα βασισμένο στο Subset Sum πρόβλημα το
οποίο δεν έχει σπάσει ολοκληρωτικά.
΄Οπως και το κρυπτοσύστημα των Chor και Rivest βασίζει και αυτό το κομμάτι της παραγωγής
των κλειδιών στο πρόβλημα του διακριτού λογαρίθμου. Η ιδέα για να αντιμετωπίσουν τις επι-

3.3 Επιθέσεις στα Κρυπτοσυστήματα του Σακιδίου 17
θέσεις που είχαν προηγηθεί και να καλύψουν τις αδυναμίες των υπαρχόντων συστημάτων ήταν
να αναπτύξουν ένα κρυπτοσύστημα του οποίου η κρυπτογράφηση βασίζεται σε ένα πρόβλημα
knapsack με στοχευμένα χαμηλά βάρη, δηλαδή με συντελεστές χαμηλών τιμών, αντί για τους
τυχαίους που χρησιμοποιούνταν μέχρι τότε.
Η απόδειξη της αντιμετώπισης των low–density επιθέσεων βρίσκεται στην ενότητα 5.2 του [20].
Επιπλέον, μία σύντομη παρουσίαση της κατασκευής του κλειδιού, του τρόπου κρυπτογράφη-
σης και αποκρυπτογράφησης μπορεί να βρεθεί στο παράρτημα του [14], ενώ η εκτενέστερη
παρουσίαση του κρυπτοσυστήματος μπορεί να βρεθεί στην αρχική δημοσίευση του κρυπτοσυ-
στήματος [24].
Παρ΄όλο που υπάρχουν αναφορές σχετικά με επιθέσεις βασισμένες σε πλέγματα [12], [20],
[22] που θέτουν υπό αμφισβήτηση την ασφάλεια του κρυπτοσυστήματος, δεν υπάρχει κάποια
γνωστή επίθεση που να έχει καταφέρει αυτόν τον σκοπό, καθώς επίσης φαίνεται ασφαλές με
την κατάλληλη επιλογή των παραμέτρων.
3.3 Επιθέσεις στα Κρυπτοσυστήματα του Σακιδίου
Τα συστήματα αυτά θα μπορούσαν να χαρακτηριστούν γενικά ευπαθή, και αυτό οφείλεται στο
γεγονός ότι η όλη διαδικασία παραγωγής των κλειδιών κρυπτογράφησης αποτελείται από την
πράξη της πρόσθεσης, μια πράξη που δεν είναι ιδιαίτερα πολύπλοκη [23].
3.3.1 Επιθέσεις Χαμηλής Πυκνότητας (Low Density Attacks)
Μία από τις μεθόδους επίθεσης που αναπτύχθηκαν με σκοπό την κρυπτανάλυση συστημάτων
που βασίζονται στο πρόβλημα του Subset Sum αποτελεί η επίθεση που βασίζεται στην πυ-
κνότητα του προβλήματος. Γενικά, προβλήματα με d > 1, μπορεί να παράγονται από παραπάνω
από ένα πρόβλημα, με αποτέλεσμα να έχουν περισσότερες από μία λύσεις, και ως εκ τούτου
να μην αποτελούν ενδιαφέρουσα περίπτωση για τους σκοπούς της κρυπτογραφίας. Επομένως,
η ενδιαφέρουσα περίπτωση αφορά επιθέσεις σε κρυπτοσυστήματα με d ≤ 1. Μια εκ αυτών
αναπτύχθηκε από τους Lagarias και Odlyzko το 1984 [17]. Το πιο ενδιαφέρον σημείο σχετικά
με την επίθεση αυτή είναι ότι δεν βασίζεται σε κάποια υπόθεση σχετικά με τη κατασκευή του
συστήματος, εν αντιθέση αυτής του Shamir για το κρυπτοσύστημα των Merkle και Hellman,
και έτσι μπορεί να εφαρμοστεί σε οποιοδήποτε κρυπτοσύστημα με χαμηλής πυκνότητας συ-
ντελεστές.
Ωστόσο, επειδή το πρόβλημα ανήκει στην κλάση των NP-hard προβλημάτων, η συγκεκρι-
μένη μέθοδος δεν επιτυγχάνει πάντοτε. Πιο συγκεκριμένα, οι συνθήκες κάτω από τις οποίες
επιτυγχάνει αφορούν τις περιπτώσεις στις οποίες:
1. Η ύπαρξη ενός Shortest Vector Oracle (αναλύεται παρακάτω)
2. Η πυκνότητα του προβλήματος είναι: d < 0.645.

3. Η πυκνότητα του προβλήματος με n τιμές βαρών είναι της μορφής:
d < (2 − )(log24/3)−1
n−1, για οποιαδήποτε συγκεκριμένη τιμή του > 0.
Ειδικά η πρώτη υπόθεση είναι πολύ περιοριστική διότι, στην πράξη δεν υπάρχουν SVP–oracles.
Δηλαδή, δεν υπάρχουν πιθανοτικοί πολυωνυμικοί αλγόριθμοι που να δέχονται ως είσοδο ένα
πλέγμα και να εξάγουν ένα από τα μικρότερα διανύσματα. Αυτή η υπόθεση, ειδικά για μεγάλες
διαστάσεις δεν ισχύει. Για μικρές διαστάσεις, n ≤ 40, ο LLL συμπεριφέρεται ως SVP-oracle.
Η μέθοδος αυτή χρησιμοποιεί τον αλγόριθμου LLL και έτσι εγγυάται τόσο την εύρεση ενός
μικρού διανύσματος όσο και την εκτέλεση σε πολυωνυμικό χρόνο. Επιπλέον, η επίθεση αυτή
εγγυάται την εύρεση λύσεων σε πολυωνυμικό χρόνο σε –σχεδόν όλα– τα κρυπτοσυστήματα
των οποίων η πυκνότητα του Subset Sum προβλήματος είναι d < 0.645, σε συνδυασμό και με
τις υπόλοιπες συνθήκες.
Η αναλυτική περιγραφή του αλγορίθμου, που αποτελεί ουσιαστικά εφαρμογή του αλγορίθμου
LLL σε κατάλληλο πλέγμα, μπορεί να βρεθεί στο τέλος της ενότητας 2 της δημοσίευσης [17].
Παρόμοιο αποτέλεσμα αποδείχτηκε και από τον Brickell [3]. ΄Επειτα από τις δύο αυτές με-
θόδους για την κρυπτανάλυση συστημάτων που βασίζονται στο πρόβλημα του Subset Sum, η
εύρεση ενός διανύσματος με αλγορίθμους αναγωγής της βάσης στον χώρο του παραγόμενου
πλέγματος, ήταν –τις περισσότερες φορές– εφικτή για πυκνότητα d < 0.0645.
Μερικά χρόνια αργότερα στην μέθοδο που αναπτύχθηκε από τους Coster, Joux, LaMacchia,
Odlyzko, Schnorr και Stern [7] παρουσιάζονται δύο τροποποιήσεις, εκ των οποίων εκάστοτε
μπορεί να επιλύσει προβλήματα με πυκνότητα d < 0.9408, εφόσον η εύρεση του επιθυμητού μι-
κρού διανύσματος είναι πρακτικά εφικτή. Οι τροποποιήσεις αυτές παρουσιάζουν επιπροσθέτως
πρακτική βελτίωση σε συνδυασμό με γνωστούς αλγορίθμους αναγωγής της βάσης στον χώρο
του πλέγματος. Ωστόσο, όπως ήδη περιγράφηκε, οι μέθοδοι αυτοί χρησιμοποιούν την υπόθε-
ση ύπαρξης ενός SVP-oracle, το οποίο πρακτικά δεν υπάρχει.
Μέχρι τότε, οι διάφορες τροποποιήσεις πάνω στους αλγορίθμους που είχαν παρουσιαστεί,
καθιστούσαν την εύρεση ενός μικρού διανύσματος (short vector) στον χώρο ενός πλέγματος
σχετικά εύκολη διαδικασία κατά μέσο όρο, παρά το γεγονός ότι το άνω όριο της χειρότερης
περίπτωσης παρουσίαζε τη διαδικασία ως δύσκολη, αναφορικά με τον χρόνο.
Αναφορικά με το κρυπτοσύστημα των Chor και Rivest, ο τροποποιημένος αλγόριθμος που
αναπτύχθηκε μπορούσε να επιλύσει ένα πρόβλημα knapsack με διάσταση n = 103, ωστόσο δεν
ήταν σε θέση να σπάσει ολοκληρωτικά το σύστημα. Παρ΄όλα αυτά, η επιλογή ενός μεγαλύτερου
αριθμού n, καθιστούσε το κρυπτοσύστημα, αν και ασφαλές, μη πρακτικό.

3.3 Επιθέσεις στα Κρυπτοσυστήματα του Σακιδίου 19
3.3.2 Επιθέσεις που βασίζονται στο Παράδοξο των Γενεθλίων
Οι επιθέσεις αυτής της κατηγορίας βασίζονται στο παράδοξο των γενεθλίων. Η βασική ιδέα
πίσω από αυτή τη παραδοχή αποτελεί το γεγονός ότι το αρχικό πρόβλημα μπορεί να διασπα-
στεί σε υποδεέστερα, στα οποία μπορούν να βρεθούν ευκολότερα πάνω από μία λύσεις και ως
συνέπεια, οι «συγκρούσεις» μεταξύ των λύσεων των υπο-προβλημάτων μπορούν να οδηγήσουν
στην τελική επίλυση ολόκληρου του προβλήματος.
Ο πρώτος αλγόριθμος που βασίζεται στην ιδέα αυτή, αναπτύχθηκε από τους Schroeppel και
Shamir[30] το 1981 και ήταν ο καλύτερος μέχρι και το 2009 για την επίλυση δύσκολων προ-
βλημάτων knapsack με πυκνότητα δηλαδή, d ≈ 1. Ο αλγόριθμος αυτός είναι ντετερμινιστικός
με χρονική πολυπλοκότητα Õ(2n/2) και απαιτούμενη μνήμη O(2n/4), όπου n η διάσταση του
προβλήματος. Η επίθεση αυτή διασπά το αρχικό πρόβλημα στο ισοδύναμο που αποτελείται από
αντίστοιχα τέσσερα υπο-προβλήματα. Για τον σκοπό αυτό η επίθεση βασίζεται στην παραδοχή
ότι η διάσταση του προβλήματος είναι πολλαπλάσιο του 4. Στην βασική περίπτωση η επίθεση
έκανε και την παραδοχή ότι το hamming weight –το πλήθος των άσσων που εμφανίζονται
στη λύση του προβλήματος– είναι ίσο με n/2 (balanced knapsack). Ωστόσο, με μια μικρή
διαφοροποίηση στην ανάπτυξη του αλγορίθμου, μπορεί να γίνει εφαρμογή και σε περιπτώσεις
όπου κάτι τέτοιο δεν ισχύει (unbalanced knapsacks). Τέλος, για την εύρεση των πιθανών
λύσεων χρησιμοποιείται η τομή μεταξύ των υπο-προβλημάτων, κάτι που δικαιολογεί και τον
χαρακτηρισμό ως επίθεση παραδόξου των γενεθλίων.
Με βάση την προηγούμενη μέθοδο, αναπτύχθηκε η βελτίωση που υλοποιήθηκε από τους
Howgrave-Graham και Joux [11] το 2010. Ο στόχος αφορούσε και πάλι την επίλυση δύσκο-
λων προβλημάτων και πετύχαινε (ευρετική) χρονική πολυπλοκότητα Õ(20.337n) και απαιτούμε-
νη μνήμη Õ(20.256n). Το αξιοσημείωτο της μεθόδου αυτής αποτελεί τη διάσπαση του αρχικού
προβλήματος σε δύο υπο-προβλήματα, στα οποία ωστόσο, αυτή τη φορά, επιτρέπεται η αλλη-
λοκάλυψη, ενώ η διάσπαση γίνεται αναφορικά με το hamming weight. Η παραδοχή ότι το n
είναι πολλαπλάσιο του 4 εμφανίζεται και εδώ. Η λύση πάλι βρίσκεται με την τομή μεταξύ των
υπο-προβλημάτων.
Μία ακόμη βελτίωση υλοποιήθηκε από τους Becker, Coron και Joux [1] το 2011. Στην
βελτίωση αυτή, η πολυπλοκότητα είναι Õ(20.291n). Η διαφοροποίηση, συγκριτικά με τα προη-
γούμενα, έγκειται στο γεγονός της μεγαλύτερης ελευθερίας όσον αφορά τις λύσεις των υπο-
προβλημάτων, οι οποίες μπορούν να έχουν τιμές στο {-1, 0, 1} αντί του γνωστού έως τώρα
{0, 1}.

3.4 Επίλυση προβλημάτων με πυκνότητα περίπου ίση με
ένα
Η μέθοδος αυτή αναπτύχθηκε από τους Claus Peter Schnorr και Taras Shevchenko το 2012
[29] και βασίζεται και αυτή σε μεθόδους αναγωγής της βάσης πλέγματος με τροποποιημένη
χρήση του αλγορίθμου BKZ.
΄Οπως αναφέρεται και στον τίτλο τη σχετικής αναφοράς, η μέθοδος στοχεύει στην κρυπτα-
νάλυση συστημάτων που βασίζονται στο πρόβλημα Subset Sum με πυκνότητα περίπου ίση με
1, δεδομένου ότι αποτελούν τις πλέον ενδιαφέρουσες και μη τετριμμένες περιπτώσεις, δύσκο-
λων προβλημάτων Subset Sum.
Παρακάτω φαίνεται η μορφή του μητρώου βάσης το οποίο αποτελείται από διανύσματα στήλες
του πλέγματος βάσης B, πάνω στο οποίο εφαρμόζεται και ο αλγόριθμος.
B = [b1, . . . , bn+1] =











2 1
... O
...
O 2 1
Na1 · · · Nan Ns
0 0 0 1
N N N n
2 N











∈ Z(n+3)(n+1)
Η τελευταία γραμμή του πίνακα εξυπηρετεί την εύρεση λύσεων που ικανοποιούν τη σχέση
n
i=1 xi = n/2. Οι συντελεστές ai αποτελούν τυχαίους ακέραιους αριθμούς στο εύρος [1, 2n].
Τέλος, ο αριθμός N επιλέγεται έτσι ώστε να πληρεί τη συνθήκη N >
√
n.
΄Εστω B η βάση του πλέγματος στο οποίο αναζητείται λύση. Κάθε διάνυσμα b = (b1, . . . , bn+3)t ∈
L του πλέγματος με τα εξής χαρακτηριστικά:
|b1| = |b2| = · · · = |bn| = 1, |bn+2| = 1, bn+1 = bn+3 = 0
παράγει μία λύση της μορφής x1, . . . , xn για το πρόβλημα του σακιδίου, όπου xi = |bi −
bn+2|/2. Η λύση αυτή ικανοποιεί τη συνθήκη n
i=1 xi = n/2 και ο ισχυρισμός αυτός ισχύει
και αντίστροφα.
3.4.1 Περιγραφή Αλγορίθμου
Η μέθοδος που αναπτύχθηκε αποτελεί μία τροποποιημένη έκδοση της αντίστοιχης που α-
ναπτύχθηκε από τους Schnorr και Euchner το 1991 [27]. Πιο συγκεκριμένα, εκτελεί τον
αλγόριθμο BKZ για διαφορετικές τιμές μεγέθους τμήματος (blocksizes) σε συνδυασμό με

3.4 Επίλυση προβλημάτων με πυκνότητα περίπου ίση με ένα 21
μεταθέσεις στα διανύσματα της βάσης.
Στο πρώτο στάδιο του αλγορίθμου, εκτελείται επαναληπτικά η μέθοδος BKZ σε μία μετάθεση
της βάσης B χωρίς κλάδεμα (pruning) με τιμές μεγέθους τμήματος (blocksize) 2, 4, 8, 16, 32.
Σε κάθε επανάληψη, αφού γίνει εκτέλεση του BKZ, το μητρώο βάσης ανανεώνεται έτσι ώστε
οι πρώτες στήλες να αποτελούνται από μεταθέσεις των διανυσμάτων, τα οποία έχουν μη μηδε-
νικές εγγραφές στην θέση n + 2, και τα υπόλοιπα ταξινομούνται με βάση το μήκος τους. Με
αυτόν τον τρόπο η μέθοδος του BKZ επιδρά σε μεγάλο βαθμό στο διάνυσμα της στήλης n+1.
Στο δεύτερο στάδιο του αλγορίθμου, η επαναληπτική διαδικασία εφαρμόζεται κάθε φορά στην
αρχική βάση με τιμές από 30 μέχρι και 61, με βήμα ίσο με 1. Επιπροσθέτως, στο στάδιο
αυτό γίνεται κλάδεμα στο υπο εξέταση δένδρο των πιθανών λύσεων, όπως περιγράφεται στον
αλγόριθμο Enum, της ενότητας 2.2.4. Οι τιμές του κλαδέματος εναλλάσσονται σε κάθε ε-
πανάληψη στις τιμές 10, 11, 12, ανάλογα με τις διαφορετικές τιμές του μεγέθους τμήματος,
ώστε να διαμορφώνουν έναν όσον το δυνατόν αποτελεσματικότερο συνδυασμό τιμών.
Ο αλγόριθμος τερματίζει μόλις βρει κάποια λύση.
3.4.2 Σχόλια
Η εκτέλεση του αλγορίθμου BKZ με επαναληπτικό διπλασιασμό της τιμής του μεγέθους
τμήματος k είναι δύο φορές γρηγορότερη συγκριτικά με την αναγωγή μεγέθους τμήματος με
τιμή εξ αρχής ίση με 2l.
Παρά το γεγονός ότι η εκτέλεση του BKZ χωρίς κλάδεμα για τιμή μεγέθους τμήματος ίση
με 32 είναι αρκετά γρήγορη, αυτό παύει να ισχύει για μεγαλύτερες τιμές μεγέθους τμήματος.
Επομένως, στο δεύτερο στάδιο γίνεται ο αλγόριθμος BKZ εκτελείται με κλάδεμα για τιμές με-
γέθους τμήματος k ≥ 30. Προκύπτει ότι δύο επαναλήψεις του δεύτερου σταδίου με διακριτές
τιμές τμήματος μεγέθους και διακριτές τιμές της παραμέτρου κλαδέματος s έχουν επιτυχημένα
ποσοστά τα οποία είναι –σχεδόν– στατιστικά ανεξάρτητα. Με αυτόν τον τρόπο τυχαιοποιείται
και ο BKZ.
3.4.3 Ψευδοκώδικας
INPUT: Knapsack problem x1, . . . , xn ∈ {0, 1}
OUTPUT: blocksize of success round
01. Start: N >
√
n
02. Generate a coefficients ai ∈R [1, 2n].
03. Create basis matrix B = [b1, . . . , bn+1] with bi = (0, 0, . . . , 2, . . . , Nai, 0, N)t
and bn+1 = (1, . . . , 1, Ns, 1, n
2 N)t
04. for l = 1 to 5 do

05. BKZ Reduction with blocksize k ← 2l
06. if solution is found: goto End
07. update(B)
08. for l = 6 to 37 do
09. BKZ Reduction with blocksize k ← l+24 with pruning s ∈ {10, 11, 12}
10. if solution is found: goto End
11. End: output blocksize of success round
3.4.4 Εκτέλεση
Από την εκτέλεση 50 παραδειγμάτων που εκτελέστηκαν στην αντίστοιχη αναφορά [29], όπου
και μπορούν να βρεθούν, με διάσταση Subset Sum προβλήματος n = 80 και τιμή σταθεράς
N = 16 και χρήση της βιβλιοθήκης του Shoup, NTL [37], τα αποτελέσματα φαίνονται δια-
γραμματικά στα παρακάτω σχήματα:
Στο παραπάνω διάγραμμα φαίνεται ο αριθμός επιτυχιών σε κάθε διαφορετικό γύρο, με τους
γύρους μηδενικών επιτυχιών να παραλείπονται. Η αντιστοίχιση των γύρων με τον αριθμό των
διαφορετικών τιμών μεγέθους τμήματος έχει γίνει ως εξής: Γύρος 1 ← Blocksize 2, Γύρος 2
← Blocksize 4, . . ., Γύρος 5 ← Blocksize 32 για την πρώτη φάση του αλγορίθμου και στη
συνέχεια: Γύρος 6 ← Blocksize 30, Γύρος 7 ← Blocksize 31, . . ., Γύρος 37 ← Blocksize 61,
για την αντίστοιχη δεύτερη φάση του αλγορίθμου. Μία παρατήρηση που θα μπορούσε να γίνει
με βάση το σχήμα αυτό είναι ότι οι γύροι των επιτυχιών τείνουν να είναι συγκεντρωμένες στον
γύρο 5 για την πρώτη φάση και στους αρχικούς για τη δεύτερη φάση του αλγορίθμου.

3.4 Επίλυση προβλημάτων με πυκνότητα περίπου ίση με ένα 23
Στο παραπάνω διάγραμμα φαίνεται ο μέσος χρόνος για την εύρεση λύσης στον αντίστοιχο
γύρο. ΄Οπως είναι λογικό, η εύρεση λύσεων σε γύρους που αφορούν τη δεύτερη φάση του
αλγορίθμου και μεγαλύτερες τιμές blocksize απαιτούν μεγαλύτερο χρόνο, δεδομένου και του
μεγαλύτερου αριθμού επαναλήψεων. Ωστόσο, αυτό δεν είναι απόλυτο, όπως μπορεί να φανεί
από τη σύγκριση χρόνων μεταξύ των γύρων 10 με αυτούς των 11, 12 και 13 ή μεταξύ του
γύρου 15 με τον 16.

Κεφάλαιο 4
Πλατφόρμα SAGE
4.1 Εισαγωγή
Το SageMath [36] αποτελεί μία πλατφόρμα ανοιχτού λογισμικού που υποστηρίζει την α-
νάπτυξη προγραμμάτων για τους επιστημονικούς τομείς της ΄Αλγεβρας, της Γεωμετρίας, της
Θεωρίας Αριθμών, της Κρυπτογραφίας, του Μαθηματικού Λογισμού και άλλων παρεμφερών
πεδίων. Η συνολική ιδέα της ανάπτυξης της συγκεκριμένης πλατφόρμας βασίζεται στην ε-
λευθερία και στην ανοικτότητα του λογισμικού, στην κοινή συνεισφορά και στη συνεργασία,
παρέχοντας ένα μαθηματικό εργαλείο με δυνατότητες αντίστοιχες των λογισμικών του εμπο-
ρίου, δωρεάν, με την άδεια GPL.
Το SAGE χρησιμοποιεί σύνταξη παρόμοια με αυτή της γλώσσας προγραμματισμού python,
υποστηρίζοντας την ανάπτυξη διαδικασιών, συναρτήσεων και αντικειμενοστραφών δομών.
4.2 Ιστορία Ανάπτυξης
Το SageMath κατασκευάστηκε από τον Stein καθηγητή μαθηματικών στο Πανεπιστήμιο της
Washington, στις 24 Φεβρουαρίου του 2005. Το κίνητρο που τον παρακίνησε στην ανάπτυ-
ξη της εν λόγω πλατφόρμας ήταν το γεγονός ότι τα διάφορα μαθηματικά εργαλεία ανοικτού
λογισμικού είχαν αναπτυχθεί σε διαφορετικές γλώσσες προγραμματισμού, υλοποιώντας δια-
φορετικές δυνατότητες. Η ιδέα του λοιπόν, ήταν να κατασκευάσει μία ενιαία πλατφόρμα, η
οποία θα προσέφερε μια κοινή διεπαφή και θα απαιτούσε από τον χρήστη μόνο τη γνώση της
γλώσσας προγραμματισμού python για την χρήση της.
Αξίζει, τέλος, να σημειωθεί ότι το SageMath έχει λάβει αρκετές διακρίσεις, όπως αυτή του
πρώτου βραβείου επιστημονικού λογισμικού στον διαγωνισμό ελεύθερου λογισμικού Les Tro-
ph´ees du Libre το 2007, καθώς επίσης και το βραβείο Jenks από την κοινότητα ACM/SIG-
SAM το 2012.
25

26 Κεφάλαιο 4. Πλατφόρμα SAGE
4.3 Κώδικας
Ο κώδικας που παραθέτεται εδώ, έχει ακριβώς την ίδια μορφή με αυτή του αντίστοιχου αρχε-
ίου, που αναπτύχθηκε στην πλατφόρμα 1.
findSolution:
checks if there is a solution in the reduced base B according to the conditions of the
paper. Specifically, |bi| must be equal to 1, for i in [1, n], |bn+2| must be equal to 1 and
|bn+1|, |bn+3| must be equal to 0. If so, the solution is produced by the next formulation:
xi = (|bi − bn+2|)/2 and (xi) = n/2.
1 def findSolution(b):
2
3 n = len(b) -3
4 for i in xrange (0,n):
5 if (abs(b[i]) ==1):
6 temp = 0
7 else:
8 return 1,1
9 if temp == 0:
10 if (b[n]==0) & (abs(b[n+1]) ==1) & (b[n+2]==0):
11 x = vector ([0 for _ in range(n)])
12 for j in xrange (0,n):
13 x[j]= Integer(abs(b[j]-b[n+1]) /2)
14 return 0,x#Solution is found (indicated by
zero) and returned
Listing 4.1: findSolution
createMatrix:
creates the matrix given the positive integers vector a. ai coefficients are random numbers
in the range of [1, 2n] in order to produce density close to or almost equal to 1. The matrix
is created according to the paper. Specifically, for the (n − 1)(n − 3) part of the matrix
the main diagonal is equal to 2, for each i, the n(n − 3) row is equal to 1, for each i, the
(n − 2)-column is the Nai for each i of the ai coefficients, the (n − 1) column is zero for
each i, except of the last element, which is equal to 1 and the n column is equal to N for
each i, except of the last one which is equal to N(n/2).
1 def createMatrix(n, N, s, a):
2
3 B = Matrix(ZZ ,n+1,n+3)
4 for i in xrange (0,n):
5 B[i,i] = 2
1
https://cryptology.csd.auth.gr:8080/home/pub/0/

4.3 Κώδικας 27
6 B[n,i] = 1
7 B[i,n] = N*a[i]
8 B[i,n+2] = N
9 B[n,n+1] = 1
10 B[n,n] = N*s
11 B[n,n+2] = Integer ((n/2))*N
12 return B
Listing 4.2: createMatrix
randonVector:
generates a random binary vector with speciﬁc amount of |n−ham| zeros and |ham| ones.
1 def randomVector(n, ham):
2
3 randV = np.array ([0] * ham + [1] * (n-ham))
4 np.random.shuffle(randV)
5 return randV
Listing 4.3: randomVector
dotProduct:
computes the dot product of two vectors A and B.
1 def dotProduct(A, B):
2
3 return sum(map(operator.mul , A, B))
Listing 4.4: dotProduct
generateProblem:
Generates a knapsack problem of dimension n, density d and hammming weight ham.
1 def generateProblem (n, d, ham):
2
3 #generate random a coefficients in the range of [1,
2**((2 -d)*n))]
4 a = [random.randint (1 ,2**((2 -d)*n)) for _ in xrange(n)]
5 #get the density of the produces problem
6 density = float(n/math.log(max(a) ,2))
7 #solution of the problem
8 solution = randomVector(n, ham)
9 #get the dot product of the random vector and the a
coefficients
10 s = dotProduct(solution , a)
11 #print "Solution to be found :", solution

12 return a,s,density
Listing 4.5: generate
update:
updates the matrix according to the instructions of the paper. Specifically, first, the rows
of the basis matrix such that the first rows have a nonzero entry in column n+2 are
permuted and then the rest are sorted according to their lengths.
1 def update(B):
2
3 n = B.nrows () -1
4 C = Matrix(ZZ , n+1, n+3) #the matrix to be returned
5 p = [] #for indexing
6 toBeSorted = [] #vectors of basis with a zero entry at #(
n+2) position
7 #...we first permute the rows of the basis matrix such
that the first rows have a nonzero entry in column n+2
8 for i in xrange (0,n+1):
9 if (B[i,n+1] != 0):
10 p.append(i)
11 else:
12 toBeSorted.append(B[i])
13 np.random.shuffle(p)
14 #...,and then sort the vectors of the basis according to
their length preserving the particular initial rows.
15 toBeSorted.sort(cmp=lambda x,y:cmp(x.norm (2), y.norm (2)))
16 to = len(p)
17 #B is set back to its elements
18 for i in range(0,to):
19 C[i] = B[p[i]]
20 for i in range(0,len(toBeSorted)):
21 C[to+i] = toBeSorted[i]
22 return C
Listing 4.6: update
initialize:
initializes a knapsack instance by receiving as parameters both the dimension n and the
density of the problem to be created and to be used in order to execute the randomized
BKZ algorithm. The hamming distance ham is always set to the half of the dimension
of the problem. Thus, only balanced problems are to be executed. Variable N is set to
have value, as referred by the paper, N ≥
√
n and so, is set to be equal to (
√
n ∗ 2) + 2.
Following to setting all the requested parameters, both generateProblem and createMatrix
functions are called and the created matrix is returned.

1 def initialize(n, density):
2
3 ham = Integer(n/2)
4 N = Integer(ceil(sqrt(n)) * 2 - 2)
5 F = generateProblem (n, density , ham)
6 B = createMatrix(n, N, F[1], F[0])
7 return B
Listing 4.7: initialize
first:
first executes the first stage of the randomized–BKZ algorithm. During each iteration,
firstly, the basis matrix is updated by calling the update function and afterwards, the
BKZ reduction is executed with a respective value of blocksize. In each iteration, it is
checked whether a solution has be found. t start is used for measuring the time needed
for the solution to be found. Finally, min and sec are used for presenting the time needed
in minuted and seconds, respectively.
1 def first(B, t_start):
2
3 n = B.nrows () -1
4 for k in xrange (1,6):
5 B = update(B) #permute and sort
6 B = B.BKZ(block_size =2**k) #execute BKZ
7 solution = findSolution(B[0]) #check for a solution
8 if (solution [0] == 0):
9 t = time ()-t_start
10 min = t//60
11 sec = t - (min *60)
12 print "Time:",min ,"m",sec ,"s"
13 return 2**k
14 else:
15 print "No solution for blocksize" ,2**k
16 return -1
Listing 4.8: first
second:
second executes the second stage of the randomized–BKZ algorithm. During each itera-
tion, firstly, the basis matrix is being stored in another variable in order to be reset after
the end of that iteration. After that, s is selected as the parameter used for linear pruning
and then, the BKZ reduction is executed with a respective value of blocksize and the
computed s. In each iteration, it is checked whether a solution has be found. t start, min
and sec are used in the same sense as that of function first.

1 def second(C, t_start):
2
3 n = C.nrows () -1
4 start = (n//2) - 10
5 end = 2* start + 2
6 for k in xrange(start , end):
7 D = C #keeping the initial instance
8 s = (k%3) + (n//10) + 2
9 C = C.BKZ(block_size=k, prune=s)
10 solution = findSolution(C[0]) #check for a solution
11 if (solution [0] == 0):
12 t = time ()-t_start
13 min = t//60
14 sec = t - (min *60)
15 print "Time:",min ,"m",sec ,"s"
16 return k
17 else:
18 print "No solution for blocksize",k
19 C = D #reset matrix to the initial state
20 return -1
Listing 4.9: second
execute:
executes the algorithm of randomized–BKZ by simply calling the function with specific
dimension n and density density. After creating the basis matrix by calling the function
initialize and initializing the variable t start, first and second are consecutively called. If
the problem is solved, success is ≥ 0 and specifically contains the blocksize of the success
round.
1 def execute(n, density):
2
3 B = initialize(n, density)
4 C = B
5 t_start = time ()
6 success = first(B, t_start)
7 if(success ==-1): success = second(C, t_start)
8 if(success >0): print "Solution found for k:",success
9 if(success ==-1): print "No solution found!"
Listing 4.10: execute

4.4 Στατιστικά 31
4.4 Στατιστικά
Για τις τιμές εισόδου:
• διάσταση n = 80 και
• πυκνότητα d = 1.0
εκτελέστηκαν συνολικά 30 παραδείγματα τα αποτελέσματα των οποίων φαίνονται στον παρα-
κάτω πίνακα.
# of experiment solution round time
1 11 17.12
2 5 05.13
3 8 08.34
4 7 06.02
5 7 05.24
6 13 44.43
7 7 07.25
8 7 08.30
9 8 08.37
10 7 12.12
11 7 05.50
12 7 07.44
13 8 12.03
14 9 16.10
15 9 19.28
16 13 42.06
17 5 05.36
18 5 02.59
19 9 14.16
20 7 08.56
21 4 00.02
22 5 03.27
23 5 02.40
24 5 04.54
25 14 64.30
26 13 53.41
27 6 05.32
28 9 15.35
29 8 12.05
30 6 03.27

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

Κεφάλαιο 5
C/C++ και fpLLL
5.1 Βιβλιοθήκη fpLLL
Η βιβλιοθήκη fpLLL [35] αποτελεί την βασική βιβλιοθήκη που χρησιμοποιήθηκε για την α-
νάπτυξη της εφαρμογής στο πλαίσιο της εργασίας. Η βιβλιοθήκη αυτή αναπτύχθηκε από τους
Albrecht και Bai και περιέχει υλοποιήσεις διάφορων αλγορίθμων σε πλέγματα. Οι υλοποιήσεις
βασίζονται σε ορθωγονιοποιήσεις στοιχείων κινητής υποδιαστολής, ενώ ο αλγόριθμος LLL
αποτελεί βασικό στοιχείο της βιβλιοθήκης, από όπου προέκυψε και το όνομα της.
Η μοναδική διαφορά μεταξύ του κώδικα που αναπτύσσεται εδώ και αυτού του Schnorr, αποτε-
λεί το γεγονός ότι εδώ το μητρώο βάσης περιέχει διανύσματα γραμμές, αντί για τα αντίστοιχα
διανύσματα στήλες της αναφοράς [29].
Τα διάφορα μηνύματα παράγονται στην έξοδο με τη μορφή λάθους (error messages) με την
εντολή cerr, ώστε να μπορούν να αγνοηθούν με την χρήση του κατάλληλου ﬂag, εφόσον ο
χρήστης επιθυμεί να μην υπάρχει καμία αλληλεπίδραση τύπου I/O από το πρόγραμμα.
5.2 Κώδικας
1 IntMatrix* initialize ()
2 {
3 z0.set (0); z1.set (1); z2.set (2); zN.set(N); zN2.set(n/2);/// initializing values
4 vector <Integer > *a = generateProblem ();///generating the coefficients
5 ///get and print density of the problem
6 Integer maxV; maxV.set (0);
7 vector <Integer >:: iterator itM;
8 for(itM=a->begin (); itM <a->end (); ++itM)
9 {
10 maxV = (*itM > maxV) ? *itM : maxV;
11 }
12 double logged = log2(maxV.get_d ());
13 double density = n/logged;
14 message <<"Density is: "<<density <<endl;
15 cerr <<"Density is: "<<density <<endl;
16 vector <int > *solution = randomVector ();///generating a subset sum solution
33

34 Κεφάλαιο 5. C/C++ και fpLLL
17 ///print solution to be found
18 vector <int >:: iterator it;
19 cerr <<"Solution to be found"<<endl;
20 for(it=solution ->begin (); it <solution ->end (); ++it)
21 {
22 cerr <<*it <<" ";
23 }
24 dotProduct(a, solution); ///getting the inner product
25 IntMatrix* B = createMatrix (a); ///creating the basic matrix
26 ///deleting the unnecessary object
27 delete a;
28 delete solution;
29 ///returning the generated matrix
30 return B;
31 }
Listing 5.1: initialize
Η συνάρτηση αυτή αποτελεί την αρχικοποίηση του προγράμματος που αναπτύχθηκε και την
συνολική κατασκευή του μητρώου βάσης, πάνω στο οποίο γίνεται η αναγωγή. Συγκεκριμένα,
αρχικοποιεί όλες τις απαραίτητες παραμέτρους που θα χρειαστούν για την εκτέλεση ενός πα-
ραδείγματος με συγκεκριμένα χαρακτηριστικά, αναφορικά με τη διάσταση του προβλήματος
καθώς επίσης και τη πυκνότητα αυτού. Οι συναρτήσεις που καλούνται αναλύονται παρακάτω
και οι κλήσεις αυτές έχουν συγκεκριμένη σειρά. Μετά την παραγωγή των τυχαίων συντελε-
στών του διανύσματος a (γραμμή 4), βρίσκεται η ακριβής πυκνότητα του προβλήματος με τον
τύπο που περιγράφηκε στην Ενότητα 3.1.1 και εκχωρείται στην εντολή density. Στη συνέχεια
(γραμμή 16) παράγεται ένα τυχαίο balanced subset sum πρόβλημα, το οποίο και εκτυπώνεται
με τη βοήθεια του iterator *it. Επιπροσθέτως, βρίσκεται ο συντελεστής s (άθροισμα προ-
βλήματος), όπως θα αναλυθεί παρακάτω (γραμμή 24) και σχηματίζεται το μητρώο βάσης B,
το οποίο εκχωρείται στο αντικείμενο *B της κλάσης IntMatrix. Τέλος, τα μη απαραίτητα
αντικείμενα διαγράφονται για εξοικονόμηση μνήμης και το αντικείμενο B επιστρέφεται.
1 IntMatrix* createMatrix (vector <Integer > *a)
2 {
3 IntMatrix* B = new IntMatrix(n+1, n+3);///the basis matrix
4 Integer z;///used as an assisting variable
5 for(int i=0; i<n; ++i)
6 {
7 B[0][i][i] = z2;
8 B[0][n][i] = z1;
9 ///for a coefficients
10 z = a->at(i); z.mul(zN , z);
11 B[0][i][n] = z;
12 B[0][i][n+2] = zN;
13 }
14 B[0][n][n+1] = z1;
15 z.mul(zN , inner); B[0][n][n] = z;
16 z.mul(zN2 , zN); B[0][n][n+2] = z;
17 return B;
18 }
Listing 5.2: createMatrix

Η συνάρτηση αυτή κατασκευάζει το μητρώο B, που αποτελεί το μητρώο βάσης B του πλέγμα-
τος L όπως αυτό ορίστηκε από την αντίστοιχη αναφορά [29]. Ως όρισμα δέχεται το διάνυσμα
με τα τυχαίους συντελεστές ai που παρήχθησαν από τη συνάρτηση generateProblem. Κατά
την αρχικοποίηση του πίνακα (γραμμή 3) όλα τα στοιχεία του έχουν τιμή ίση με 0. Η βοηθη-
τική μεταβλητή z αποτελεί το στοιχείο με τύπο δεδομένου Integer με σκοπό την εκτέλεση
πράξεων με χρήση της μεταβλητής αυτής και των στατικών μεταβλητών z1, z2, zN, zN2 και
inner. Η εκχώρηση των διάφορων τιμών γίνεται με επαναληπτική διαδικασία, στην οποία
εκχωρούνται και οι τυχαίες τιμές του διανύσματος a (γραμμή 10). Η συνάρτηση τελικά επι-
στρέφει τον πίνακα που κατασκευάστηκε.
1 vector <short >* findSolution (IntMatrix *B)
2 {
3 short sol;
4 vector <short > *x = new vector <short >; ///vector for possible solution
5 x->push_back (-1); ///-1 found -> no solution found
6 Integer z;
7 int temp = 1;
8 for(int j = 0; j < n; ++j)
9 {
10 z.abs(B[0][0][j]);
11 if (z.cmp(z1) == 0) temp = 0;
12 else
13 {
14 return x;
15 }
16 }
17 if (temp == 0)
18 {
19 Integer zn1; Integer zn; Integer zn2;
20 zn1.abs(B[0][0][n+1]); zn.abs(B[0][0][n]); zn2.abs(B[0][0][n+2]);
21 if ((zn1.cmp(z1) == 0) && (zn.cmp(z0) == 0) && (zn2.cmp(z0) == 0))
22 {
23 x->clear (); /// eliminating the negative value
24 for(int j = 0; j < n; ++j)
25 {
26 z.sub(B[0][0][j],B[0][0][n+1]);
27 z.abs(z);
28 ///instead of dividing by 2, explicitly set to 0 or 1
29 sol = (z > 0) ? 1 : 0;
30 x->push_back(sol);
31 }
32 return x;
33 }
34 }
35 return x;
36 }
Listing 5.3: ﬁndSolution
Η συνάρτηση αυτή ελέγχει την πιθανή ύπαρξη λύσης στην πρώτη γραμμή του αντικειμένου
που αντιπροσωπεύει το μητρώο βάσης και δίνεται στην συνάρτηση ως όρισμα (*B). Σε κάθε
περίπτωση, είτε μία λύση έχει βρεθεί είτε όχι, επιστρέφεται ένα διάνυσμα. Το διάνυσμα αυτό
περιέχει την λύση στην περίπτωση όπου αυτή έχει βρεθεί ή μία μοναδική τιμή (−1) (γραμμή

5) στην αντίθετη περίπτωση. Αρχικά (γραμμή 8), γίνεται ο έλεγχος κατά τον οποίο πρέπει
να ικανοποιείται η συνθήκη |b1| = |b2| = . . . = |bn| = 1. Στην περίπτωση όπου όλα αυτά
τα στοιχεία είναι ίσα με 1, η βοηθητική μεταβλητή temp, έχει την τιμή 0 και η εκτέλεση
της μεθόδου συνεχίζεται (γραμμή 14). Στη συνέχεια (γραμμή 17), ελέγχονται οι υπόλοιπες
συνθήκες (|bn+2| = 1 και bn+1 = bn+3 = 0). Στην περίπτωση που ικανοποιούνται όλες,
τότε κατασκευάζεται η λύση, πάλι κατά τα πρότυπα της αναφοράς, δηλαδή βάση του τύπου
|bi − bn+2|/2. Αξίζει να σημειωθεί ότι λόγω της μη υποστήριξης της πράξης της διαίρεσης
από την βιβλιοθήκη fpLLL, η πράξη αυτή αντικαταστάθηκε από την αντίστοιχη |bi −bn+2| και
στη συνέχεια με μία σύγκριση με το 0, βάση του οποίου αποφασίζεται αν τελικώς υπάρχει 0 ή
1 στην λύση (γραμμές 29 και 30). Τέλος, όπως αναφέρθηκε παραπάνω, το διάνυσμα σε κάθε
περίπτωση επιστρέφεται.
1 vector <int >* randomVector ()
2 {
3 vector <int > *randV = new vector <int >; ///represents the vector a
4 for(int i=0; i<n-ham; ++i) randV ->push_back (0);
5 for(int i=n-ham; i<n; ++i) randV ->push_back (1);
6 random_device rd;
7 mt19937 mt(rd());
8 shuffle(randV ->begin (), randV ->end(), mt);
9 return randV; ///return the vector
10 }
Listing 5.4: randomVector
Η συνάρτηση αυτή παράγει ένα τυχαίο balanced πρόβλημα subset sum. Συγκεκριμένα, με
την χρήση της μεταβλητής ham, που έχει αρχικοποιηθεί σε προηγούμενο βήμα και συμβολίζει
το hamming weight, αρχικοποιείται ένα διάνυσμα (*randV) με ίσο πλήθος άσσων (1) και
μηδενικών (0). Για την τυχαιοποίηση του προβλήματος αυτού χρησιμοποιούνται οι τυχαίες
μηχανές random device και mt19937 (γραμμές 7 και 8) σε συνδυασμό με την τυχαία διαδι-
κασία shuffle (γραμμή 8), που κάνει το «ανακάτεμα» του διανύσματος. Τέλος, το διάνυσμα
αυτό επιστρέφεται.
1 void dotProduct(vector <Integer > *A, vector <int > *B)
2 {
3 Integer a; Integer b;
4 Integer mul; mul.set (1);
5 Integer sum; sum.set (0);
6 int lenA = A->size ();///set the size
7 for(int i=0; i<lenA; ++i)
8 {
9 a = A->at(i);
10 b.set(B->at(i));
11 mul.mul(a, b);
12 sum.add(sum , mul);
13 }
14 inner = sum;
15 }
Listing 5.5: dotProduct

Η συνάρτηση αυτή υπολογίζει το εσωτερικό γινόμενο των δύο διανυσμάτων *A και *B, που
δίνονται ως όρισμα. Το πρώτο διάνυσμα, αντιπροσωπεύει το διάνυσμα των τυχαίων συντελε-
στών ai, ενώ το δεύτερο το παραγόμενο πρόβλημα subset sum. Ο υπολογισμός γίνεται με την
χρήση μίας επαναληπτικής διαδικασίας που διατρέχει όλα τα στοιχεία των δύο διανυσμάτων
(γραμμή 7), σε συνδυασμό με τις βοηθητικές μεταβλητές sum και mul. Η πρώτη αυξάνει την
τιμή της με τη νέα ποσότητα που υπολογίστηκε, ενώ η δεύτερη υπολογίζει το γινόμενο δύο
αντίστοιχων ποσοτήτων. Τέλος, η ποσότητα αυτή εκχωρείται στην μεταβλητή inner (γραμμή
14). Το στοιχείο που επηρεάζεται στον πίνακα μητρώου από αυτή την ποσότητα βρίσκεται
στην θέση Bn+1,n+1.
1 vector <Integer >* generateProblem ()
2 {
3 vector <Integer > *a = new vector <Integer >; ///represents the vector a
4 random_device rd;
5 unsigned int random_num;
6 unsigned long int lower_bound = 1;
7 unsigned long int upper_bound = ULLONG_MAX;
8 uniform_int_distribution <unsigned long int > unif(lower_bound , upper_bound );
9 int bit = n * (2 - d);
10 mp_bitcnt_t bits; bits = bit;
11 mpz_t seed; mpz_t random_int;
12 Integer z;
13 gmp_randstate_t grt;
14 ///generate random coefficients in the range [1, 2^n]
15 for(int i=0; i<n; ++i)
16 {
17 random_num = unif(rd); ///get a random number for seeding
18 mpz_init_set_ui (seed , random_num); ///set the number to the seed
19 gmp_randinit_default (grt); ///initialize state
20 gmp_randseed (grt , seed); ///initialize random machine
21 mpz_init2(random_int , bits); ///initialize random_int variable
22 mpz_urandomb (random_int , grt , bits); ///get a random num of n bits
23 z.set(random_int); ///turn it to Integer
24 a->push_back(z); ///append it to vector
25 gmp_randclear (grt); ///clear generator
26 }
27 return a;
28 }
Listing 5.6: generateProblem
Η συνάρτηση αυτή παράγει τους συντελεστές ai του τυχαίου διανύσματος a. Για την διαδικα-
σία αυτή χρησιμοποιούνται οι διαδικασίες της γλώσσας C++, random device (γραμμή 5) και
uniform int distribution (γραμμή 8) για την παραγωγή των αριθμών seed, που θα αρχι-
κοποιήσουν τους γεννήτορες με σκοπό την παραγωγή αριθμών με συγκεκριμένο αριθμό από
bits, δηλαδή στο επιθυμητό εύρος [1, 2n], όπου n η διάσταση του προβλήματος. Ο προσδιο-
ρισμός της ακρίβειας των δυαδικών ψηφίων γίνεται με την χρήση της βοηθητικής μεταβλητής
bit καθώς επίσης και της αντίστοιχης της βιβλιοθήκης gmp, bits. Σε κάθε επανάληψη της
επαναληπτικής διαδικασίας, αρχικοποιείται η αντίστοιχη συνάρτηση παραγωγής αριθμών της
βιβλιοθήκης gmp, gmp randseed (γραμμή 20) και παράγεται ένας τυχαίος ακέραιος αριθμός
στο επιθυμητό εύρος με την κλήση της μεθόδου mpz urandomb (γραμμή 22). Η τιμή αυτή εκ-

χωρείται κάθε φορά στην βοηθητική μεταβλητή z (γραμμή 23) και προστίθεται στο διάνυσμα.
Αφού ολοκληρωθεί η διαδικασία αυτή, το διάνυσμα επιστρέφεται.
1 IntMatrix *update(IntMatrix* B)
2 {
3 vector <int > *permuted = new vector <int >;///contains the rows to be permuted
4 vector <int > *sorted = new vector <int >;///contains the rows to be sorted
5 for(int i=0; i<n+1; ++i)
6 {
7 if(B[0][i][n+1] != z0)
8 {
9 permuted ->push_back(i);
10 }
11 else
12 {
13 sorted ->push_back(i);
14 }
15 }
16 ///sort scope
17 Integer norm; norm.set (0); ///represents the length of the row
18 Integer length; length.set (1); ///represents the value to be powered
19 vector <length_row > *norms = new vector <length_row >; ///contains the lengths
20 length_row *len = new length_row; ///mapping the rows to their length
21 ///iteratively compute the length of the rows to be sorted
22 vector <int >:: iterator v = sorted ->begin (); ///iterator for the sorted vector
23 while(v!=sorted ->end ())
24 {
25 ///compute the length of row iteratively
26 for(int j=0; j<n+2; ++j)
27 {
28 length.mul(B[0][*v][j], B[0][*v][j]);
29 norm.add(norm , length);
30 }
31 len ->norm = norm;
32 len ->row = *v;
33 norms ->push_back (* len);
34 norm.set (0);
35 v++;
36 }
37 delete len;///delete the unnecessary object
38 sort(norms ->begin (), norms ->end (), comp); ///sort the rows to their length
39 ///permutation scope
40 random_device rd;
41 minstd_rand gen(rd());
42 shuffle(permuted ->begin (), permuted ->end (), gen); ///shuffle permuted vector
43 IntMatrix* C = new IntMatrix(n+1, n+3); ///the updated matrix
44 int to = permuted ->size (); ///represents the ending index of permuted rows
45 ///set the rows to the new matrix
46 for(int i=0; i<to; ++i)
47 {
48 for(int j=0; j<n+3; ++j)
49 {
50 C[0][i][j] = B[0][ permuted ->at(i)][j];
51 }
52 }
53 for(int i=to; i<n+1; ++i)
54 {
55 for(int j=0; j<n+3; ++j)

56 {
57 C[0][i][j] = B[0][ norms ->at(i-to).row][j];
58 }
59 }
60 ///delete the unnecessary object
61 delete sorted;
62 delete permuted;
63 delete norms;
64 return C; ///return the updated matrix
65 }
Listing 5.7: update
Η συνάρτηση αυτή ανανεώνει το μητρώο βάσης, το οποίο δέχεται και ως όρισμα, κατά το
πρώτο κομμάτι του αλγορίθμου. Συγκεκριμένα, χρησιμοποιούνται δύο διανύσματα τα οποία
αποθηκεύουν τις θέσεις στις οποίες αντίστοιχα υπάρχει (διάνυσμα sorted) ή δεν υπάρχει (δι-
άνυσμα permuted) μηδενικό στοιχείο στη θέση n + 1 των διανυσμάτων του μητρώου βάσης.
Στη συνέχεια, υπολογίζεται το μέτρο των διανυσμάτων (διάνυσμα norms) που βρίσκονται στις
θέσεις που αποθηκεύτηκαν στο διάνυσμα sorted, με σκοπό να ταξινομηθούν με βάση την τιμή
αυτή. Για την ταξινόμηση αυτή χρησιμοποιείται ο συγκριτής comp ως όρισμα στην εκτέλεση
του αλγορίθμου ταξινόμησης sort. Ακολούθως, οι υπόλοιπες θέσεις επαναπροσδιορίζονται
σε νέες τυχαίες θέσεις, μια διαδικασία γνωστή και ως permutation, που εκτελείται με την
μέθοδο shuffle. Τέλος, κατασκευάζεται ένας νέος πίνακας που περιέχει στις πρώτες θέσεις
τα διανύσματα όπως αυτά προέκυψαν μετά το ανακάτεμα (permutation) και τα υπόλοιπα τα-
ξινομημένα ως προς το μέτρο τους.
1 int first(IntMatrix *B)
2 {
3 int blocksize; ///represents the number of blocksize
4 vector <short > *solution; ///represents the possible solution found
5 for(int k=1; k <6; ++k)
6 {
7 B = update(B); ///update the matrix with permutation and sorting
8 blocksize = (int)pow (2.0 , k); ///setting the blocksize
9 bkzReduction (*B, blocksize , BKZ_DEFAULT , FT_DEFAULT , 0); ///bkz reduction
10 solution = findSolution (B); ///checking for a solution
11 if(solution ->at(0) != -1)
12 {
13 clock_end = clock ();///stop timer
14 cerr <<"No solution found at round: "<<k<<endl;
15 vector <short >:: iterator it;
16 for(it=solution ->begin (); it <solution ->end (); ++it)
17 {
18 cerr <<*it <<" ";
19 }
20 cerr <<endl;
21 return blocksize;
22 }
23 else
24 {
25 cerr <<"No solution found at round: "<<k<<endl;
26 message <<"No solution found at round: "<<k<<endl;
27 }

28 }
29 return -1;
30 }
Listing 5.8: ﬁrst
Η συνάρτηση αυτή εκτελεί το πρώτο κομμάτι του αλγορίθμου BKZ, έτσι όπως αυτό περιγράφε-
ται στην αντίστοιχη αναφορά. Σε κάθε επανάληψη, δηλαδή σε κάθε αναγωγή με διαφορετικό
αριθμό blocksize, γίνεται αρχικά η ανανέωση του μητρώου (γραμμή 7) και στη συνέχεια η
εκτέλεση της αναγωγής με την κλήση της μεθόδου bkzReduction. Αμέσως μετά, γίνεται
έλεγχος για εύρεση λύσης. Σε περίπτωση που η λύση έχει βρεθεί ο αλγόριθμος τερματίζει,
με την εμφάνιση του γύρου στον οποίο βρέθηκε η λύση αλλά και την λύση.
1 int second(IntMatrix *C, int start , int end , int step)
2 {
3 int s; ///represents the pruning gradient
4 vector <short > *solution; ///represents the possible solution found
5 ///elements for BKZ execution
6 IntMatrix *D = new IntMatrix(C->getRows (), C->getCols ());
7 BKZParam param;
8 for(int k=start; k<end; k+= step)
9 {
10 *D = *C; ///reset the matrix
11 s = (k%3) + n/10 + 2;
12 param.blockSize = k; ///setting the blocksize
13 param. enableLinearPruning (s); ///setting the level of linear pruning
14 bkzReduction (D, NULL , param , FT_DEFAULT , 0); ///bkz reduction execution
15 solution = findSolution (D); ///checking for a solution
16 if(solution ->at(0) != -1)
17 {
18 clock_end = clock ();///stop timer
19 cerr <<"Solution found at round: "<<k-24<< endl;
20 vector <short >:: iterator it;
21 for(it=solution ->begin (); it <solution ->end(); ++it)
22 {
23 cerr <<*it <<" ";
24 }
25 cerr <<endl;
26 return k;
27 }
28 else
29 {
30 cerr <<"No solution found at round: "<<k-24<< endl;
31 message <<"No solution found at round: "<<k-24<< endl;
32 }
33 }
34 return -1;
35 }
Listing 5.9: second
Η συνάρτηση αυτή εκτελεί το δεύτερο κομμάτι του αλγορίθμου BKZ, έτσι όπως αυτό περι-
γράφεται στην αντίστοιχη αναφορά. Σε κάθε επανάληψη, όπως και πριν, γίνεται έλεγχος για
εύρεση λύσης. Η βασική διαφορά με την προηγούμενη συνάρτηση είναι η χρήση της μεταβλη-
τής s που αντιπροσωπεύει τον συντελεστή του γραμμικού κλαδέματος (Linear Pruning). Ο

5.3 Εκτέλεση Παραδειγμάτων 41
συντελεστής δίνεται ως όρισμα στην αντίστοιχη κλήση της μεθόδου enableLinearPruning
του αντικειμένου param, της κλάσης BKZParam. Η κλάση αυτή περιέχει επιπλέον χαρακτηρι-
στικά αναφορικά με την εκτέλεση της μεθόδου αναγωγής. Τέλος, και εδώ, σε περίπτωση που
η λύση έχει βρεθεί ο αλγόριθμος τερματίζει, με τις ανάλογες εμφανίσεις.
5.3 Εκτέλεση Παραδειγμάτων
Στο σύνολο των παραδειγμάτων που εκτελέστηκαν, έγινε αρχικά παραμετροποίηση ως προς
την πυκνότητα των προβλημάτων που παραγόντουσαν. Οι τιμές της πυκνότητας είναι d =
0.9, d = 0.95 και d = 1. Η διάσταση όλων των προβλημάτων είναι n = 80 με συντελεστή
N = 16. ΄Ολα τα προβλήματα είναι ίσων βαρών αναφορικά με την απόσταση hamming. Εκτε-
λέστηκαν 30 παραδείγματα για κάθε τιμή πυκνότητας.
Τα αποτελέσματα συνολικά φαίνονται παρακάτω:
Για τιμή πυκνότητας d = 0.9 τα αποτελέσματα φαίνονται παρακάτω.
1 5 00.33
2 6 01.47
3 7 01.55
4 9 04.28
5 5 00.46
6 5 00.59
7 5 00.27
8 6 01.21
9 8 02.05
10 6 01.42
11 9 04.22
12 5 00.48
13 9 03.22
14 5 01.12
15 5 00.24
16 6 01.25
17 10 04.33
18 8 02.37
19 9 04.24
20 10 03.55
21 8 02.44
22 9 03.17
23 5 00.47
24 6 01.20
25 5 00.29
26 7 02.02
27 10 06.23
28 10 02.39
29 6 00.59
30 5 00.25

Για τιμή πυκνότητας d = 0.95 τα αποτελέσματα φαίνονται παρακάτω.
1 7 01.59
2 5 00.53
3 7 02.11
4 10 04.30
5 10 04.29
6 10 05.30
7 7 01.16
8 9 03.51
9 5 01.09
10 10 05.05
11 10 06.44
12 7 02.42
13 12 06.56
14 5 00.43
15 5 01.23
16 14 23.19
17 5 00.38
18 7 03.06
19 9 05.33
20 10 04.50
21 9 03.37
22 9 02.25
23 6 02.03
24 9 04.19
25 6 01.04
26 7 01.14
27 5 00.38
28 9 03.09
29 6 00.53
30 14 22.05
Για τιμή πυκνότητας d = 1 τα αποτελέσματα φαίνονται παρακάτω.
1 7 02.11
2 12 10.26
3 10 04.45
4 5 01.09
5 9 03.35
6 5 02.45
7 9 05.41
8 11 11.41
9 8 04.09
10 7 02.46
11 7 01.44
12 6 02.23
13 6 00.31
14 9 04.12
15 9 04.34
16 9 03.50
17 6 02.07
18 10 05.27
19 11 05.10
20 9 04.37
21 9 03.01
22 5 01.21
23 5 00.29
24 9 03.46
25 9 03.36
26 5 00.34
27 10 04.31
28 9 04.10
29 5 01.06
30 6 01.12
5.4 Συμπεράσματα
Αρχικά, είναι εμφανές ότι για μία ακόμη φορά ο αλγόριθμος τερματίζει είτε στον Γύρο 5 από
το πρώτο στάδιο, είτε στους αρχικούς από το δεύτερο στάδιο. Αυτό που αξίζει να σημειωθεί

5.5 Εκτέλεση του BKZ 2.0 43
αναφορικά με τη συσχέτιση της επίλυσης του προβλήματος με την πυκνότητά του είναι ότι
οι ποσότητες αυτές δείχνουν να έχουν ανάλογη σχέση. Συγκεκριμένα, συγκρίνοντας τρία
προβλήματα, το καθένα με διαφορετική πυκνότητα, στα οποία η λύση βρίσκεται στον ίδιο γύρο
(Γύρος 5), ισχύει το εξής:
td=0.9(#1) = 00.33 < td=0.95(#2) = 00.53 < td=1(#4) = 01.09
Αλλά και στην περίπτωση του Γύρου 10:
td=0.9(#17) = 04.33 < td=0.95(#10) = 05.05 < td=1(#18) = 05.27
Ωστόσο, αυτή η παρατήρηση δεν είναι απόλυτη αφού εμφανίζονται και περιπτώσεις με την
αντίστροφη σχέση.
5.5 Εκτέλεση του BKZ 2.0
Η τελευταία έκδοση του αλγορίθμου fpLLL διαθέτει και τη δυνατότητα εκτέλεσης του αλγο-
ρίθμου BKZ 2.0, ο οποίος αποτελεί την εξελιγμένη έκδοση του αλγορίθμου BKZ και ανα-
πτύχθηκε από τους Chen και Nguyen το 2011 [5]. Η χαρακτηριστική διαφορά της νεότερης
έκδοσης έγκειται στο κλάδεμα που γίνεται κατά την εκτέλεση της υπο-ρουτίνας Enum από τον
αλγόριθμο. Συγκεκριμένα, το κλάδεμα είναι οριακό όσον αφορά την επιλογή των κλαδιών που
παραλείπονται, κάτι που δικαιολογεί και την ονομασία του ως extreme pruning. Περισσότερα
για την υλοποίηση της συγκεκριμένης υπο-ρουτίνας μπορούν να βρεθούν εδώ: [5] στην ενότη-
τα 4.
Στο παραπάνω διάγραμμα φαίνονται οι χρόνοι εκτέλεσης 30 συνολικά παραδειγμάτων με την
έκδοση 5.0.1 του fpLLL. Τα παραδείγματα εκτελέστηκαν τόσο με το γνωστό έως τώρα linear

pruning (μπλε γραμμή), όσο και με τη νέα δυνατότητα, αυτή του extreme pruning (πράσινη
γραμμή). Από το διάγραμμα, μπορεί να γίνει αισθητή η χρονική διαφορά μεταξύ των δύο
μεθόδων, όπου –σχεδόν– σε όλες τις περιπτώσεις η νέα μέθοδος είναι γρηγορότερη.
5.6 Πιθανές Βελτιώσεις
Παρακάτω υπάρχουν δύο πιθανές βελτιώσεις που θα μπορούσαν να εκτελέσουν ακόμη πιο
αποδοτικά τον αλγόριθμο, χωρίς επιβάρυνση στην ποιότητα των αποτελεσμάτων.
Η πρώτη πιθανή βελτίωση αναφέρεται στην επαναληπτική διαδικασία επιλογής μεγέθους τμήμα-
τος (blocksize) στο δεύτερο κομμάτι του αλγορίθμου. Συγκεκριμένα, η αύξηση του βήματος
κατά την επαναληπτική διαδικασία μπορεί να γίνεται αντί με τον γνωστό τρόπο κατά μία μο-
νάδα, με αύξηση ίση με 2 ή 3 μονάδες, έτσι ώστε να βρίσκεται σε πιο σύντομο χρονικό διάστημα
η λύση.
Στην δεύτερη περίπτωση βελτίωσης, δεδομένων των σύγχρονων υπολογιστικών συστημάτων,
τα οποία διαθέτουν πάνω από έναν πυρήνες, καθώς επίσης και της δυνατότητας εκτέλεσης
κάποιας διαδικασίας σε ένα σύμπλεγμα από υπολογιστικές μονάδες, γνωστό και ως grid ή
cluster computing, μπορεί να γίνει η εκτέλεση του δεύτερου βήματος παράλληλα, έτσι ώστε
να μην είναι αναγκαία η αναμονή εκτέλεσης του επόμενου βήματος πριν την ολοκλήρωση του
προηγούμενου, κατά την επαναληπτική διαδικασία όπου εναλλάσσεται το μέγεθος τμήματος
(blocksize).

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

Παράρτημα Αʹ
Εγκατάσταση βιβλιοθήκης fpLLL
Οι επίσημες οδηγίες εγκατάστασης της βιβλιοθήκης fpLLL για την εκτέλεση του βασικού
αλγορίθμου BKZ μπορούν να βρεθούν εδώ: https://fplll.github.io/fplll/index.html. Η βι-
βλιοθήκη αυτή είναι διαθέσιμη μόνον για περιβάλλοντα Linux. Παρακάτω παραθέτεται ένας
πιο αναλυτικός οδηγός στα ελληνικά για τον ίδιο σκοπό με εντολές όπως αυτές εκτελέστηκαν
στη διανομή Ubuntu 16.04.
Για την εξασφάλιση της διανομής των τελευταίων πακέτων συνιστάται πρώτα η αναβάθμιση
του συστήματος με τις παρακάτω εντολές:
sudo apt update
sudo apt upgrade
Αʹ.1 Προαπαιτούμενα
Αʹ.1.1 g++ Compiler
Το πρόγραμμα g++ compiler χρειάζεται για την μετάφραση του πηγαίου κώδικα σε εκτελέσι-
μο αρχείο (compilation). Η ελάχιστη απαιτούμενη έκδοση είναι η 4.9.3. Συνιστάται να γίνει
ένας αρχικός έλεγχος για την έκδοση που μπορεί να υπάρχει εγκατεστημένη:
g++ --version
Αν το πρόγραμμα δεν είναι εγκατεστημένο ή η έκδοσή του είναι μικρότερη από την απαιτο-
ύμενη πρέπει να γίνει εγκατάσταση του με την εκτέλεση των παρακάτω εντολών:
sudo apt install g++
47

48 Παράρτημα αʹ. Εγκατάσταση βιβλιοθήκης fpLLL
Αʹ.1.2 autotools
Τα autotools χρησιμοποιούνται για την εγκατάσταση των βιβλιοθηκών. Λόγω του γεγονότος
ότι στο πλαίσιο εγκατάστασης σε περιβάλλοντα Linux, η εγκατάσταση αποτελεί την αντι-
γραφή διάφορων αρχείων σε συγκεκριμένες τοποθεσίες, το πρόγραμμα αυτό επιτελεί αυτή τη
διαδικασία. Η ελάχιστη απαιτούμενη έκδοση είναι η 2.61. Συνιστάται να γίνει ένας αρχικός
έλεγχος για την έκδοση που μπορεί να υπάρχει εγκατεστημένη:
autoconf --version
Αν το πρόγραμμα δεν είναι εγκατεστημένο ή η έκδοσή του είναι μικρότερη από την απαιτο-
ύμενη πρέπει να γίνει εγκατάσταση του με την εκτέλεση των παρακάτω εντολών:
sudo apt install autoconf
Αʹ.1.3 git
Το git είναι ένα σύστημα ελέγχου εκδόσεων με έμφαση στην ταχύτητα, στην ακεραιότητα των
δεδομένων και στην υποστήριξη για κατανεμημένες μη γραμμικές ροές εργασίας 1. Ελάχιστη
απαιτούμενη έκδοση δεν υπάρχει. Συνιστάται να γίνει ένας αρχικός έλεγχος για την έκδοση
που μπορεί να υπάρχει εγκατεστημένη:
git --version
Αν το πρόγραμμα δεν είναι εγκατεστημένο πρέπει να γίνει εγκατάσταση του με την εκτέλεση
των παρακάτω εντολών:
sudo apt install git
Αʹ.1.4 Βιβλιοθήκη GNU MP
Η βιβλιοθήκη GNU MP αποτελεί μία ελεύθερης διανομής βιβλιοθήκη για αριθμούς απερι-
όριστης ακρίβειας, διαχείριση προσημασμένων ακεραίων, ρητών αριθμών και αριθμών κινητής
υποδιαστολής. Ο μοναδικός περιορισμός ακρίβειας υπόκειται στην μνήμη του συστήματος που
χρησιμοποιεί την βιβλιοθήκη. Επιπλέον, παρέχει μεγάλο πλήθος συναρτήσεων με τις συνήθεις
διεπαφές2. Η ελάχιστη απαιτούμενη έκδοση είναι η 4.2.0. Για την εγκατάσταση της βιβλιο-
θήκης πρέπει να εκτελεστούν οι παρακάτω εντολές:
wget https://gmplib.org/download/gmp/gmp-6.1.1.tar.bz2
1
https://en.wikipedia.org/wiki/Git
2
https://gmplib.org/

αʹ.1 Προαπαιτούμενα 49
tar -cvfj gmp-6.1.1.tar.bz2
cd gmp-6.1.1
./configure
make check
make
make install
Αʹ.1.5 Βιβλιοθήκη MPFR
Η βιβλιοθήκη MPFR αποτελεί μία βιβλιοθήκη της γλώσσας C για υπολογισμό πολλαπλής
ακρίβειας αριθμών κινητής υποδιαστολής με τη σωστή στρογγυλοποίηση. Η βιβλιοθήκη υπο-
στηρίζεται συνεχώς από το ινστιτούτο INRIA και οι σύγχρονοι κύριοι κατασκευαστές προ-
έρχονται από τις ομάδες Caramba και AriC των πανεπιστημίων Loria και LIP αντιστοίχως.
Η βιβλιοθήκη βασίζεται στην GMP, που περιγράφηκε παραπάνω 3. Η ελάχιστη απαιτούμενη
έκδοση είναι η 2.3.0. Για την εγκατάσταση της βιβλιοθήκης πρέπει να εκτελεστούν οι παρα-
κάτω εντολές:
wget http://www.mpfr.org/mpfr-current/mpfr-3.1.5.tar.gz
tar -xvf mpfr-3.1.5.tar.gz
cd mpfr-3.1.5
wget http://www.mpfr.org/mpfr-3.1.5/allpatches
patch -N -Z -p1 < allpatches
./configure
make check
make
make install
Αʹ.1.6 Βιβλιοθήκη QD (προαιρετικά)
Η βιβλιοθήκη QD αποτελεί μία βιβλιοθήκη για την υποστήριξη τόσο τύπων δεδομένων διπλής
ακρίβειας (double–double), όσο και τύπων δεδομένων τετραπλής ακρίβειας (quad – double).
Η υπολογιστική βιβλιοθήκη είναι γραμμένη σε C++. Η βιβλιοθήκη υποστηρίζει υψηλού επι-
πέδου διεπαφές ώστε να μπορεί να ενσωματωθεί εύκολα σε ήδη ανεπτυγμένες εφαρμογές. 4.
Η ελάχιστη απαιτούμενη έκδοση είναι η 2.3.15. Για την εγκατάσταση της βιβλιοθήκης πρέπει
να εκτελεστούν οι παρακάτω εντολές:
wget http://crd.lbl.gov/ dhbailey/mpdist/qd-2.3.17.tar.gz
tar -xvf qd-2.3.17.tar.gz
3
http://www.mpfr.org/
4
http://crd-legacy.lbl.gov/∼dhbailey/mpdist/

50 Παράρτημα αʹ. Εγκατάσταση βιβλιοθήκης fpLLL
cd qd-2.3.17
./configure --enable-shared=yes
make check
make
make install
Αʹ.2 Βιβλιοθήκη fpLLL
Η βιβλιοθήκη fpLLL [35] περιγράφηκε στην ενότητα 5.2, αφού αποτελεί τη βάση του αλγο-
ρίθμου που αναπτύχθηκε στο πλαίσιο της εργασίας.
Η πρόσφατη έκδοση που είχε δημοσιευθεί κατά την εκπόνηση της εργασίας ήταν η 5.0.2. Η
εργασία αναπτύχθηκε με την έκδοση 4.1.1. Για την εγκατάσταση της βιβλιοθήκης πρέπει να
εκτελεστούν οι παρακάτω εντολές:
git clone https://github.com/fplll/fplll.git
cd fplll
./autogen.sh
./configure
make check
make
make install --prefix /usr/local
Αʹ.3 Πιθανά Σφάλματα
Στην περίπτωση όπου υπάρχει κάποιο άλλο πιθανό σφάλμα μπορεί να γίνει αναφορά αυτού
στους συνδέσμους από τους αντίστοιχους ιστοτόπους: Github 5 και Google Group 6
Αʹ.4 Εκτέλεση Παραδειγμάτων
Αρχικά, για την μετάφραση του πηγαίου κώδικα σε εκτελέσιμο αρχείο
g++ -std=c++11 -O3 -march=native main.cpp -o bkz -lfplll -lgmp -lmpfr -lqd
και στη συνέχεια για την εκτέλεση του αρχείου
./bkz
5
https://github.com/fplll/fplll/issues
6
https://groups.google.com/forum/#!forum/fplll-devel

αʹ.5 Ενσωμάτωση σε Ολοκληρωμένο Περιβάλλον Ανάπτυξης (IDE) 51
Αʹ.5 Ενσωμάτωση σε Ολοκληρωμένο Περιβάλλον Ανάπτυ-
ξης (IDE)
Παραθέτεται ο τρόπος ανάπτυξης στο Ολοκληρωμένο Περιβάλλον Ανάπτυξης (Integrated
Development Environment) CLion της JetBrains, το οποίο διατίθεται δωρεάν για λήψη, ενώ
οι κάτοχοι ακαδημαϊκών ιδρυματικών λογαριασμών, μπορούν να αποκτήσουν και την σχετική
άδεια χρήσης7. Κατά αναλογία μπορεί να γίνει ανάπτυξη και σε άλλα προγράμματα τέτοιου
τύπου.
1 #include <stdio.h>
2 #include <fplll.h>
3
4 using namespace fplll;
5
6 int main(int argc , const char* argv [])
7 {
8 // this is a simple fplll example
9 Integer z;
10 z = 0;
11 z.print ();
12
13 return EXIT_SUCCESS ;
14 }
Listing A.1: simpleExample
1 cmake_minimum_required (VERSION 3.5)
2 project(project1)
3 set( PROJECT_LINK_LIBS libfplll.so libgmp.so libmpfr.so libqd.so)
4 link_directories (/ usr/local/lib/)
5 include_directories (/usr/local/include /)
6 add_executable (project1 main.cpp)
7 target_link_libraries (project1 ${ PROJECT_LINK_LIBS })
8 set( CMAKE_CXX_FLAGS "${ CMAKE_CXX_FLAGS } -std=c++11 -lgmp -lfplll -lqd -lmpfr")
Listing A.2: cmakeCode
7
https://www.jetbrains.com/student/

Παράρτημα Βʹ
Σημειογραφία
Rm χώρος πραγματικών διανυσμάτων διάστασης m
Zm χώρος ακέραιων διανυσμάτων διάστασης m
B μητρώο βάσης πλέγματος L
xi διάνυσμα βάσης πλέγματος L
b διάνυσμα μητρώου βάσης πλέγματος L
li θετικοί ακέραιοι (βάρη) πλέγματος L
x, δ, αριθμητικές τιμές
λi(L) i–οστό διαδοχικό ελάχιστον πλέγματος L
det(L) ορίζουσα πλέγματος L
vol(L) όγκος πλέγματος L
P προβολή πλέγματος L
γn σταθερά Hermite
O(·) big O notation
b∗
διάνυσμα Gram–Schmidt ορθογωνιοποίησης
µi,j συντελεστής Gram–Schmidt ορθογωνιοποίησης
| · | ευκλείδεια νόρμα (νόρμα δευτέρου βαθμού ή μέτρο διανύσματος)
· στρογγυλοποίηση στον κοντινότερο ακέραιο
·, · εσωτερικό γινόμενο
53

Bibliography
[1] A. Becker, J.S. Coron, A. Joux, Improved generic algorithms for hard knapsacks, Proc.
Eurocrypt 2011, LNCS 6632, Springer, pp. 364-385, 2010
[2] Murray R. Bremner, Lattices Basis Reduction, Taylor and Francis Group, LLC, Delhi,
India, 2012
[3] E.F. Brickell, Breaking iterated knapsacks, CRYPTO 1984, LNCS 196, Springer, pp.
342-358, 1985
[4] R. Bose, S. Chowla, Theorems in the additive theory of numbers, Comment. Math.
Helv., 37, pp. 141-147, 1983
[5] Y. Chen, P.Q. Nguyen, BKZ 2.0: Better lattice security estimates, Advances in Cryp-
tology ASIACRYPT 2011, pp. 1-20, 2011
[6] B. Chor, R. L. Rivest, A Knapsack Type Public Key Cryptosystem Based On Arith-
metic in Finite Fields, Proceedings of CRYPTO, 84, pp. 54-65, 1985
[7] M.J. Coster, A. Joux, B.A. LaMacchia, A.M. Odlyzko, C.P. Schnorr, J.Stern, An
improved low density subset sum algorithm, Computational Complexity, 2, pp. 11-
128, 1992
[8] Abhijit Das, C. E. Veni Madhavan, Public Key Cryptography Theory and Practice,
Pearson Education, Saskatoon, Canada, 2009
[9] W. Diﬃe, M. Hellman, New directions in cryptography, 1983
[10] Steven D. Galbraith, Mathematics of Public Key Cryptography, Cambridge University
Press, New York, US, 2012
[11] N. Howgrave-Graham, A. Joux, New generic algorithms for hard knapsacks, Proc.
Eurocrypt 2010, Springer, LNCS 6110, pp. 235-256, 2010.
[12] T. Izu, J. Kogure, J.Koshiba, T. Shimoyama, Low-density attack revisited, Des.
Codes Cryptogr., 43(1), pp. 47–59, 2007
[13] R. Kannan, Improved algorithms for integer programming and related lattice prob-
lems, in Proc. ACM Symp. Theo. Comp., Boston, MA, pp. 193–206, 1983.
55

56 Bibliography
[14] A. Kate, I. Goldberg, Generalizing cryptosystems based on the subset sum problem,
Int. J. Inf. Secur., Springer, 10, pp. 189-199, 2011
[15] A. Korkine, G. Zolotarev, Sur les formes qudratiques, Math. Ann., 6, pp. 366-389,
1873
[16] J.C. Lagarias, Knapsack-type public key cryptosystems and Diophantine approxima-
tion, Advances in Cryptology, Proceedings of CRYPTO, 83, pp. 3-24, 1984
[17] J.C. Lagarias, A. M. Odlyzko, Solving low-density subset sum problems, J. Assoc.
Comp. Mach., 32(1), pp. 229-246, 1985
[18] H.W. Lenstra Jr., A. K. Lenstra, L. Lov`asz, Factoring Polynomials with rational
coeﬃcients, Mathematische Annalen, 261, pp. 515-534, 1982
[19] R. C. Merkle, M. E. Hellman, Hiding Information and Signatures in Trapdoor Knap-
sacks, IEEE Transactions on Information Theory, 24, pp. 525-530, 1978
[20] P. Q. Nguyen, J. Stern, Adapting Density Attacks to Low-Weight Knapsacks, Ad-
vances in Cryptology - ASIACRYPT 2005, 3788, pp. 41-58, 2005
[21] P. Q. Nguyen, B. Vallee, The LLL Algorithm: Survey and Applications, Berlin,
Germany: Springer-Verlag, 2009.
[22] H. Niederreiter, Knapsack-type cryptosystems and algebraic coding theory, Probl.
Control Inf. Theory, 15, pp. 159-166, 1986
[23] A. M. Odlyzko, The Rise and Fall of Knapsack Cryptosystems, Cryptology and Com-
putational Number Theory, A.M.S, pp. 75-88, 1990
[24] T. Okamoto, K. Tanaka, S. Uchiyama, Quantum Public-Key Cryptosystems, Ad-
vances in Cryptology - CRYPTO 2000, 1880, pp. 147-165, 2000
[25] M. Pohst, On the computation of lattice vectors of minimal length, successive minima
and reduced bases with applications. SIGSAM Bull., 15(1), pp. 37-44. 1981.
[26] C.P. Schnorr, A hierarchy of polynomial time lattice basis reduction algorithms,
Theoret. Comput. Sci., 53, pp. 201-224, 1987
[27] C.P. Schnorr, M. Euchner, Lattice basis reduction: Improved algorithms and solving
subset sum problems, Proc. of Fundamentals of Computation Theory, FCT’91, LNCS,
Springer, 529, pp. 68-85, 1991
[28] C.P. Schnorr, H. H. Horner, Attacking the Chor-Rivest cryptosystem by improved
lattice reduction, Proc. of Eurocrypt ’95, LNCS 921, Springer, 1995
[29] C. P. Schnorr, T. Shevchenko, Solving Subset Sum Problems of Density close to 1 by
”randomized” BKZ-reduction, Cryptology ePrint Archive, Report 2012/620, , 2012

Bibliography 57
[30] R. Schroeppel, A. Shamir, A T = O(2n/2), S = O(2n/4) algorithm for certain NP-
complete problems, SIAM J. Compu., 10(3), pp. 456-464, 1981
[31] A. Shamir, A polynomial time algorithm for breaking Merkle-Hellman cryptosystems,
IEEE Trans. Inform. Theory, IT-22, pp. 644–654, 1976
[32] P. W. Shor, Polynomial-Time Algorithms for Prime Factorization and Discrete Log-
arithms on a Quantum Computer, SIAM J.Sci.Statist.Comput., 26, pp. 1484-1509,
1997
[33] S. Vaudenay, Cryptanalysis of the chor-rivest cryptosystem, Advances in Cryptology,
CRYPTO, pp. 243-256, 1998
[34] W. Zhang, S. Qiao, Y. Wei, Practical HKZ and Minkowski Lattice Reduction Algo-
rithms, IEEE Trans. Signal Process. 60, pp. 5963-5976, 2011
[35] fplll, a lattice reduction library, The FPLLL development team,
https://github.com/fplll/fplll, Available at https://github.com/fplll/fplll,
version 4.1.1, 2016
[36] SageMath, The Sage Mathematics Software System (Version 7.3),
http://www.sagemath.org
[37] ntl, A Library for doing Number Theory, V. Shoup

Απόδοση ξενόγλωσσων όρων
Απόδοση Ξενόγλωσσος όρος
ακέραιο integer
αναγωγή reduction
βαθμίδα rank
βάση basis
γραμμικός linear
διαδοχικά ελάχιστα successive minima
διακριτό discrete
διάσταση dimension
ισορροπημένος balanced
κλάδεμα pruning
μέγεθος τμήματος blocksize
μη ισορροπημένος unbalanced
μητρώο matrix
οριακός extreme
ορίζουσα determinant
παραγωγή span
πλέγμα lattice
πυκνότητα density
σακίδιο knapsack
υποπλέγμα sublattice
υποσύνολο subgroup
59

algorithmiki-epilusi-duskolon

More Related Content

Similar to algorithmiki-epilusi-duskolon (20)

algorithmiki-epilusi-duskolon