To trzeci post dotyczący małego pakietu PKI GPG i wersji Gnu4Win. Opiszę tutaj tematy związane z certyfikatami klucza publicznego oraz niewielki program do ich obsługi a mianowicie Kleopatra z pakietu Gnu4Win.

Program zawarty jest w pakiecie Gnu4Win i służy do tworzenia i obsługi  certyfikatów klucza publicznego PGP, generowania żądań certyfikatu X.509 i ich obsługi. Jak można zauważyć na poniższej ilustracji jeśli w systemie stworzymy (za pomocą GPA) parę kluczy prywatny-publiczny automatycznie tworzony jest odpowiadający certyfikat PGP, który można zobaczyć z programie Kleopatra.

Przejrzyjmy zatem możliwości Kleopatry, ruszamy więc z pustym kontem gdzie nie posiadamy ani pary kluczy ani żadnego certyfikatu. Zakładka My Certificates przechowuje moje prywatne certyfikaty, Trusted Certificates certyfikaty przeze mnie zaufane, Other inne certyfikaty a Imported to certyfikaty zaimportowane z pliku czy serwera certyfikatów.

Menu File pozwala na:
– tworzenie nowego certyfikatu osobistego
– poszukiwanie i import certyfikatu z serwerów publicznych
– eksport certyfikatów do pliku, serwera oraz eksport klucza prywatnego
– szyfrowanie, podpisywanie i odwrotne operacje
– obsługę sum kontrolnych

Spróbujemy teraz utworzyć nowy certyfikat osobisty (mamy otwarte dwa programy Kleopatrę i GPA aby widzieć co się będzie działo). Klikamy w File / New Certificate i pojawia sie okno tworzenia certyfikatu. Mamy tu do wyboru tworzenie certyfikatu PGP lub żądania certyfikatu X.509. Na początek zajmiemy się certyfikatami PGP.

Tworzenie certyfikatu OpenPGP

Menu File / New Certificate, klikamy w pierwszą opcję Create a personal OpenPGP key pair:

Kolejne okno wypełniamy zgodnie z potrzebami:

Jeśli chcemy konfigurować dodatkowe ustawienie certyfikatu można kliknąć w Advanced settings:

W tym oknie można wybrać rodzaj algorytmu (domyślnie możemy zostawić RSA z kluczem o długości 2048 bitów), oraz zastosowania samego certyfikatu:
– Signing dla operacji podpisu elektronicznego
– Encryption dla szyfrowania danych
– Certification dla certyfikacji np innych certyfikatów
– Authentication dla operacji uwierzytelniania
– Valid until to data ważności certyfikatu po przekroczeniu której staje się on bezużyteczny (jak i klucze z nim związane)

Ponieważ często używa się różnych certyfikatów dla różnych celów (np. inny dla podpisu a inny dla szyfrowania) dla tego mamy tu możliwośc wygenerowania ich większej ilości z różnym przeznaczeniem. To przeznaczenie certyfikatów może być wymagane w zależności od firm, systemów czy osób z jakimi będziemy prowadzić komunikację przy uzyciu naszych certyfikatów. Rozdział ról certyfikatów może być zależy od przyjętej polityki bezpieczeństwa i może wymagać innego certyfikatu do podpisu a innego do szyfrowania a jeszcze innego do uwierzytelniania. Przykładowo certyfikat dla uwierzytelniania może być związany z kartą SmartCard, certyfikat dla szyfrowania może być związany z programem GPA a operację podpisu mogą używać jeszcze innej metody z którą będzie związany certyfikat podpisujący. Zatwierdzamy więc wartości domyślne i kontynuujemy klikając w następnym oknie Create Key. W trakcie następnej operacji jaka jest tworzenie pary kluczy można w konie jakie się pojawi wpisywać dowolny tekst, poruszać nim po ekranie lub uruchomić program intensywnie korzystający z dysku gdyż program generatora zbiera dane „losowe” z naszego komputera celem podania ich do algorytmu tworzenia kluczy. Wpisany w oknie tekst nie będzie użyty w generowanych kluczach. O ciekawych sprawach związanych z losowością danych można poczytać w bardzo dobrej książce „Cisza w sieci” autorstwa Michała Zalewskiego. Kolejny etap to wprowadzenie hasła dla klucza prywatnego – staraj się aby hasło było możliwie trudne, zawierało min 10 znaków wraz ze znakami z poza alfabetu. Po utworzeniu certyfikatu a wraz z nim pary kluczy pojawia się potwierdzenie:

Mamy tu możliwość utworzenia pliku archiwum obu kluczy (prywatny i publiczny), wysłania certyfikatu na podany e-mail lub przesłania go do serwera certyfikatów o czym będzie nieco dalej, tu jednak nadmienię aby nie używać bezcelowo czy tylko w celu testu tej opcji gdyż raz posłany certyfikat zostanie tam na zawsze ponieważ jest prawie niemożliwe skasowanie go. Klikamy w Finish (kopie będziemy robić pózniej) i kończymy proces tworzenie nowego certyfikatu.

Spoglądając teraz do zakładek My Cerfificates oraz Trusted Certificates widzimy iż pojawił się tam wpis naszego nowego certyfikatu. Spójrzmy też do programu GPA – tam również pojawił się wpis z tym, że jest to tylko nowy klucz publiczny związany z utworzonym przed chwilą certyfikatem o czym świadczy pole Key-ID:

Powróćmy teraz do Kleopatry i sprawdzmy zawartość naszego certyfikatu (klikamy dwa razy na jego wpisie):

Zakładka Overview podaje najważniejsze informacje:
– User-ID dane o właścicielu certyfikatu (to co było wpisane przy jego tworzeniu)
– Validity termin ważności od do
– Type algorytm i długość klucza
– Usage przeznaczenie (omówione wyżej)
– Key-ID ID klucza
– Fingerprint odcisk palca certyfikatu
– Ownertrust zaufanie do certyfikatu (o nim będzie nieco dalej)
– Stored miejsce przechowania (komputer, SmartCard czy coś innego)

Jak widać mamy tu możliwość zmiany hasła do klucza prywatnego oraz daty ważności. Kolejna zakładka User-ID and Certifications przedstawia powiązania naszego certyfikatu z innymi, które mogły go obdarzyć zaufaniem a lista taka pojawia się po naciśnięciu Load certifications. O wzajemnej certyfikacji będzie nieco dalej.

Tworzenie żądania certyfikatu X.509

Certyfikaty X.509 to standard przemysłowy opisany w wielu dokumentach a podstawowe informacje znajdziesz na Wikipedii, w dokumencie RFC2459 oraz na wielu inny stronach internetowych. Tworzenie żądania certyfikatu X.509 rozpoczynamy z menu Files / New Cerificate a następnie wybieramy drugą pozycję Create a personal X.509..., w następnym oknie mamy już trochę więcej wpisywania:

W powyższym oknie należy wprowadzić dane w, które służą do utworzenia ścieżki nazewniczej  zwanej Nazwa Wyróżniająca w skrócie DN (ang. Distinguished Names). O sposobie budowy DN możesz poczytać na wielu stronach www na przykład w serwisie WebSphere czy na Wikipedii oraz w książkach takich jak K. Kocis Administracja MS Active Directory Helion 2002 lub S. Reimer, M. Mulcare Active Directory dla MS Windows Server 2003 Promise 2005. Jest to kolejny standard w świecie informatyki i dobrze się jest z nim zapoznać jeśli chce się na poważnie zajmować certyfikatami X.509 (i nie tylko).

– CN nazwa użytkownika
– email adres poczty
– L Twoja lokalizacja np. miasto (możesz zostawić puste)
– OU jednostka organizacyjna np wydział firmy(możesz zostawić puste)
– O nazwa organizacji
– C kod kraju z normą ISO

To w sumie wszystko, klikamy w Next i wprowadzamy hasło dla klucza prywatnego, po chwili żądanie certyfikatu jest gotowe.

Wygenerowana została para kluczy oraz żądanie certyfikatu X.509. Teraz możemy zakończyć lub od razu wygenerować plik żądania certyfikatu celem pózniejszego posłania do centrum certyfikacji. Klikamy więc w „Save…” i zapisujemy żądanie certyfikatu do pliku. Zauważmy, iż taki plik ma rozszerzenie *.p10 co jest standardem. Zapisany plik jest plikiem binarnym, który może zostać przesłany do centrum certyfikacyjnego CA co opisane będzie w innym poście.

Obsługa certyfikatów

W poprzednich postach dotyczących szyfrowania współpracowaliśmy z Jankiem i Helgą – kontynuujmy zatem to dzieło 🙂 Na maszynie wirtualnej, będącej „komputerem” Janka tworzymy jego certyfikat osobisty i zapisujemy do pliku, który przesyłamy na drugą maszynę – „komputer” Helgi. Na jej komputerze także tworzymy dla niej certyfikat osobisty. Wszystko w podany wyżej sposób. Teraz kilka sposobów obsługi certyfikatów.

– Export Certificates pozwala wyeksportować certyfikat do pliku
– Export Secret Keys eksportuje do pliku parę kluczy związanych z certyfikatem
– Export Certificates to Server eksportuje certyfikat do publicznego serwera
– Certify Certificate pozwala dany (zaznaczony) certyfikat certyfikować naszym certyfikatem
– Change Expiry Dart umożliwia zmianę daty ważności certyfikatu
– Change Passphrase zmiana hasła klucza prywatnego związanego c ceryfikatem
– Add User-ID dodaje do certyfikatu nowego użytkownika np w celu dodania innego adresu
– Import Certificate umożliwia import certyfikatu z pliku lub serwera

Na początek zabawy zwróćmy jeszcze uwagę na wpisy w programie GPA – po utworzeniu certyfikatu Helgi jest tam tylko jej klucz publiczny, natomiast komplet przechowywany jest przez Kleopatrę w powiązaniu z certyfikatem Helgi. Zajmiemy się tym nieco pózniej.

Eksport certyfikatu do pliku

Klikamy prawym w certyfikat Helgi i wybieramy Export certificates. Zauważ, że program proponuje nazwę pliku z certyfikatem, która jest zgodna z odciskiem palca togo konkretnego certyfikatu a ostatnie osiem znaków jest zgodnych z ID pary kluczy związanych z nim. Plik zapisujemy w dowolnym katalogu. Wyeksportuj teraz certyfikat Helgi za chwilę będziemy go importować. Wygenerowany plik certyfikatu jest plikiem ASCII:

Eksport pary kluczy związanych z certyfikatem

Zaznaczmy certyfikat i prawym, następnie menu Export Secret Keys, w oknie jakie się pojawi podajemy katalog docelowy oraz nazwę pliku z kluczami – może być w postaci ID klucza. Jeśli zaznaczysz opcję ASCI Armor wygenerowany zostanie plik ASCII (jak miało to miejsce w przypadku eksportu kluczy opisanych w innym poście). Wyeksportuj teraz klucze Helgi będą za chwile potrzebne.

Eksport certyfikatu do serwera

Certyfikaty możemy upubliczniać tym samym pozwalając na ich używanie wielu osobom. W tym celu zaznaczamy certyfikat i wybieramy opcję Export Certificates to Server. Pamiętaj iż nie należy bawić się w tym przypadku bo raz wysłany certyfikat zawsze już będzie w sieci. Aby skonfigurować listę serwerów do jakich posyłamy certyfikaty mamy opcję Settings / Configure Cleopatra:

Możesz skonfigurować więcej serwerów z podziałem na rodzaj eksportowanego certyfikatu (OpenPGP czy X.509).

Importowanie certyfikatów

Możesz zaimportować certyfikaty swoje (z archiwum), pary kluczy oraz certyfikaty cudze. Jeśli zaimportujesz swój certyfikat w GPA pojawi się tylko klucz publiczny ale jeśli wcześniej zrobiona była kopia kluczy (prywatny i publiczny) to wczytasz certyfikat razem z oboma kluczami. Jeszcze raz popatrzmy na GPA i Kleopatrę:

Mamy tu tylko jej klucz publiczny jednak mamy też w pliku wyeksportowanym przed chwilką oba jej klucze wraz z plikiem certyfikatu. Kasujemy zatem certyfikat Helgi i w GPA sprawdzamy czy klucz znika – tak właśnie powinno być (użyj przycisku Refresh w GPA Redisplay w Kleopatrze). Teraz zaimportujemy jej certyfikat a następnie parę kluczy zobaczyć różnicę. Klikamy w Import Certificate, wskazujemy plik i zatwierdzamy. Po chwili certyfikat pojawia się w zakładce Imported Certificates. Odświeżając widok w GPA widzimy iż pojawił się nowy klucz publiczny (błękitny), który jest związany z właśnie zaimportowanym certyfikatem. Ostatnim krokiem a tym wypadku jest zmiana poziomu zaufania dla tego certyfikatu. Prawym na certyfikacie i Change Owner Trust a następnie wybieramy odpowiedni poziom co omówione było w poście dotyczącym kluczy. W tym wypadku certyfikat jest traktowany jako obcy gdyż nie mamy z nim związanego klucza prywatnego. Pozostaje teraz kwestia certyfikowania tego nowo wczytanego certyfikatu własnym certyfikatem.

Certyfikowanie certyfikatu

Aby certyfikować wczytany, przechodzimy do zakładki Imported Certificates,  klikamy certyfikat Helgi prawym i opcja Certify Certificates a następnie zaznaczmy pozycje certyfikatów jakie chcemy certyfikować oraz pole I have veryfied the fingerprint oznaczające iż mamy pewność co do prawdziwości certyfikatu i zatwierdzamy. Kolejne okno to wybór czy certyfikujemy tylko dla siebie w swoim systemie czy dla wszystkich i od razy posyłamy go na serwer. W tym momencie wybieramy opcje Certify only for myself. Jeśli posiadamy zapisane dwa lub więcej nasze osobiste certyfikaty w oknie tym mamy do wyboru jakim certyfikatem podpiszemy certyfikat Helgi. Aby certyfikować wieloma naszymi certyfikatami operację powtarzamy dla każdego naszego certyfikatu.

Certyfikat pojawia się w zakładce Trusted Certificates co oznacza iż jest on dla nas zaufanym i mamy pewność iż należy do właściwej osoby oraz sam certyfikat jest OK. Jeśli teraz klikniemy w certyfikat aby wyświetlić jego właściwości a następnie w zakładkę User-IDs a następnie w przycisk na dole Load Certificatios pojawi się drzewo zaufania do certyfikatów oznaczające kto ufa temu certyfikatowi. Jeśli była zaznaczona opcja certyfikacji tylko dla siebie to po wyeksportowaniu tego certyfikatu i wczytaniu go u Janka (czy u kogokolwiek innego) nie będzie on już certyfikowany przez te dodatkowe certyfikaty!

Wobec tego eksportujemy do pliku np 19968DE25253ED9B35CD7706B8F12FC0E324503B_2.asc ten certyfikowany przez nas certyfikat,  przesiadamy się na komputer Janka, importujemy go i…

Mamy „czysty” certyfikat Helgi. Jeśli przy certyfikowaniu certyfikatu Helgi naszym(i) była włączona opcja certyfikacji dla każdego

to po ponownym wyeksportowaniu go do pliku a następnie imporcie na komputerze Janka pojawia się (prawie) pełne drzewo certyfikacji:

Niestety ponieważ Janek nie ma moich certyfikatów to drzewo nie jest takie zupełnie pełne 🙂 Aby w certyfikacie Helgi pojawiły się odpowiednie wpisy na komputerze Janka muszą znajdować się zaimportowane odpowiednie certyfikaty (te, którymi jest podpisany certyfikat Helgi). Tak więc wyeksportuję teraz je do pliku i zaimportuję na komputerze Janka (można eksportowa / importować więcej pozycji na raz). Po imporcie pliku z moimi certyfikatami u Janka w certyfikacie Helgi pojawiają się już odpowiednie wpisy:

Import pełnego certyfikatu (pary kluczy)

Aby wczytać pełny certyfikat z kluczem (wcześniej wyeksportowany za pomocą opcji Export Secret Keys) musimy plik z tym archiwum wczytać w taki sam sposób jak wyżej. Najpierw jednak kasujemy certyfikat Helgi (na jej komputerze). Teraz opcja Import Certificate i wybieramy plik z archiwum kluczy utworzonym w kroku Eksport pary kluczy związanych z certyfikatem. W przypadku importu swojego certyfikatu z parą kluczy pojawia się informacja mówiąca o zaimportowaniu „Secret certificates”:

Kolejny krok to ustawienie Owner Trus na Ultimate czyli prawym na certyfikacie i Change Owner Trust a w następnym oknie zaznaczamy opcje This is my certificate. W tym momencie certyfikat staje się zaufamy i możemy w pełnie z niego korzystać.  Wez pod uwagę, iż plik z tak wyeksportowanymi danymi zawiera Twój klucz prywatny – ten plik należy szczególnie chronić! Jeśli natomiast importujemy cudzy certyfikat (tylko z kluczem publicznym pojawia się nieco inny komunikat:

Informujący wyłącznie o ilości zaimportowanych certyfikatów.

Dodawanie dodatkowych użytkowników do certyfikatu

Ta opcja  ma sens tylko w przypadku gdy chcemy dodać więcej adresów e-mail do jednego certyfikatu. Certyfikat zawsze związany jest z jednym podmiotem i raczej nie należy wiązać go z wieloma nazwami użytkownika czy skrzynek e-mail gdyż takie postępowanie może wprowadzać bałagan.

Import i eksport z użyciem serwera kluczy / certyfikatów

W poprzednich postach omówiłem możliwość eksportu i importu do i z publicznych serwerów kluczy. W przypadku certyfikatów są to te same serwery. Zróbmy próbę: klikamy w menu Files / Lookup Certificates on Server po czym wpisujemy Igor Brzezek. Pojawia się lista „certyfikatów”:

tylko, że to jest lista moich kluczy publicznych jakie kiedyś wyeksportowałem na serwery kluczy. Jak więc widać klucz publiczny eksportowany z GPA jest rónoważny w pewnym sensie certyfikatowi z Kleopatry. Pamiętajmy, iż certyfikat zawiera dane podmiotu i klucz publiczny podmiotu podobnie jak sam klucz publiczny także zawiera dane podmiotu do jakiego on należy. Druga sprawa tyczy się tego, iż jest to lista certyfikatów OpenPGP a nie X.509 które różnią się w wielu aspektach. Jeśli chodzi o eksport certyfikatu robi sie to w podobny sposób za pomocą opcji Export Certificates to Server. W spisie kluczy, na serwerze pojawia się nowy wpis:

***********************************************

Ufff… sporo materiału ale warto poznać tego typu programy gdyż wspierają nas w zachowaniu poufności i integralności danych. Jak będzie czas powstaną inne posty w tym temacie.

Kiedy korzystamy z szyfrowania musimy posiadać klucze szyfrujące nasze oraz partnerów. W zarządzaniu kluczami pomaga nam oprogramowanie między innymi takie jak Gnu4Win GPA (Gnu Privacy Assistant). Program pozwala generować pary kluczy (prywatny + publiczny), eksportować publiczne na serwery i do plików a prywatne archiwizować w plikach. Podstawy szyfrowania zawarto w innym poście.

Najpierw utworzymy parę osobistych kluczy prywatny + publiczny, w tym celu przechodzimy do GPA i z menu Keys / New key… uruchamiamy kreatora kluczy.

W naszych przykładach używamy kluczy o długości 2048 bitów oraz opartych o algorytm RSA. Pozostałe dane wedle uznania mając na uwadze, że data ważności klucza może być wymagana w niektórych środowiskach jednak wiąże się to z koniecznością dbania o archiwum oraz historię kluczy co już nie jest takie proste.

Kolejny krok to ustalenie hasła dla klucza prywatnego i wygenerowanie pary kluczy przez GPA. Jeśli to była pierwsza para kluczy automatycznie staje się ona kluczami domyślnymi:

W podsumowaniu mamy ważne informacje dotyczące parametrów klucza, co stanie się jaśniejsze przy imporcie innych kluczy z jakimi będziemy pracować.

Przyjrzyjmy się jeszcze konfiguracji programu: menu Edit / Preferences, gdzie można ustawić domyślny serwer kluczy, ustawmy zatem na keyserver.ubuntu.com

W sumie w tym momencie można już zacząć pracę, jednak dobrze jest wykonać jeszcze kilka kroków celem zabezpieczenia naszych kluczy. Wez pod uwagę, że to co zaszyfrujesz kluczem publicznym może być odszyfrowane tylko związanym z nim kluczem prywatnym. Gdy stracisz klucz prywatny prawdopodobnie nigdy już nie uzyskasz danych zaszyfrowanych związanym z nim kluczem publicznym. Wobec tego należało by jakoś zabezpieczyć najlepiej oba klucze. W omawianym programie mamy taką możliwość i to w kilku wariantach:

– eksport klucza publicznego na ogólnodostępny serwer
– eksport klucza publicznego do pliku tekstowego
– archiwizacja pary kluczy do pliku tekstowego
– kasowanie klucza / pary kluczy
– wczytanie pary kluczy z pliku tekstowego
– wczytanie klucza publicznego z pliku tekstowego
– import klucza publicznego z serwera
– podpisywanie innych kluczy

Eksport klucza publicznego na ogólnodostępny serwer

W sieci mamy dostępnych wiele serwerów kluczy publicznych takich jak
http://keyserver.ubuntu.com/
http://pgp.mit.edu/
http://keys.gnupg.net/
oraz inne świadczące podobne usługi. Pamiętaj o jednym fakcie: raz posłany tam klucz zostaje na zawsze – praktycznie nie ma możliwości jego skasowania gdyż serwery te tworzą sieć i co „wrzucisz” do jednego pojawia się na wielu innych. Wgrywanie klucza publicznego jest automatyczne i bardzo proste:

Kliknij prawym klawiszem myszki dany klucz (parę kluczy) i wybierz opcję Send Keys – klucz publiczny zostanie wysłany na serwer (o tym na jaki decyduje opcja Default keyserver z menu Edit / Preferences programu GPA).

Aby sprawdzić czy klucz znajduje się na serwerach kluczy wystarczy otworzyć jedną z podanych wyżej stron np: http://keyserver.ubuntu.com i w pole Search string wpisać dane użytkownika (np mail) jakie były podane przy tworzeniu jego klucza:

W odpowiedzi dostajemy przechowywane klucze. Uwaga – Search string poszukuje dokładnie takich danych jak wpiszemy – to nie Google więc Igor Brzeżek to zupełnie coś innego niż Igor Brzezek (ż i z) więc najlepiej szukać po adresie e-mail. Poniżej fragment odpowiedzi serwera kluczy:

Jak widać klucze posortowane są wdł. daty ich umieszczenia i opisane zgodnie z tym co widzimy w programie GPA. Mój najnowszy klucz ma ID: D915D89E. ID będzie potrzebne do importu kluczy w programie GPA ale o tym nieco pózniej. Klikając w ID klucza jago widok wyświetla się w przeglądarce tak więc można go skopiować, wkleić do pliku a następnie zaimportować do GPA.

Eksport klucza publicznego do pliku tekstowego

Kolejna możliwość to eksport klucza publicznego do pliku tekstowego celem archiwizacji lub przekazania innym. W tym celu z przycisków wybieramy pozycję Export lub na danym kluczu (kluczach) klikamy prawym i wybieramy opcje Export Keys.

Pojawia się okno zatytułowane: Export public keys to file co wyraznie oznacza eksport tylko klucza (kluczy) prywatnego. W oknie podajemy nazwę pliku (może być email + ID klucza z rozszerzeniem asc) oraz włączmy opcję armor oznaczającą zapis do pliku w postaci tekstu ASCII (jest to bardziej uniwersalne). Tak wyeksportowany klucz w postaci pliku możemy udostępnić wszystkim, którzy chcą wysyłać do nas zaszyfrowane wiadomości lub sprawdzać nasz podpis cyfrowy. W mojej wersji program niestety nie wstawiał automatycznie rozszerzenia asc co pewnie będzie naprawione w nowszych edycjach.

Wygenerowany plik można przeglądać w dowolnym edytorze tekstu, kopiować zawartość i np. wkleić na swoja stronę www czy do maila. Ważne jest aby nie zmienić ani jednego znaku gdyż to spowoduje zniszczenie klucza. Poniżej widok klucza publicznego z wyeksportowanego pliku.

—–BEGIN PGP PUBLIC KEY BLOCK—–
Version: GnuPG v2.0.17 (MingW32)

mQENBFFfFh8BCACzb383NDIdV53t1F1cpWgS0NF95qLApf4c9VGwCEDCglMunMWG
I+xHy18F6iUpP4HI9Ws0vTP/gz+VqwkA7IfmBG47cEt5/a6ltZgGlh2BxrQ7aVSM
0uCc3O5b/wcrI5Eg1nUb60dhQWWBR/M+tPAzfRl2MyAXn/VYbir44LIM1EkA9Xb8
SwKFVGJ3SeX9nuJXMUP4VXynyLIfDVzj/zHBPKeRiTD8stVTi6mSapzJH3I6/S9H
DrnB6qJe7m0xYsEJgWsXwya5D3XPJfmH+eEYXHgzg7e97YdSwjkCtHrpN3Nnn0Qd
RUzi6HJN4Z5fYRu44x3xRPk5+fJkCtCOxZdbABEBAAG0Nklnb3IgQnJ6ZXplayAo
S2x1Y3ogb3NvYmlzdHkpIDxpZ29yLmJyemV6ZWtAZ21haWwuY29tPokBOAQTAQIA
IgUCUV8WHwIbAwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQbTE72NkV2J7S
sQf/eqlwXS7Sse5M5BqqbSOiDOsR2cRuVnenZIqCqgXr7v8yUxvv9GAW3WuJ3vkK
2CQ9tDz4nE2OkW3KI9PYgWacwCv2hDO7ZiJ2tRXM8TmgsquB9GfFmCQ2gAbH/tt9
bNZbtJz7y5tEmaz1mruDAVzUYEK2zL4JJWhSV3JGcR7D94R4NmXM9XRJxxsP9weS
AcPRb+Qu6hB/c7j505a2wf80MKNRifDsvJgWUcA8Qt008L9V20JgX9vjMYYgzu2e
J+Va9HvzAPyPhOCOVujmkIy40vz9onsRYj2RDEw6zoL8f6+J2y94x5XJHbQTKaNo
mUHu/f1VUy9GJBEBUy4mJsKP4LkBDQRRXxYfAQgAo0Uh/P0ngbwMw5aDJKU017vJ
3cPbJCL+aj+WMsTNd+YN5I1HTkqm2LDUNrXUwmoA92wgIgci+l8YN5qMY1Fuctk4
Dy+3PX+GQJJUzhJfQeN9Kv7xtPUCtzX78HpzxniO0BiA76GAkme3kTOzOUdtYzU+
ciXuKbIYhEUmg0l6Zemj4yvQYmqP2bBlHMvqXL40xtb72WbD5tpPRWTvsAYdEjU4
ljSYdaME+SZxymaNKRpFXdYYeK93tL2t7EpUz0QfIlBCr09XP+o7ss25V4ePITvE
7yrPFtWf23A5q6M8gxYfHUcoBU33H6NUrdue/7XIgdpa3FukDWC2XyadtfS+UQAR
AQABiQEfBBgBAgAJBQJRXxYfAhsMAAoJEG0xO9jZFdieCNMH/Rfh2QltMGSyYJwU
BG9dcyitgR2c4eXUA2EOEN2fIje1p6e2NoBz9+sDIvS9rL7wc6Ef+helBoRS1ArC
uDuUjxnafCRIURe0cB2NosoJs990Q1eCBxA7DZsnZY5QH/j34dnae98S9ZDu5Ml/
L+EKvpFEpRr3DN/hQq7QdqLj0QkTPvqnLDjwVOTo548A4wzbWMHM1E2VFCbKJ8WC
R8mZBtdjaX6RrOtPkkGvWJQm7saFHwtmuCOs/haT/4b42j4scDOOLMJkWiFpxrwu
C6HG9AZBDgCpprpMmVe0R7m1fijAZ0S7GDDDLqhLfgS4vPayoUu45NsbJdfCDII0
/T8PHYI=
=RTbv
—–END PGP PUBLIC KEY BLOCK—–

Archiwizacja pary kluczy do pliku tekstowego

Archiwizacja (ang. backup) to nie to samo co eksport gdyż zapisuje ona do pliku (najczęściej też tekstowego) klucz publiczny oraz prywatny co naraża go na ujawnienie. Wobec tego tak wygenerowany plik należy zabezpieczyć. Archiwizację wykonuje się w wielu celach, dla uproszczenia przyjmijmy, iż jest ona potrzebna w przypadku np. uszkodzenia nośnika z kluczem. W takiej sytuacji oba klucze można łatwo odzyskać z pliku archiwum. W celu archiwizacji zaznaczamy wymagany klucz (najczęściej jest to powiązana para), klikamy prawy i z menu wybieramy pozycję Backup. To samo osiągniemy korzystając z menu Keys / Backup.

Pojawia się okno podobne do eksportu klucza publicznego z tym, że tym razem program już wygenerował nazwę pliku docelowego składającą się z frazy secret-key-ID_KLUCZA.asc, co oznacza iż mamy do czynienia z  kluczem prywatnym (secret) i plikiem tekstowym. Do nazwy można dodać e-mail czy dane właściciela.

Kasowanie klucza / pary kluczy.

Jeśli mamy już zarchiwizowaną parę kluczy (w pliku i na serwerze) oraz klucz publiczny możemy dokonać operacji skasowania kluczy celem przedstawienie operacji importu. W tym celu zaznaczmy klucz, klikamy prawym i wybieramy opcję Delete keys. Jest to operacja nieodwracalna więc program dwa razy każe ją potwierdzić po czym klucze zostają bezpowrotnie skasowane. Jeśli coś zaszyfrowałeś a nie masz kopii kluczy (zwłaszcza prywatnego) masz kłopot…

Jeśli skasowałeś wszystkie pary swoich kluczy GPA przy następnym uruchomieniu pokaże błąd:

Oznacz to iż brak klucza domyślnego. Nic nie szkodzi za chwilę wczytamy takowy i będzie ok. Generalnie jedne z kluczy (zazwyczaj pierwszy wczytany czy utworzony) prywatnych  jest kluczem domyślnym jaki stosowany jest domyślnie przy operacjach podpisu.

Wczytanie pary kluczy z pliku tekstowego.

Pierwsze odzyskanie klucza przeprowadzimy na bazie klucza publicznego. To dokładnie to co będziesz robić w przypadku gdy dostaniesz od kogoś jego klucz publiczny. Potem wczytamy jeszcze dwa klucze publiczne, używane w innym poście dotyczącym szyfrowania. Są to klucze Janka i Helgi. Jeśli w pliku mamy klucz publiczny wczytamy go bez problemu ale jeśli jest to plik z parą kluczy (publiczny + prywatny) będzie trzeba podać hasło klucza prywatnego.

1 – Wczytujemy nasz poprzednio skasowany klucz, w tym celu z programu GPA wybieramy menu Keys / Import keys i wskazujemy plik z parą naszych kluczy (uprzednio zarchiwizowanych, w tym wypadku plik IgorBrzezek_secret-key-4D6E9EE5.asc ). Ponieważ jest to para kluczy wczytana z pliku a więc z założenia nie są one zaufane. Aby podnieść poziom ufności dla tych kluczy należy zmienić to poprzez menu Keys / Set Owner Trust, który ustawiamy na Ultimate. (Poziom zaufania dla kluczy opisany jest w dokumentacji GPG, generalnie Ultimate tylko dla tych którym ufamy i znamy ich gdyż powoduje to iż ufamy też kluczom podpisanym przez te osoby co może tworzyć długi łańcuchy zaufania)

Jak widać poniżej zaufanie dla klucza zostało ustanowione na pełne:

Ponieważ wczytano parę kluczy należy je traktować jako klucze osobiste. Możemy teraz dla lepszego zobrazowania dalszych czynności dodać nową parę kluczy, którą wygenerujemy wcześniej poznanym sposobem (Keys / New keys)

OK mamy już drugą parę kluczy czas na dalsze czynności.

2 – Klucz domyślny. Zauważmy, iż nadal nie ma klucza domyślnego (status u dołu okna), aby takowy ustanowić przechodzimy do menu Edit / Preferences i zaznaczamy wybraną parę kluczy, od tego moment staną się one kluczami domyślnymi, automatycznie używanymi przez program do np podpisywania, co oczywiście możemy w trakcie różnych operacji zmienić.

Zaznaczamy wybraną parę kluczy, ew. inne opcje i klikamy OK. W tym momencie mamy ustanowiony klucz domyślny co widać w dolnej linii statusowej programu GPA:

Wczytanie klucza publicznego z pliku tekstowego

Kolejna operacja polega na imporcie kluczy publicznych naszych partnerów komunikacji, najpierw zajmiemy się wczytaniem kluczy publicznych z dostarczonych nam plików. Pliki możemy otrzymać od znajomych, którzy chcą abyśmy szyfrowali dla nich dane ich kluczami publicznymi tak aby mogli je rozszyfrować. Janek i Helga wyeksportowali już swoje klucze publiczne do plików janek_pub.asc i helga_pub.asc oraz dostarczyli je nam. Aby zaimportować klucz publiczny do GPA wybieramy menu Keys / Import keys i zaznaczamy właściwy plik z kluczem  czy kluczami. W ten sposób można importować klucze publiczne znajomych. Czynność przeprowadzamy dla oby podanych wyżej plików. W GPA pojawiły sie wczytane klucze publiczne, jednak nie są one kluczami zaufanymi i trzeba to zmienić w podany wcześniej sposób (Kesy / Set Owner Trust) zmieniamy na Ultimate.

Pobranie klucza z serwera

Klucz publiczny z serwera kluczy można pobrać na dwa sposoby:
– z poziomu GPA
– ręcznie przeszukując zasoby serwera a następnie wklejając klucz do pliku tekstowego, który z kolei importujemy do GPA

Automatyczne wczytanie klucza z serwerów kluczy polega na wybraniu menu Server / Retrieve keys i wpisaniu ID klucza. Jeśli ID jest poprawne klucz publiczny danej osoby zostanie zaimportowany. ID klucza dostajemy od właściciela lub szukamy w bazie kluczy za pomocą metod opisanych wyżej.

Podpisywanie kluczy

Każdy klucz jest podpisany sam przez siebie co można zobaczyć w statusie klucza:

W tym wypadku mamy klucz publiczny Janka, który jest podpisany sam przez siebie co oznacza, iż jeszcze nikt go nie podpisał. Zaraz to zrobimy domyślnym kluczem jednak najpierw parę słów wyjaśnienia.  Podpisywani kluczy ma na celu stworzenie przechodniego łańcucha zaufania. Jeśli Helga ufa kluczowi publicznemu Brunnera a Janek ufa kluczowi Helgi to oznacza to iż Janek nie musi sprawdzać kluczy podpisanych przez Helgę tylko może im zaufać co obrazuje poniższa ilustracja.

Taka konstrukcja zaufania upraszcza sprawdzanie wielu kluczy i tworzy sieć zaufania (ang. Web of Trust). Inną kwestią jest całkowity brak kontroli nad tym czy Brunner jest Brunnerem czy kimkolwiek innym. Web of Trust nie rozwiązuje takich problemów. Powracając do naszego GPA i klucza Janka widzimy, iż nie jest on przez nikogo podpisany. Podpiszmy go więc. Tu uwaga: obce klucze publiczne GPA podpisuje aktualnie domyślnym kluczem prywatnym. Jeśłi chcemy podpisać czyjś klucz innym naszym kluczem należy zmienić klucz domyślny w ustawieniach programu GPA. Tak więc podpiszmy klucz publiczny Janka naszym kluczem aktualnie domyślnym: prawy na kluczy Janka i wybieramy opcje Sign keys:

Pojawia się okno w którym ważnym parametrem jest Sign only locally co powoduje, że klucz jest podpisany tylko w systemie lokalnym i w razie eksportu klucza nie zostaną z nim te informacje wyeksportowane.

Zaznaczamy tą opcje i zatwierdzamy. Jak widać w parametrach klucza Janka pojawił się wpis świadczący iż został on podpisany (czerwona ramka) naszym kluczem domyślnym (zielona ramka):

Dodatkowo jest informacja, iż podpis jest ważny tylko w systemie lokalnym co oznacza, że jeśli klucz zostanie wyeksportowany na serwer tam już nie bzie podpisany przez nasz klucz. Jeśli tej opcji podczas podpisywania nie zaznaczymy a potem klucz zostanie wyeksportowany na serwer kluczy wraz z nim będą tam informacje jakie klucze (osoby) go podpisały. Aby sprawdzić jak to działa użyjemy w tym celu jednego z mich starych kluczy ID = 8C62932A. Sprawdzając na keyserver.ubuntu.com dostajemy:

Klucz jest podpisany tylko przez siebie. Zaimportujemy go teraz do GPA i podpiszemy go moim kluczem tamże domyślnym  (ID = 139F81D0 nie jest wyeksportowany na żaden serwer kluczy). Tak więc GPA -> Server / Retrieve keys, wpisujemy ID = 8C62932A i ok. Podnosimy jego poziom zaufania na Ultimete (bo to mu klucz wiec jakże by inaczej) i podpisujemy go kluczem domyślnym czyli prawym na kluczu i Sign keys. NIE zaznaczamy Sign only locally i klikamy ok. Jak widać klucz został podpisany moim domyślnym kluczem:

Teraz eksportujemy na serwer kluczy ten nowo podpisany klucz (o ID = 8C62932A) czyli Server / Send keys i ponownie sprawdzamy na stronie serwera czy jest jakaś zmiana:

Jak najbardziej pojawił się wpis świadczący iż klucz 8C62932A jest podpisany przez klucz 139F81D0. Pięknie tylko, że po kliknięciu w klucz 139F81D0 nic się nie wyświetla czyli klucza tego nie ma na serwerze wiec nie można go w żaden sposób zweryfikować. Zostawmy to jednak i podpiszmy teraz kluczem D915D89E czyli moim aktualnym. W tym celu importuje go z pliku archiwizacyjnego (para kluczy) i ustalam jako domyślny a następnie podpisuję nasz testowy klucz.

W razie gdyby GPA wyświetlał błąd hasła po zmianie klucza domyślnego – zrestartuj program. Teraz eksportujemy nasz klucz testowy 8C62932A do serwera kluczy i sprawdzamy jak wygląda jego wpis:

Jest OK wpis się pojawił nasz klucz testowy ma już dwa podpisy. Mój klucz może być podpisany przez innych itd co daje strukturę Web of Trust. Po zaimportowaniu klucza do lokalnego systemu wszystkie powiązania są oczywiście zachowywane.

Kilka ważnych uwag

Fingerprint to cyfrowy odcisk klucza – zawsze po pobraniu klucza publicznego należy zweryfikować czy podany fingerptint jest zgodny z prawdą np przez kontakt z właścicielem klucza.

Poziomy zaufania kluczom
GPG pozwana na ustalenie kilku poziomów zaufania jakimi możemy obdarzyć klucze:
– unknow: domyślnie, brak danych dotyczących klucza
– never: nie ufaj nigdy kluczom oznaczonym tym poziomem
– marginal: nie można być pewnym co do klucza ani właściciela
– full: pełne zaufanie do klucza i właściciela
– ultimate: pełne zaufanie w sumie tylko dla naszych kluczy
Poziomy są dość płynne i jest możliwa ich różna interpretacja.

Podsumowanie

Przedstawione oprogramowanie i możliwości raczej nadają się do prywatnego użytku głównie ze względu na brak mechanizmu potwierdzającego autentyczność osób stojących za kluczami oraz małą skalowalność. Program GPA pomaga w obsłudze kluczy choć nie zawsze działa poprawnie czasem się wieszając lub  zamykając z błędem. Dostępna jest oczywiście wersja dla Linuxa ale to będzie temat na inny post.

Szyfrowanie danych jest dość istotną czynnością celem której ma być ukrycie zawartości danych (np dokumentu tekstowego) przed osobami niepowołanymi. Wraz z rozwojem potrzeb biznesowych pojawiły się tez inne możliwości takie jak podpis cyfrowy oraz związane z nimi funkcje skrótu czy sumy kontrolne. W tym poście opisano podstawowe wiadomości dotyczące szyfrowania asymetrycznego,  generowania pary kluczy (publiczny / prywatny), oraz cyfrowego podpisu na bazie oprogramowania Gnu4Win. Przedstawiono też funkcje serwerów kluczy.

Wstępnie kilka uwag teoretycznych. Z szyfrowaniem inaczej mówiąc utajnianiem wiadomości wiąże się pojęcie algorytmu szyfrującego oraz klucza.  Szyfrowanie, ogólnie rzecz ujmując można podzielić na dwa rodzaje: symetryczne i asymetryczne. W szyfrowaniu symetrycznym każda ze stron musi mieć ten sam klucz co przy większej ilości kontaktów zaczyna być problemem. W szyfrowaniu asymetrycznym każdy ma swoją parę kluczy prywatny + publiczny. Klucz prywatny musi być silnie strzeżony publiczny natomiast można (nawet należy) udostępnić wszystkim chcącym posyłać do nas zaszyfrowane wiadomości.

Szyfrowanie asymetryczne. Co zostanie zaszyfrowanie kluczem publicznym może być odszyfrowane tylko (a przynajmniej tam nam się mówi) powiązanym z nim kluczem prywatnym. Teoretycznie i jak na razie praktycznie nie ma możliwości zbudowania klucza prywatnego na bazie klucza publicznego. Szyfrowanie służy zachowaniu poufności wiadomości.

Podpis cyfrowy. Z drugiej strony zastosowanie klucza prywatnego, poza operacją odszyfrowania, ma miejsce w przypadku wykonywania podpisów elektronicznych (cyfrowych). Dokument jest traktowany funkcją skrótu, tak utworzony skrót jest szyfrowany kluczem prywatnym właściciela czy nadawcy dokumentu. Odbiorca za pomocą powiązanego klucza publicznego deszyfruje skrót, oblicza własny i porównuje. Jeśli wynik porównania jest pozytywny oznacz to poprawność podpisu. Pozostaje kwestia czy klucz publiczny np pobrany z ogólnodostępnego serwera kluczy należy faktycznie do tego kto jest w jego opisie ale to temat na inny post dotyczący certyfikatów i urzędów certyfikacyjnych.

Poniżej przedstawiono uproszczony schemat szyfrowania asymetrycznego.

Aby Helga mogła bezpiecznie do agenta J23 (Janek) posłać wiadomość musi posiadać jego klucz publiczny, który może pobrać z ogólnodostępnego serwera kluczy. Jednak aby się tam znalazł najpierw Janek musi go tam posłać. Tak więc:
1 – Janek posyła (eksportuje) swój klucz publiczny Jpub na serwer kluczy
2 – Helga pobiera klucz publiczny Janka i zapisuje w swoim archiwum
3 – Szyfruje dokument kluczem publicznym Janka i posyła go
4 – Janek, używając swojego klucza prywatnego Jpryw, deszyfruje dokument i cieszy się nim (bo Brunner poszedł na emeryturę)

Tyle teorii, więcej w necie i moim małym dokumencie Systemy_PKI.pdf, z podpisem cyfrowym Systemy_PKI.pdf.sig. Przystępujemy do praktyki.

Zakładam, że nie masz jeszcze swojej pary kluczy publiczny / prywatny i będziemy je generować za pomocą omawianego programu.

1. Wchodzimy na stronę www.gnupg.org i z lewej wybieramy Download i następnie Biranies po czym klikamy w Gpg4win. Przekieruje nas to do strony gpg4win.org. Z tej strony pobieramy najnowszą, stabilną (nie beta!) wersję pakietu GPG4Win. Po zakończeniu pobierania instalujemy ją zwracając uwagę aby zaznaczyć opcję GPA (Gnu Privacy Assistance) w razie gdyby była niezaznaczona. Cały proces jest dość prosty i w sumie polega na klikaniu Next.

2. Po instalacji rozpoczynamy proces generowania naszej pierwszej pary kluczy. Generowane są klucze publiczny i prywatny. Pamiętaj: publiczny możesz a nawet musisz udostępnić wszystkim zainteresowanym (o tym nieco dalej) ale prywatny trzeba chronić – on jest tylko dla Ciebie! Ponieważ program jest świeżo zainstalowany od razu pojawia się monit dotyczący wygenerowanie pierwszej pary kluczy.

Klikamy w Generate key now i rozpoczyna się proces generowania pierwszej pary kluczy. Podajemy dane:
– Imię i nazwisko
– adres e-mail
– decydujemy czy od razu wykonać kpię kluczy (tu dajemy nie – Do it later)
– czekamy chwilkę na wygenerowanie klucza po czym pojawia się monit o ustalenie hasła do klucza prywatnego, wpisujemy hasło (dwukrotnie) dbając aby było silne
– pojawia się główne okno programu z wygenerowaną parą kluczy (klucze symbolizowane są ikonką klucza: żółty to prywatny, błękitny to publiczny, gdy są jeden nad drugim oznacza to powiązaną parę kluczy)

W ten sposób mamy wygenerowaną pierwszą parę kluczy która składa się z klucza publicznego i prywatnego. Przejrzyjmy zatem opcje jakie mamy dostępne w programie GPA.

W głównym oknie mamy spis wszystkich zainstalowanych kluczy (na razie tylko jedna para) a w dolnej części okna podsumowanie aktualnie zaznaczonego klucza. Domyślny widok jest uproszczony aby przełączyć na widok zaawansowany klikamy w przycisk Detailed w górnej części okna programu. Przeanalizujmy teraz właściwości naszych kluczy.

Key ID – jest identyfikatorem klucza wyjątkowo pomocnym podczas korzystania z publicznych serwerów kluczy choć nie tylko (zapamiętaj to ID gdyż będzie używane w dalszych przykładach)
Expiry Date – data wygaśnięcia ważności klucza, domyślnie nigdy
Owner Trust – oznacza poziom zaufanie do klucza, dla naszej pary jest Ultimate czyli całkowity co jest logiczne bo to nasza nowa para kluczy
Validity – ważność klucza, którą traci po dojściu do daty ważności
User name – nazwa użytkownika wraz z e-mailem
Fingerprint – cyfrowy odcisk palca danej pary/klucza
Key type – typ klucza, tu RSA o długości 2048 bitów

W zasadzie to wszystko 🙂 Mamy nową parę kluczy, za pomocą której można już dokonywać operacji szyfrowania, deszyfrowania i podpisywania dokumentów. Dla przykładu możemy utworzyć plik tekstowy i wpisać do niego dowolny tekst:

Następnie przechodzimy do eksploratora plików (czy czego tam używasz – ja Totall Commandera) i prawym klikamy na naszym pliku. Pojawia się menu podręczne:

Na razie interesują nas pozycje Decrypt (odszyfrowanie), Encrypt (szyfrowanie), Sign(podpisanie) oraz Verify (weryfikacja podpisu). Dodatkową przydatną opcją jest suma kontrolna (Create i Verify).

W ćwiczeniach używam maszyn wirtualnych z zainstalowanym Gnu4Win. Jedna maszyna to „komputer” Janka a druga Helgi. Na każdym są wygenerowane klucze właściciela a dodatkowo Janek ma klucz publiczny Helgi. Aby pozyskać klucz publiczny Janka na komputerze Helgi i wspak skocz do postu opisującego obsługę kluczy. Tak czy inaczej Janek musi posiadać klucz publiczny Helgi a Helga klucz publiczny Janka aby mogli przesyłać do siebie zaszyfrowane dokumenty a następnie je deszyfrować czy weryfikować podpisy.

Szyfrowanie

Dane szyfruje się kluczem publicznym. Pamiętaj, że posyłając dane do np Janka szyfrujemy je kluczem publicznym Janka nie naszym! W takim wypadku tylko Janek może je odszyfrować (pozostaje problem pewności, że klucz który posiadam jest faktycznie przynależny do Janka a nie kogo innego ale to temat na inny post) więc uznajemy je za dobrze zabezpieczone. Tak więc szyfrujemy dane przeznaczone dla Helgi czyli Janek szyfruje za pomocą jej klucza publicznego a ona deszyfruje za pomocą swojego klucza prywatnego.

1 – Na wybranym pliku (poufne.txt) klikamy prawym i wybieramy pozycję More GpgEX options > Encrypt

2 – W oknie jakie się pojawi wybieramy opcję Encrypt

Uwaga – jeśli chcemy zarchiwizować kilka plików i jednocześnie stworzyć z nich archiwum zaznaczamy opcję Archiwe files with i określany nazwy plików z archiwum. Program wszystkie zaznaczone wcześniej pliki (więcej plików zaznaczamy w normalny sposób) spakuje do archiwum i całość zaszyfruje.
Pozostałe opcje:
– Sign oznacza operację wykonania podpisu cyfrowego, w tym wypadku Janek musi użyć jednego ze swoich kluczy prywatnych
– Text output (ASCII armor) wynik jest w formacie tekstowym ASCII (znaki 1-127) a nie binarnym co może być bardziej uniwersalne podczas przesyłania tak zaszyfrowanego pliku, w tym wypadku pliki zaszyfrowane mają rozszerzenie .asc w przeciwnym razie .gpg
– Remove… usuwa oryginał (pamiętaj ze zazwyczaj będzie istniała możliwość odtworzenia pliku jeśli ktoś będzie bardzo to chciał zrobić)

3 – W kolejnym oknie wybieramy klucz publiczny Helgi, naciskamy Add czyli dodajemy go do listy kluczy jakimi zaszyfrujemy plik (tak, można szyfrować do kilku odbiorców naraz w tym i do siebie jeśli oryginał ma być zniszczony), na koniec zatwierdzamy tym samym rozpoczynając proces szyfrowania (jeśli wśród kluczy szyfrujących, publicznych, nie było naszego program wyświetli ostrzeżenie omówione wyżej)

4 – Kończymy z informacją o poprawnym szyfrowaniu

5 – Celem weryfikacji sprawdzamy zawartość katalogu z plikiem jaki szyfrowaliśmy – pojawia się plik poufne.txt.gpg gdzie gpg jest automatycznie dodawanym rozszerzeniem zaszyfrowanym plikom:

Jak widać zawartość pliku jest nieczytelna czyli zaszyfrowana, w tym wypadku to plik binarny (Janek nie zaznaczył opcji ASCII armor). Taki plik można bezpiecznie posłać do adresata.

Deszyfrowanie

Odszyfrować dane można tylko w przypadku gdy posiadamy klucz prywatny powiązany z kluczem publicznym jakim dane zostały zaszyfrowane. Ktoś pobiera z serwera kluczy nasz publiczny, szyfruje nim plik i posyła do nas. Taki plik możemy deszyfrować za pomocą powiązanego klucza prywatnego. Helga ma już zaszyfrowany plik a więc może przystąpić do jego odszyfrowania.

1 – Przesiadamy się na komputer Helgi, prawym klikamy na zaszyfrowanym pliku poufne.txt.gpg i docelowo wybieramy Decrypt

2 – W następnym oknie wybieramy folder docelowy w jakim ma się pojawić rozszyfrowany plik (pliki w przypadku archiwum) i klikamy w Decrypt/Verify

3 – Zapewne pojawi się monit o hasło o prywatnego klucza Helgi jakim odszyfrujemy plik, należy je więc podać i zakończyć proces deszyfrowania

4 – Sprawdzamy zawartość katalogu – jak widać pojawił się oryginalny plik

Podpis

Podpis dokumentu (pliku) tworzymy za pomocą naszego klucza prywatnego a sprawdzić go może każdy kto posiada powiązany z num klucz publiczny (po to są ogólnodostępne serwery kluczy publicznych)

1 – Janek wysyła dokument do Helgi ale tylko go podpisuje, prawym na pliku i opcja Sign, pojawia się znane już okno, w którym wybierany pozycję Sign i dodatkowo tym razem Text output.

W kolejnym oknie wybieramy jeden z naszych kluczy prywatnych (np. ten, który mamy przeznaczony do podpisu cyfrowego) oraz odznaczamy opcję Sign with S/MIME, klikamy w Sign podajemy hasło do klucza prywatnego Janka i gotowe.

2 – Po zakończeniu pojawia się plik poufne.txt.asc, który jest cyfrowym podpisem pliku poufne.txt.

W przypadku nie włączenia opcji Text output (ASCI armor) pojawi się plik binarny z rozszerzeniem .sig. Generalnie pliki tekstowe podpisów (ASCII armor) mają rozszerzenie .asc a binarne .sig. Oba pliki zródłowy i z podpisem cyfrowym Janet teraz musi posłać Heldze aby mogła dokonać weryfikacji. Podpis służy dwom celom: po pierwsze zapewni integralność dokumentu po drugie potwierdza, że nadawcą i autorem jest Janek (o tyle o ile można ufać kluczowi publicznemu ze na 100% jest własnością Janka).

Weryfikacja

Podpisany dokument weryfikuje się za pomocą publicznego klucza powiązanego z prywatnym, którym został on podpisany. Helga może więc przystąpić do weryfikacji podpisu dokumentu Janka.

1 – Przechodzimy do komputera Helgi i prawym na dokumencie (pliku) i wybieramy Verify oraz zatwierdzamy opcje z kolejnego okna

Input file: – plik na jakim Helga kliknęła czyli plik z sygnaturą podpisu
opcja Input file is a detached signature oznacza iż ten plik to oddzielna sygnatura względem pliku z dokumentem (sygnatura może być scalona z plikiem)
Signed data: – plik oryginalnego dokumentu

2 – Jeśli wszystko przebiegło bez problemów i dokument jest oryginalny bez zmian a podpis jest OK pojawia się informacja o poprawności podpisu i zgodności dokumentu wraz z informacją o ID klucza publicznego Janka.

3 – W przypadku kliknięcia na pliku dokumentu a nie podpisu

program automatycznie szuka plików z podpisami

i następnie je weryfikuje

4 – Jeśli Helga nie posiada klucza publicznego Janka pojawi się błąd mówiący o braku certyfikatu (klucza publicznego): osoby podpisującej dokument. Klucz taki można pobrać z publicznego serwera lub importować z pliku ale o tym w innym poście.

5 – W przypadku zmodyfikowania choć jednego bitu pliku z dokumentem otrzymujemy błąd weryfikacji:

Tak więc podsumowując wiedzę o kluczach można powiedzieć, że zazwyczaj przechowujemy wiele kluczy: publiczne osób z którymi się komunikujemy oraz parę (lub więcej par) kluczy prywatny + publiczny należących do nas. Szyfrujemy kluczami publicznymi osób docelowych, odszyfrowujemy naszym kluczem prywatnym, podpisujemy naszym prywatnym a sprawdzamy podpisy kluczami publicznymi osób,  które posyłają nam podpisane przez siebie dokumenty.

W tym poście to na tyle, zapraszam do czytania innych traktujących o obsłudze kluczy.