Κεφάλαιο 3 Firewall 3.1 Εισαγωγή
4.13 Φόρμα Ελέγχου MailServer Contol Panel
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 142
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 143 1812. TEdit *Edit1;
1813. TLabel *Label1;
1814. TMainMenu *MainMenu1;
1815. TMenuItem *Online1;
1816. TMenuItem *Offline1;
1817. void __fastcall FormCreate(TObject *Sender);
1818. void __fastcall Online1Click(TObject *Sender);
1819. void __fastcall Offline1Click(TObject *Sender);
1820. private: // User declarations 1821. public: // User declarations
1822. __fastcall TForm14(TComponent* Owner);
1823. bool offline;
1824. bool online;
1825. };
1826. //--- 1827. extern PACKAGE TForm14 *Form14;
1828. //--- 1829. #endif
Mailservercp.cpp
1830. //---
1831. #include <vcl.h>
1832. #pragma hdrstop
1833. #include "mailservercp.h"
1834. #include "mail.h"
1835. USEFORM("mail.cpp",Form12);
1836. //--- 1837. #pragma package(smart_init)
1838. #pragma resource "*.dfm"
1839. TForm14 *Form14;
1840. //--- 1841. __fastcall TForm14::TForm14(TComponent* Owner) 1842. : TForm(Owner)
1843. {
1844. offline = false;
1845. online = false;
1846. }
1847. //--- 1848. void __fastcall TForm14::FormCreate(TObject *Sender) 1849. {
1850. Edit1->Text = Form12->EmailsTable->RecordCount;
1851. }
1852. //--- 1853. void __fastcall TForm14::Online1Click(TObject *Sender) 1854. {
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 144 1855. online = true;
1856. offline = false;
1857. }
1858. //--- 1859. void __fastcall TForm14::Offline1Click(TObject *Sender) 1860. {
1861. offline = true;
1862. online = false;
1863. }
1864. //---
4.14 Κρυπτογράφηση
{21}Σε μια εφαρμογή με σκοπό τη μεγιστοποίηση της ασφάλειας των δικτύων δεν θα μπορούσε να λείπει η κρυπτογράφηση. Έχουμε χρησιμοποιήσει έναν αλγόριθμο κρυπτογράφησης για να προστατεύσουμε τους κωδικούς των χρηστών του δικτύου.
Η κρυπτογραφία είναι ένας κλάδος της επιστήμης της κρυπτολογίας, η οποία ασχολείται με την μελέτη της ασφαλούς επικοινωνίας. Ο κύριος στόχος της είναι να παρέχει μηχανισμούς για 2 ή περισσότερα μέλη να επικοινωνήσουν χωρίς κάποιος άλλος να είναι ικανός να διαβάζει την πληροφορία εκτός από τα μέλη.
Η κρυπτογράφηση αποτελεί εφαρμογή της κρυπτογραφίας. Κρυπτογράφηση είναι ο μετασχηματισμός δεδομένων σε μορφή που να είναι αδύνατον να διαβαστεί χωρίς την γνώση της σωστής ακολουθίας bit. Η ακολουθία bit καλείται "κλειδί" και χρησιμοποιείται σε συνδυασμό με κατάλληλο αλγόριθμο ή συνάρτηση. Η αντίστροφη διαδικασία είναι η αποκρυπτογράφηση και απαιτεί γνώση του κλειδιού. Σκοπός της κρυπτογράφησης είναι να εξασφαλίσει το απόρρητο των δεδομένων κρατώντας τα κρυφά από όλους όσους έχουν πρόσβαση σε αυτά. Η κρυπτογράφηση και η αποκρυπτογράφηση απαιτούν, την χρήση κάποιας μυστικής πληροφορίας, το κλειδί. Για μερικούς μηχανισμούς χρησιμοποιείται το ίδιο κλειδί και για την κρυπτογράφηση και για την αποκρυπτογράφηση, για άλλους όμως τα κλειδιά που χρησιμοποιούνται διαφέρουν.
Υπολογίζεται ότι η πιθανότητα να έχουν δύο μηνύματα την ίδια σύνοψη είναι μετά από 264 περιπτώσεις και ότι η πιθανότητα να έχει ένα οποιοδήποτε μήνυμα μια δεδομένη σύνοψη μηνύματος είναι είναι μετά από 2128 περιπτώσεις.
Κρυπτογράφηση (encryption) ονομάζεται η διαδικασία μετασχηματισμού ενός μηνύματος σε μία ακατανόητη μορφή με την χρήση κάποιου κρυπτογραφικού αλγορίθμου ούτως ώστε να μην μπορεί
21http://en.wikipedia.org/wiki/Cryptography
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 145 να διαβαστεί από κανέναν εκτός του νόμιμου παραλήπτη. {22}
Η αντίστροφη διαδικασία όπου από το κρυπτογραφημένο κείμενο παράγεται το αρχικό μήνυμα ονομάζεται αποκρυπτογράφηση (decryption).
Κρυπτογραφικός αλγόριθμος (cipher) είναι η μέθοδος μετασχηματισμού δεδομένων σε μία μορφή που να μην επιτρέπει την αποκάλυψη των περιεχομένων τους από μη εξουσιοδοτημένα μέρη. Κατά κανόνα ο κρυπτογραφικός αλγόριθμος είναι μία πολύπλοκη μαθηματική συνάρτηση.
Αρχικό κείμενο (plaintext) είναι το μήνυμα το οποίο αποτελεί την είσοδο σε μία διεργασία κρυπτογράφησης.
Κλειδί (key) είναι ένας αριθμός αρκετών bit που χρησιμοποιείται ως είσοδος στην συνάρτηση κρυπτογράφησης.
Κρυπτογραφημένο κείμενο (ciphertext) είναι το αποτέλεσμα της εφαρμογής ενός κρυπτογραφικού αλγόριθμου πάνω στο αρχικό κείμενο.
Η κρυπτογραφική συνάρτηση κατατεμαχισμού (cryptographic hash function) είναι μια συνάρτηση που είναι σχεδιασμένη για να χρησιμοποιείται στην κρυπτογραφία.
Είναι μια μαθηματική συνάρτηση που έχοντας ως είσοδο μια αυθαίρετου μεγέθους ομάδα δεδομένων δίνει έξοδο μια καθορισμένου μεγέθους στοιχειοσειρά (string) (η συμβολοσειρά είναι συνήθως μικρότερη σε μέγεθος από την αρχική είσοδο). Η έξοδος δεν μπορεί με αντιστροφή (με κανένα τρόπο) να μας παράγει την αρχική είσοδο. Η έξοδος αποκαλείται συνήθως "σύνοψη" (digest). Διάσημη συνάρτηση κατατεμαχισμού είναι η MD5 η οποία χρησιμοποιήθηκε στην εφαρμογή.
Σύνοψη Μηνύματος (Message Digest):
Η σύνοψη ενός μηνύματος είναι το αποτέλεσμα (έξοδος) της συνάρτησης κατατεμαχισμού. Η σύνοψη δεν έχει το ίδιο μέγεθος (είναι συνήθως μικρότερη) με το αρχικό μήνυμα – κάτι το οποίο έχει νόημα, γιατί όπως εξηγήσαμε δεν μπορούμε έτσι και αλλιώς να ξαναγυρίσουμε στο αρχικό μήνυμα. Οι αλγόριθμοι κατατεμαχισμού είναι φτιαγμένοι με τέτοιο τρόπο ώστε μια μικρή μεταβολή στα δεδομένα εισόδου (π.χ. ένα μόνο γράμμα ή ακόμα και ένα μόνο bit) να προκαλεί ολοκληρωτική αλλαγή στην έξοδο (πλήρης αλλαγή της σύνοψης).
Στην εφαρμογή έχει χρησιμοποιηθεί ο αλγόριθμος κατατεμαχισμού MD5. Πώς λειτουργεί αυτός ο αλγόριθμος;
Τα passwords που επιλέγουν οι χρήστες για τους λογαριασμούς τους δεν αποθηκεύονται ως plain text, δηλαδή όπως τα πληκτρολογούν οι χρήστες. Αντί αυτών, στο σύστημα αποθηκεύονται τα MD5 digests των passwords, μ’ άλλα λόγια οι συνόψεις τους ως προς τη συνάρτηση κατατεμαχισμού (hash) MD5. Έτσι, όταν ένας χρήστης επιχειρεί να συνδεθεί στο λογαριασμό του -όταν δηλαδή επιχειρεί να κάνει login-, αφού δώσει το username και μετά το password, υπολογίζεται το hash του τελευταίου και συγκρίνεται με το αποθηκευμένο. Η είσοδος επιτρέπεται μόνον
22http://www.image.ntua.gr/meleti172KTP/?q=node/23
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 146 όταν τα δύο digests ταυτίζονται -και φυσικά όταν υπάρχει στο σύστημα χρήστης με το δοσμένο username.
Οι τέσσερις κύκλοι του MD5{23}
/* Round 1. */
/* Let [abcd k s i] denote the operation a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4]
[ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8]
[ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12]
[ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]
/* Round 2. */
/* Let [abcd k s i] denote the operation a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20]
[ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24]
[ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28]
[ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32]
/* Round 3. */
/* Let [abcd k s t] denote the operation a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36]
[ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40]
[ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44]
[ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]
/* Round 4. */
/* Let [abcd k s t] denote the operation a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52]
[ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56]
[ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60]
[ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64]
/* Then perform the following additions. (That is increment each of the four registers by the value it had before this block was started.) */
23STALLINGS W., (2003), «Cryptography and Network Security: Principles and Practice».
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 147 A = A + AA
B = B + BB C = C + CC D = D + DD
end /* of loop on i */
Ο κώδικας του αλγόριθμου:
md5.h
/* MD5
converted to C++ class by Frank Thilo (thilo@unix-ag.org) for bzflag (http://www.bzflag.org)
based on:
md5.h and md5.c
reference implementation of RFC 1321
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved.
License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function.
License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this documentation and/or software.
*/
1865. #ifndef BZF_MD5_H 1866. #define BZF_MD5_H
1867. #include <string>
1868. #include <iostream>
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 148 1869. // a small class for calculating MD5 hashes of strings or byte arrays
1870. // it is not meant to be fast or secure 1871. //
1872. // usage: 1) feed it blocks of uchars with update() 1873. // 2) finalize()
1874. // 3) get hexdigest() string 1875. // or
1876. // MD5(std::string).hexdigest() 1877. //
1878. // assumes that char is 8 bit and int is 32 bit 1879. class MD5
1880. { 1881. public:
1882. typedef unsigned int size_type; // must be 32bit
1883. MD5();
1884. MD5(const std::string& text);
1885. void update(const unsigned char *buf, size_type length);
1886. void update(const char *buf, size_type length);
1887. MD5& finalize();
1888. std::string hexdigest() const;
1889. friend std::ostream& operator<<(std::ostream&, MD5 md5);
1890. private:
1891. void init();
1892. typedef unsigned char uint1; // 8bit 1893. typedef unsigned int uint4; // 32bit
1894. enum {blocksize = 64}; // VC6 won't eat a const static int here
1895. void transform(const uint1 block[blocksize]);
1896. static void decode(uint4 output[], const uint1 input[], size_type len);
1897. static void encode(uint1 output[], const uint4 input[], size_type len);
1898. bool finalized;
1899. uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk 1900. uint4 count[2]; // 64bit counter for number of bits (lo, hi)
1901. uint4 state[4]; // digest so far 1902. uint1 digest[16]; // the result
1903. // low level logic operations
1904. static inline uint4 F(uint4 x, uint4 y, uint4 z);
1905. static inline uint4 G(uint4 x, uint4 y, uint4 z);
1906. static inline uint4 H(uint4 x, uint4 y, uint4 z);
1907. static inline uint4 I(uint4 x, uint4 y, uint4 z);
1908. static inline uint4 rotate_left(uint4 x, int n);
1909. static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 149 1910. static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4
ac);
1911. static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
1912. static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
1913. };
1914. std::string md5(const std::string str);
1915. #endif
md5.cpp /* MD5
converted to C++ class by Frank Thilo (thilo@unix-ag.org) for bzflag (http://www.bzflag.org)
based on:
md5.h and md5.c
reference implemantion of RFC 1321
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved.
License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function.
License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this documentation and/or software.
1916. */
1917. /* interface header */
1918. #include "md5.h"
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 150 1919. /* system implementation headers */
1920. #include <stdio.h>
1921. // Constants for MD5Transform routine.
1922. #define S11 7 1923. #define S12 12 1924. #define S13 17 1925. #define S14 22 1926. #define S21 5 1927. #define S22 9 1928. #define S23 14 1929. #define S24 20 1930. #define S31 4 1931. #define S32 11 1932. #define S33 16 1933. #define S34 23 1934. #define S41 6 1935. #define S42 10 1936. #define S43 15 1937. #define S44 21
1938. ///////////////////////////////////////////////
1939. // F, G, H and I are basic MD5 functions.
1940. inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) { 1941. return x&y | ~x&z;
1942. }
1943. inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) { 1944. return x&z | y&~z;
1945. }
1946. inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) { 1947. return x^y^z;
1948. }
1949. inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) { 1950. return y ^ (x | ~z);
1951. }
1952. // rotate_left rotates x left n bits.
1953. inline MD5::uint4 MD5::rotate_left(uint4 x, int n) { 1954. return (x << n) | (x >> (32-n));
1955. }
1956. // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
1957. // Rotation is separate from addition to prevent recomputation.
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 151 1958. inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4
ac) {
1959. a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
1960. }
1961. inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
1962. a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
1963. }
1964. inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
1965. a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
1966. }
1967. inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
1968. a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
1969. }
1970. //////////////////////////////////////////////
1971. // default ctor, just initailize 1972. MD5::MD5()
1973. { 1974. init();
1975. }
1976. //////////////////////////////////////////////
1977. // nifty shortcut ctor, compute MD5 for string and finalize it right away 1978. MD5::MD5(const std::string &text)
1979. { 1980. init();
1981. update(text.c_str(), text.length());
1982. finalize();
1983. }
1984. //////////////////////////////
1985. void MD5::init() 1986. {
1987. finalized=false;
1988. count[0] = 0;
1989. count[1] = 0;
1990. // load magic initialization constants.
1991. state[0] = 0x67452301;
1992. state[1] = 0xefcdab89;
1993. state[2] = 0x98badcfe;
1994. state[3] = 0x10325476;
1995. }
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 152 1996. //////////////////////////////
1997. // decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
1998. void MD5::decode(uint4 output[], const uint1 input[], size_type len) 1999. {
2000. for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
2001. output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) | 2002. (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
2003. }
2004. //////////////////////////////
2005. // encodes input (uint4) into output (unsigned char). Assumes len is 2006. // a multiple of 4.
2007. void MD5::encode(uint1 output[], const uint4 input[], size_type len) 2008. {
2009. for (size_type i = 0, j = 0; j < len; i++, j += 4) { 2010. output[j] = input[i] & 0xff;
2011. output[j+1] = (input[i] >> 8) & 0xff;
2012. output[j+2] = (input[i] >> 16) & 0xff;
2013. output[j+3] = (input[i] >> 24) & 0xff;
2014. } 2015. }
2016. //////////////////////////////
2017. // apply MD5 algo on a block
2018. void MD5::transform(const uint1 block[blocksize]) 2019. {
2020. uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
2021. decode (x, block, blocksize);
2022. /* Round 1 */
2023. FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
2024. FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
2025. FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
2026. FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
2027. FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
2028. FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
2029. FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
2030. FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
2031. FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
2032. FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
2033. FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
2034. FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
2035. FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
2036. FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
2037. FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 153 2038. FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
2039. /* Round 2 */
2040. GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
2041. GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
2042. GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
2043. GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
2044. GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
2045. GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
2046. GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
2047. GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
2048. GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
2049. GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
2050. GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
2051. GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
2052. GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
2053. GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
2054. GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
2055. GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
2056. /* Round 3 */
2057. HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
2058. HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
2059. HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
2060. HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
2061. HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
2062. HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
2063. HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
2064. HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
2065. HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
2066. HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
2067. HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
2068. HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
2069. HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
2070. HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
2071. HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
2072. HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
2073. /* Round 4 */
2074. II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
2075. II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
2076. II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
2077. II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
2078. II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
2079. II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
2080. II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
2081. II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 154 2082. II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
2083. II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
2084. II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
2085. II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
2086. II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
2087. II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
2088. II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
2089. II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
2090. state[0] += a;
2091. state[1] += b;
2092. state[2] += c;
2093. state[3] += d;
2094. // Zeroize sensitive information.
2095. memset(x, 0, sizeof x);
2096. }
2097. //////////////////////////////
2098. // MD5 block update operation. Continues an MD5 message-digest 2099. // operation, processing another message block
2100. void MD5::update(const unsigned char input[], size_type length) 2101. {
2102. // compute number of bytes mod 64 2103. size_type index = count[0] / 8 % blocksize;
2104. // Update number of bits
2105. if ((count[0] += (length << 3)) < (length << 3)) 2106. count[1]++;
2107. count[1] += (length >> 29);
2108. // number of bytes we need to fill in buffer 2109. size_type firstpart = 64 - index;
2110. size_type i;
2111. // transform as many times as possible.
2112. if (length >= firstpart) 2113. {
2114. // fill buffer first, transform
2115. memcpy(&buffer[index], input, firstpart);
2116. transform(buffer);
2117. // transform chunks of blocksize (64 bytes)
2118. for (i = firstpart; i + blocksize <= length; i += blocksize) 2119. transform(&input[i]);
2120. index = 0;
2121. } 2122. else 2123. i = 0;
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 155 2124. // buffer remaining input
2125. memcpy(&buffer[index], &input[i], length-i);
2126. }
2127. //////////////////////////////
2128. // for convenience provide a verson with signed char 2129. void MD5::update(const char input[], size_type length) 2130. {
2131. update((const unsigned char*)input, length);
2132. }
2133. //////////////////////////////
2134. // MD5 finalization. Ends an MD5 message-digest operation, writing the 2135. // the message digest and zeroizing the context.
2136. MD5& MD5::finalize() 2137. {
2138. static unsigned char padding[64] = {
2139. 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2140. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2141. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
2142. };
2143. if (!finalized) {
2144. // Save number of bits 2145. unsigned char bits[8];
2146. encode(bits, count, 8);
2147. // pad out to 56 mod 64.
2148. size_type index = count[0] / 8 % 64;
2149. size_type padLen = (index < 56) ? (56 - index) : (120 - index);
2150. update(padding, padLen);
2151. // Append length (before padding) 2152. update(bits, 8);
2153. // Store state in digest 2154. encode(digest, state, 16);
2155. // Zeroize sensitive information.
2156. memset(buffer, 0, sizeof buffer);
2157. memset(count, 0, sizeof count);
2158. finalized=true;
2159. }
2160. return *this;
2161. }
2162. //////////////////////////////
2163. // return hex representation of digest as string 2164. std::string MD5::hexdigest() const
2165. {
2166. if (!finalized) 2167. return "";
2168. char buf[33];
2169. for (int i=0; i<16; i++)
2170. sprintf(buf+i*2, "%02x", digest[i]);
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 156 2171. buf[32]=0;
2172. return std::string(buf);
2173. }
2174. //////////////////////////////
2175. std::ostream& operator<<(std::ostream& out, MD5 md5) 2176. {
2177. return out << md5.hexdigest();
2178. } 2179.
2180. //////////////////////////////
2181. std::string md5(const std::string str) 2182. {
2183. MD5 md5 = MD5(str);
2184. return md5.hexdigest();
2185. }
4.14 Βάση Δεδομένων
Στην παρούσα εργασία δημιουργήθηκε μια βάση δεδομένων με το πρόγραμμα Microsoft Office Access 2010 επειδή υπήρχε η ανάγκη ενός οργανωμένου τρόπου αποθήκευσης των πληροφοριών και συνάμα η ανάγκη πρόσβασης σε αυτές τις πληροφορίες. Δημιουργήσαμε πίνακες και βάλαμε τις κατάλληλες σχέσεις μεταξύ τους, όπως φαίνεται στο παρακάτω σχήμα.
Σχήμα 4.14 : Οι πίνακες της βάσης δεδομένων.
Μπαμπέκος Χρήστος Α.Ε.Μ.:1904 Βουλγαράκη Φωτεινή Α.Ε.Μ:1912 157 Τα χειριστήρια(components) ADOConnection, ADOTable, DataSource μας βοήθησαν στη σύνδεση της βάσης με το λογισμικό μας.
157
Συμπεράσματα – Μελλοντικές Προοπτικές
Δεδομένου ότι τα αναχώματα ασφάλειας δεν αποτελούν πανάκεια και ότι μόνο το 36% των επιθέσεων ανιχνεύεται από αυτά, η σωστή ρύθμιση ενός αναχώματος και η υλοποίηση μίας ρητής πολιτικής ασφάλειας σύμφωνης με τις απαιτήσεις ενός χρήστη ή ενός οργανισμού, αποτελούν τις καλύτερες δυνατές πρακτικές για ασφαλή συστήματα. Θεωρώντας ότι τα ασφαλή συστήματα είναι στην εποχή που διανύουμε, μια εποχή υπό την κυριαρχία του Διαδικτύου – δικαίως κατά τη γνώμη μας - είναι εξόχως σημαντικά, πιστεύουμε στην σπουδαιότητα της εργασίας μας.
Με την δημιουργία της παρούσας εργασίας ευελπιστούμε να καταστήσουμε σαφές την αναγκαιότητα των αναχωμάτων ασφαλείας αλλά και την εκμάθηση της δημιουργίας τους. Παρατηρεί κανείς μέσω της εφαρμογής μας πώς «στήνεται» ένα δίκτυο και πώς γίνεται η ανάπτυξη και η διαχείριση ενός αναχώματος ασφαλείας.
Τολμούμε να προτείνουμε την χρησιμοποίηση της παρούσας εργασίας για εκπαιδευτικούς σκοπούς θεωρώντας ότι αποτελεί ένα εύχρηστο «εργαλείο» για τον κάθε χρήστη στην προσπάθεια αποκόμισης γνώσεων όσον αφορά το αντικείμενο που πραγματεύεται. Θα ήταν πραγματικά μεγάλη μας τιμή αν δεχόταν οιοσδήποτε διδάσκων να ενσωματώσει στο μάθημά του την εφαρμογή που δημιουργήσαμε.
Αξίζει να σημειωθεί πως, αναμφίβολα, όπως όλα τα δημιουργήματα επιδέχονται βελτιώσεις έτσι και το παρόν θα μπορούσε να εξελιχθεί περαιτέρω και αντί για μια εφαρμογή που παρουσιάζει εικονικά ένα δίκτυο και το ανάχωμα ασφαλείας που το προστατεύει, να καταφέρει στο μέλλον, συνδυασμένη με hardware, να αποτελέσει ένα πραγματικό «όπλο» στο τομέα της ασφάλειας των δικτύων.
158 Ελληνόγλωσση
1. Σιδερίδη, Αλέξανδρου Β. 1998, "Εισαγωγή στην επιστήμη των υπολογιστών", ISBN 960-85647-1-4
2. ΒΑΡΕΛΑΣ Χ., (2001), «Αφιέρωμα: Ασφάλεια στο Διαδίκτυο», Περιοδικό RΑΜ, Τεύχος 144.
3. Δρ. ΓΕΩΡΓΙΑΔΗΣ Χρ., «Προβλήματα Ασφάλειας στο Ηλεκτρονικό Εμπόριο», E- Επιχειρείν – Πανεπιστήμιο Θεσσαλίας
4. ΚΟΜΝΗΝΟΥ Θ., ΣΠΥΡΑΚΗ Π., «Ασφάλεια Δικτύων & Υπολογιστικών Συστημάτων».
5. ΣΟΥΡΗΣ Αν. – ΠΑΤΣΟΣ Δημ. – ΓΡΗΓΟΡΙΑΔΗΣ Ν., «Ασφάλεια της Πληροφορίας”, Εκδόσεις Νέων Τεχνολογιών.
6. Γκρίτζαλης Σ., Κάτσικας Σ., Γκρίτζαλης Δ., (2003): Ασφάλεια Δικτύων Υπολογιστών:
Τεχνολογίες και Υπηρεσίες σε Περιβάλλοντα Ηλεκτρονικού Επιχειρείν και Ηλεκτρονικής Διακυβέρνησης, Παπασωτηρίου
7. Αρχή Διασφάλισης Απορρήτου Επικοινωνιών (ΑΔΑΕ), (2006),« Κανονισμός για τη Διασφάλιση του Απορρήτου στις Διαδικτυακές Επικοινωνίες και τις Συναφείς Υπηρεσίες και Εφαρμογές».
Ξενόγλωσση
8. Tanenbaum, Andrew S. [1996] 2000, "Δίκτυα Υπολογιστών", Τρίτη Έκδοση, Πρώτη Ελληνική Έκδοση, Εκδόσεις Παπασωτηρίου, ISBN 960-7510-70-4
9. Bellovin, S.M. and W.R. Cheswick, "Firewalls and Internet Security: Repelling the Wily Hacker", Addison-Wesley, 1994.
10. Internet Security and Firewalls (Networking) - V. V. Preetham
11. John L. Hennessy & David A. Patterson «Computer Architecture: A Quantitative Approach» (2nd Edition), Morgan Kaufmann (1996)
12 . Matthew Gast "802.11 Wireless Networks: The Definitive Guide, Second Edition", ISBN: 0-596-10052-3, April 2005
13. Firewalls Complete, M. Gonclaves, McGraw-Hill, 1997
14. Building Internet Firewalls, Brent Chapman & Elizabeth D. Zwicky, O' Reilly, 1995