Biztonságos a vonal?

Vannak azok a remek filmes jelenetek, amikor főhősünk felhív valakit és megkérdezik tőle, hogy biztonságos-e a vonal. Érdekes téma lenne a vezetékes telefonvonalak lehallgatása is, vagy hogy ebben az esetben mit jelenthet az, hogy biztonságos-e a kapcsolat. De mi azért maradunk a digitális világban.

Azon belül is a rengeteg eszköz egyikét, a TLS-t, vagy korábbi nevén az SSL-t fogjuk kicsit közelebbről megvizsgálni. De még mielőtt rátérhetnénk a TLS által nyújtott titkosított csatornák szépségeire, ejtenünk kell pár szót a tanúsítványokról.

Digitális tanúsítványok

Természetesen ezt is, mint minden más kriptográfiával kapcsolatos dolgot a fekete mágia működteti. Vagy a matematika, kinek hogy tetszik.

A tanúsítvány nem több, mint egy publikus kulcs, némi metaadat és egy aláírás egy remélhetőleg megbízható harmadik személytől (Certificate authority, vagy röviden CA), aki ezzel igazolja, hogy a publikus kulcs és a metaadat összetartozik.

Ez a megbízható harmadik fél például lehet egy szervezet (pl. Let's Encrypt), aki domain-ekhez állít ki tanúsítványokat, miután leellenőrzi, hogy tényleg hozzád tartozik-e, vagy akár a munkáltatód, aki a VPN szerverhez osztogat tanúsítványokat.

Amit még érdemes tudni, hogy ezeket a tanúsítványokat egymás után lehet fűzni és ha valamelyikben megbízol, akkor az összes alatta lévő által kiadott tanúsítványban is megbízol.

A www.google.com tanúsítvány-lánca.

Generáljunk kulcsokat

Mivel nem tartozom azon beavatottak közé, akik képesek az openssl parancs misztikus varázsigéit elkántálni, ezért egy easy-rsa nevű eszközt fogunk használni, ami nagyban megkönnyíti a dolgunkat.

Először is szerezzük be az eszközt:

$ git clone https://github.com/OpenVPN/easy-rsa.git
$ cd easy-rsa/easyrsa3/

Inicializáljunk egy új PKI-t (Public key infrastructure). Ez esetünkben csak létrehoz egy könyvtárstruktúrát a pki/ könyvtár alá, amit az easy-rsa használ a továbbiakban.

$ ./easyrsa init-pki

Generáljunk egy CA-t, egy szerver- és egy kliens tanúsítványt. Természetesen jelszó nélkül, hogy később könnyebb dolgunk legyen (valós használatra viszont ez kevésbé egészséges).

$ ./easyrsa build-ca nopass
$ ./easyrsa build-server-full server nopass
$ ./easyrsa build-client-full client nopass

Ha minden jól ment, lett hat darab fájlunk, amit a későbbi scriptekben fel fogunk használni. A .crt végűek megoszthatóak a világgal, a .key végűeket pedig inkább tartsuk csak meg magunknak.

pki/ca.crt
pki/issued/client.crt
pki/issued/server.crt
pki/private/ca.key
pki/private/client.key
pki/private/server.key

A jó öreg titkosítatlan szöveg

A példákban egy-egy socket klienst és szervert fogunk megvalósítani. Mielőtt azonban belevágnánk fejszénket a titkosítás fájába, nézzük meg hogyan is néz ki egy titkosítás nélkül:

plain_text_client.py
import socket

target = ('127.0.0.1', 12321)
data = b'Hello, world'

with socket.create_connection(target) as sock:
    sock.sendall(data)
    print('Sent', repr(data))
    data = sock.recv(1024)
    print('Received', repr(data))
plain_text_server.py
import socket

target = ('127.0.0.1', 12321)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
    sock.bind(target)
    sock.listen(5)
    while True:
        conn, addr = sock.accept()
        data = conn.recv(1024)
        conn.sendall(b'ECHO ' + data)
        conn.close()

A tcpdump parancs segítségével meg is tudjuk nézni, hogy a kommunikáció tényleg nincs titkosítva.

# tcpdump -i lo port 12321 -w plain_text.pcap

Az egészet lementhetjük egy pcap fájlba, amit aztán pl. Wireshark segítségével emészthetőbb formában is megnézhetünk.

A küldött adat szépen látható a hálózati forgalomban.

Én csak titkosítok, nem érdekel más

Még mielőtt belemennénk a következő példába, itt szeretném felhívni a figyelmet, hogy ez továbbra sem olyan kód, amit a való világban érdemes használni, mindjárt arra is kitérünk, hogy miért.

encrypt_client.py
import socket
import ssl

target = ('127.0.0.1', 12321)
data = b'Hello, world'

context = ssl.SSLContext(ssl.PROTOCOL_TLS)

with socket.create_connection(target) as sock:
    with context.wrap_socket(sock) as tls_sock:
        tls_sock.sendall(data)
        print('Sent', repr(data))
        data = tls_sock.recv(1024)
        print('Received', repr(data))
encrypt_server.py
import socket
import ssl

target = ('127.0.0.1', 12321)

context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain('pki/issued/server.crt', 'pki/private/server.key')

with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
    sock.bind(target)
    sock.listen(5)
    with context.wrap_socket(sock, server_side=True) as tls_sock:
        while True:
            conn, addr = tls_sock.accept()
            data = conn.recv(1024)
            conn.sendall(b'ECHO ' + data)
            conn.close()

A tcpdump-ot és a Wireshark-ot segítségül hívva ismét megnézhetjük a forgalmat, történt-e valami változás.

Nincs itt semmi látnivaló.

A részletes elemzés házi feladat, de az jól látszik, hogy sokkal több csomag utazott a TLS miatt. Valamint az sem mellékes, hogy nem értünk az adatból egy szót se. Mi akkor a probléma?

Igazából nem érdekel minket, hogy kivel beszélünk. Bárki lehet a vonal másik végén, amíg titkosítottan próbál velünk kommunikálni. Így ha valaki a kliens és a szerver közé tud állni, a kliensnek nem fog feltűnni, hogy megváltozott a tanúsítvány.

Python esetén érdemes átfutni az ssl modul Security considerations részét, mielőtt élesben is használjuk ezeket a dolgokat.

Legyünk biztosak abban, hogy kivel beszélünk

Biztosabbak lehetünk a dolgunkban, ha megköveteljük a szervertől, hogy a tanúsítványát valamilyen általunk megbízhatónak ítélt CA írja alá. Ehhez a kliensünk context-jén a következőket kell beállítani:

context.verify_mode = ssl.CERT_REQUIRED
context.load_verify_locations('pki/ca.crt')

A CA-tól függően ez akár elég is lehet, de ha egy olyan CA-ról beszélünk, akitől bárki tud tanúsítványt igényelni, akkor ugyanott vagyunk, mint az előző pontban. A kliens context-jébe viszont bekapcsolhatunk még egy validációt:

context.check_hostname = True

Ehhez viszont az is kell, hogy a kliens socket becsomagolásakor megmondjuk, hogy szerintünk kivel fogunk beszélgetni:

context.wrap_socket(sock, server_hostname='server')

Ez a server string nem mellesleg ugyanaz a server, mint amit a ./easyrsa build-server-full server nopass parancsban adtunk meg és szerepel a tanúsítvány metaadatai között.

Amikor a másik félnek is bizonyíték kell, nem ígéret

A kliens már biztos lehet a szerver kilétében, de szerverünk még bárkivel leáll beszélgetni. Ezt orvosolhatjuk azzal, hogy a szerver is követeljen meg a klienstől tanúsítványt.

A szintek itt is hasonlóan alakulnak, mint a kliensnél és hasonló következményekkel is járnak, úgyhogy ugorjunk is rögtön arra a változatra, ahol csak egy bizonyos CA által kiállított tanúsítványt fogadunk el egy megfelelő nevű klienstől (ami így remekül használható autentikációra is).

client_cert_client.py
import socket
import ssl

target = ('127.0.0.1', 12321)
data = b'Hello, world'

context = ssl.SSLContext(ssl.PROTOCOL_TLS)
context.verify_mode = ssl.CERT_REQUIRED
context.check_hostname = True
context.load_verify_locations('pki/ca.crt')
context.load_cert_chain('pki/issued/client.crt', 'pki/private/client.key')

with socket.create_connection(target) as sock:
    with context.wrap_socket(sock, server_hostname='server') as tls_sock:
        tls_sock.sendall(data)
        print('Sent', repr(data))
        data = tls_sock.recv(1024)
        print('Received', repr(data))
client_cert_server.py
import socket
import ssl

target = ('127.0.0.1', 12321)

context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.verify_mode = ssl.CERT_REQUIRED
context.load_verify_locations('pki/ca.crt')
context.load_cert_chain('pki/issued/server.crt', 'pki/private/server.key')

with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
    sock.bind(target)
    sock.listen(5)
    with context.wrap_socket(sock, server_side=True) as tls_sock:
        while True:
            conn, addr = tls_sock.accept()
            try:
                ssl.match_hostname(conn.getpeercert(), 'client')
            except:
                conn.close()
                continue
            data = conn.recv(1024)
            conn.sendall(b'ECHO ' + data)
            conn.close()

Bár ad rá a modul segédfüggvényt (ssl.match_hostname()), de a validációt itt már nekünk kell kézzel megcsinálnunk. A hívásban lévő client string itt is ugyanaz, mint az ./easyrsa build-client-full client nopass parancsban megadott client.

Végezetül csak annyit, hogy ha valami titkosított, az még nem feltétlenül jelenti azt, hogy biztonságos is. A kriptográfiára jellemző, hogy rengeteg helyen félrecsúszhatnak a dolgok (nem biztonságos beállítások, elavult verziók használata) és mi itt csak a felszínt kapargattuk meg egy kicsit.

Ha érdekelnek a részletek

Mást se szeretnél jobban, mint azonnal értesülni a friss tartalmakról? A legjobb helyen jársz! Feliratkozhatsz az oldal RSS feed-jére vagy követheted a blogot Twitteren.