Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00177 008386 10461164 na godz. na dobę w sumie
Kryptografia w Javie. Od podstaw - książka
Kryptografia w Javie. Od podstaw - książka
Autor: Liczba stron: 512
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0277-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Stosuj algorytmy kryptograficzne w aplikacjach

W świecie, w którym najcenniejszym towarem jest informacja, kryptografia coraz bardziej zyskuje na znaczeniu. Cenne dane, przesyłane w sieci lub przechowywane w aplikacjach i bazach danych, muszą być chronione za pomocą skomplikowanych algorytmów szyfrowania i uwierzytelniania. Ponieważ próby włamań do serwerów internetowych zdarzają się regularnie, implementacja mechanizmów kryptograficznych w aplikacjach sieciowych i platformach handlu elektronicznego ma szczególnie wysoki priorytet. Java, wykorzystywana bardzo często do tworzenia takich właśnie rozwiązań, wyposażona została w zestaw interfejsów programistycznych (API), które pozwalają szybko i skutecznie wzbogacać aplikacje o obsługę kryptografii.

Książka 'Kryptografia w Javie. Podstawy' to podręcznik przedstawiający na praktycznych przykładach narzędzia kryptograficzne Javy. Opisuje podstawowe zasady ich używania, ułatwia zrozumienie zależności między poszczególnymi interfejsami API i uczy, jak w razie potrzeby korzystać z gotowych rozwiązań, by oszczędzić czas. Daje wiedzę niezbędną do implementowania technik kryptograficznych w aplikacjach bez niepotrzebnego komplikowania kodu źródłowego.

Twórz bezpieczne aplikacje,
wykorzystując nowoczesne mechanizmy kryptograficzne.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Kryptografia w Javie. Od podstaw Autor: David Hook T³umaczenie: Zbigniew Banach ISBN: 83-246-0277-1 Tytu³ orygina³u: Beginning Cryptography with Java Format: B5, stron: 512 Przyk³ady na ftp: 600 kB Stosuj algorytmy kryptograficzne w aplikacjach (cid:127) Poznaj architekturê interfejsów kryptograficznych Javy (cid:129) Zastosuj klucze symetryczne i asymetryczne (cid:129) Naucz siê zarz¹dzania certyfikatami w programach W œwiecie, w którym najcenniejszym towarem jest informacja, kryptografia coraz bardziej zyskuje na znaczeniu. Cenne dane, przesy³ane w sieci lub przechowywane w aplikacjach i bazach danych, musz¹ byæ chronione za pomoc¹ skomplikowanych algorytmów szyfrowania i uwierzytelniania. Poniewa¿ próby w³amañ do serwerów internetowych zdarzaj¹ siê regularnie, implementacja mechanizmów kryptograficznych w aplikacjach sieciowych i platformach handlu elektronicznego ma szczególnie wysoki priorytet. Java, wykorzystywana bardzo czêsto do tworzenia takich w³aœnie rozwi¹zañ, wyposa¿ona zosta³a w zestaw interfejsów programistycznych (API), które pozwalaj¹ szybko i skutecznie wzbogacaæ aplikacje o obs³ugê kryptografii. Ksi¹¿ka „Kryptografia w Javie. Podstawy” to podrêcznik przedstawiaj¹cy na praktycznych przyk³adach narzêdzia kryptograficzne Javy. Opisuje podstawowe zasady ich u¿ywania, u³atwia zrozumienie zale¿noœci miêdzy poszczególnymi interfejsami API i uczy, jak w razie potrzeby korzystaæ z gotowych rozwi¹zañ, by oszczêdziæ czas. Daje wiedzê niezbêdn¹ do implementowania technik kryptograficznych w aplikacjach bez niepotrzebnego komplikowania kodu Ÿród³owego. (cid:129) Architektura interfejsów JCA i JCE (cid:129) Szyfrowanie symetryczne (cid:129) Generowanie kluczy (cid:129) Stosowanie kluczy asymetrycznych (cid:129) Podpisy cyfrowe (cid:129) Obs³uga certyfikatów (cid:129) Szyfrowanie poczty elektronicznej Twórz bezpieczne aplikacje, wykorzystuj¹c nowoczesne mechanizmy kryptograficzne O autorze ....................................................................................................................................................13 Wstęp ..........................................................................................................................................................15 Rozdział 1. JCA i JCE ...................................................................................................................................21 Podstawowa architektura .............................................................................................. 21 Podpisywanie dostawców .............................................................................................. 24 Pliki polityki ograniczeń ................................................................................................ 25 Instalacja plików polityki nieograniczających siły algorytmów ....................................... 25 Rozwiązywanie innych problemów ............................................................................. 27 Skąd wiadomo, że pliki dostarczone przez firmę Sun naprawdę działają tak, jak powinny? .............................................. 28 Instalacja dostawcy Bouncy Castle ................................................................................ 28 Instalacja poprzez konfigurację środowiska uruchomieniowego ................................... 28 Instalacja na etapie wykonania ................................................................................ 31 Priorytety dostawców .................................................................................................... 31 Sprawdzanie możliwości dostawcy ................................................................................. 33 Podsumowanie ............................................................................................................ 34 Ćwiczenia .................................................................................................................... 35 Rozdział 2. Kryptografia z kluczem symetrycznym .............................................................................. 37 Pierwszy przykład ......................................................................................................... 38 Prosta klasa narzędziowa ........................................................................................ 38 Klasa SecretKeySpec .............................................................................................. 42 Klasa Cipher .......................................................................................................... 42 Dopełnienie w symetrycznych szyfrach blokowych ........................................................... 44 Dopełnienie PKCS #5/PKCS #7 ............................................................................... 44 Inne mechanizmy dopełnienia .................................................................................. 47 Tryby szyfrowania w symetrycznych szyfrach blokowych ................................................... 48 Tryb ECB ................................................................................................................ 48 Tryb CBC ................................................................................................................ 50 Słowo o obiektach parametrów szyfru ....................................................................... 58 Klasa AlgorithmParameters ..................................................................................... 58 Tryb CTS — specjalna odmiana CBC ........................................................................ 59 Tryby strumieniowe symetrycznych szyfrów blokowych ................................................ 59 6 Kryptografia w Javie. Od podstaw Symetryczne szyfry strumieniowe ................................................................................... 63 Generowanie losowych kluczy ....................................................................................... 65 Interfejs Key ........................................................................................................... 67 Klasa KeyGenerator ................................................................................................ 67 Szyfrowanie z hasłem ................................................................................................... 68 Podstawowe PBE .................................................................................................... 69 PBE w JCE .............................................................................................................. 70 Opakowywanie klucza ................................................................................................... 75 Szyfrowanie operacji wejścia-wyjścia .............................................................................. 78 Podsumowanie ............................................................................................................ 80 Ćwiczenia .................................................................................................................... 81 Rozdział 3. Skróty wiadomości, MAC i HMAC ......................................................................................... 83 Klasa narzędziowa ....................................................................................................... 84 Problem modyfikacji wiadomości ................................................................................... 86 Skróty wiadomości ....................................................................................................... 88 Klasa MessageDigest ............................................................................................. 90 Modyfikacja skrótu ....................................................................................................... 92 HMAC — MAC oparty na skrócie ................................................................................... 94 Klasa Mac .............................................................................................................. 97 Kody MAC oparte na szyfrach symetrycznych .................................................................. 98 Funkcje skrótu jako źródło danych pseudolosowych ...................................................... 100 Generowanie kluczy PBE ........................................................................................ 100 Generowanie maski .............................................................................................. 103 Operacje wejścia-wyjścia ze skrótami kryptograficznymi ................................................. 105 Podsumowanie .......................................................................................................... 107 Ćwiczenia .................................................................................................................. 108 Rozdział 4. Kryptografia asymetryczna ................................................................................................109 Klasa narzędziowa ..................................................................................................... 110 Interfejsy PublicKey i PrivateKey .................................................................................. 111 Algorytm RSA ............................................................................................................. 111 Klasa KeyFactory .................................................................................................. 114 Klasa RSAPublicKeySpec i interfejs RSAPublicKey ................................................... 115 Klasa RSAPrivateKeySpec i interfejs RSAPrivateKey ................................................. 115 Tworzenie losowych kluczy RSA .............................................................................. 115 Przyspieszanie pracy RSA ...................................................................................... 118 Mechanizmy dopełniania RSA ................................................................................ 120 Opakowywanie kluczy RSA ..................................................................................... 128 Wymiana kluczy tajnych .............................................................................................. 130 Uzgadnianie klucza .................................................................................................... 133 Algorytm Diffiego-Hellmana .................................................................................... 133 Diffie-Hellman bazujący na krzywych eliptycznych ..................................................... 137 Diffie-Hellman z wieloma stronami ......................................................................... 142 Algorytm El Gamala .................................................................................................... 144 Klasa AlgorithmParameterGenerator ....................................................................... 146 Podpisy cyfrowe ......................................................................................................... 148 Klasa Signature .................................................................................................... 149 Algorytm podpisu cyfrowego DSA ........................................................................... 150 Algorytmy podpisu oparte na RSA ........................................................................... 156 Podsumowanie .......................................................................................................... 160 Ćwiczenia .................................................................................................................. 161 Spis treści 7 Rozdział 5. Opis obiektów kryptograficznych w notacji ASN.1 ............................................................163 Czym jest ASN.1? ...................................................................................................... 163 Klasa narzędziowa ..................................................................................................... 164 Podstawowa składnia ASN.1 ....................................................................................... 165 Składnia komentarzy ............................................................................................. 165 Identyfikatory obiektów .......................................................................................... 165 Struktura modułu .................................................................................................. 166 Typy danych w ASN.1 ................................................................................................. 168 Typy proste .......................................................................................................... 169 Typy ciągów bitowych ............................................................................................ 170 Typy ciągów znakowych ......................................................................................... 170 Typy strukturalizowane .......................................................................................... 172 Adnotacje typów ................................................................................................... 172 Znaczniki ............................................................................................................. 173 Typ CHOICE .......................................................................................................... 177 Typ CLASS ........................................................................................................... 178 Reguły kodowania ...................................................................................................... 179 Kodowanie BER .................................................................................................... 179 Kodowanie DER .................................................................................................... 181 API ASN.1 w Bouncy Castle ........................................................................................ 182 Tworzenie podstawowych typów ASN.1 ................................................................... 183 Obsługa znaczników .............................................................................................. 185 Definiowanie własnych obiektów ............................................................................ 186 Analiza nieznanego zakodowanego obiektu ............................................................. 192 Prawdziwe przykłady wykorzystania ASN.1 w Javie ......................................................... 194 Podstawowe struktury ASN.1 ................................................................................. 194 Kodowanie IV ....................................................................................................... 195 Budowa podpisu PKCS #1 V1.5 ............................................................................. 196 Kodowanie parametrów podpisu PSS ..................................................................... 199 Kodowanie kluczy publicznych i prywatnych ............................................................. 201 Podsumowanie .......................................................................................................... 212 Ćwiczenia .................................................................................................................. 213 Rozdział 6. Nazwy wyróżniające i certyfikaty ......................................................................................215 Klasa narzędziowa ..................................................................................................... 216 Nazwy wyróżniające .................................................................................................... 216 Klasa X500Principal .............................................................................................. 218 Certyfikaty klucza publicznego ..................................................................................... 219 Klasa Certificate ................................................................................................... 220 Certyfikaty X.509 ....................................................................................................... 221 Klasa X509Certificate ........................................................................................... 221 Rozszerzenia X.509 .............................................................................................. 229 Interfejs X509Extension ........................................................................................ 230 Rozszerzenia obsługiwane bezpośrednio przez klasę X509Certificate ........................ 231 Odczyt i zapis certyfikatów .......................................................................................... 238 Klasa CertificateFactory ........................................................................................ 238 Żądania certyfikacyjne ................................................................................................ 242 Tworzenie prostego centrum certyfikacji ....................................................................... 248 8 Kryptografia w Javie. Od podstaw Ścieżki i składy certyfikatów ........................................................................................ 253 Klasa CertPath ..................................................................................................... 254 Klasa CertStore .................................................................................................... 256 Klasa X509CertSelector ........................................................................................ 257 Podsumowanie .......................................................................................................... 259 Ćwiczenia .................................................................................................................. 260 Rozdział 7. Unieważnianie certyfikatów i walidacja ścieżek ...............................................................261 Klasa narzędziowa ..................................................................................................... 262 Listy unieważnionych certyfikatów ................................................................................ 265 Klasa CRL ............................................................................................................ 265 Listy unieważnionych certyfikatów X.509 ...................................................................... 266 Klasa X509CRL .................................................................................................... 267 Klasa X509CRLEntry ............................................................................................. 271 Rozszerzenia wpisów list CRL X.509 ...................................................................... 272 Rozszerzenia list CRL X.509 .................................................................................. 273 Pobieranie list CRL za pomocą klasy CertificateFactory ............................................ 278 Klasa X509CRLSelector ........................................................................................ 281 Protokół OCSP — weryfikacja statusu certyfikatów w czasie rzeczywistym ....................... 283 Klasa CertificateID ................................................................................................ 284 Klasa OCSPReq .................................................................................................... 285 Rozszerzenia żądań OCSP ..................................................................................... 288 Klasa OCSPResp .................................................................................................. 292 Klasa BasicOCSPResp .......................................................................................... 293 Rozszerzenia odpowiedzi OCSP .............................................................................. 295 Walidacja ścieżek certyfikatów .................................................................................... 301 Klasa TrustAnchor ................................................................................................ 301 Klasa PKIXParameters .......................................................................................... 302 Klasa CertPathValidator ........................................................................................ 304 Klasa PKIXCertPathValidatorResult ........................................................................ 305 Klasa PKIXCertPathChecker ................................................................................... 308 Budowanie poprawnej ścieżki na podstawie składu CertStore ........................................ 313 Klasa CertPathBuilder ........................................................................................... 313 PKIXBuilderParameters ......................................................................................... 313 Podsumowanie .......................................................................................................... 316 Ćwiczenia .................................................................................................................. 317 Rozdział 8. Zarządzanie kluczami i certyfikatami ................................................................................319 Klasa narzędziowa ..................................................................................................... 320 Klasa KeyStore .......................................................................................................... 321 Rodzaje repozytoriów ............................................................................................ 322 Podstawowe API klasy KeyStore ............................................................................. 323 Zagnieżdżone klasy i interfejsy klasy KeyStore .............................................................. 330 Interfejs KeyStore.ProtectionParameter .................................................................. 330 Interfejs KeyStore.Entry ......................................................................................... 331 Klasa KeyStore.Builder ......................................................................................... 335 Interfejs KeyStore.LoadStoreParameter .................................................................. 338 Format PKCS #12 ...................................................................................................... 338 Korzystanie z plików PKCS #12 w API KeyStore ....................................................... 341 Spis treści 9 Program keytool ......................................................................................................... 345 Polecenia programu keytool ................................................................................... 345 Repozytorium certyfikatów maszyny wirtualnej ......................................................... 349 Eksperymentowanie z programem keytool ............................................................... 349 Podpisywanie archiwów JAR i pliki polityki bezpieczeństwa Javy ..................................... 353 Narzędzie jarsigner ............................................................................................... 354 Pliki polityki bezpieczeństwa Javy ........................................................................... 354 Podsumowanie .......................................................................................................... 355 Ćwiczenia .................................................................................................................. 356 Rozdział 9. CMS i S/MIME .......................................................................................................................357 Klasa narzędziowa ..................................................................................................... 357 Standard CMS ........................................................................................................... 360 Podstawy CMS ..................................................................................................... 361 Typ Data .............................................................................................................. 361 Interfejs CMSProcessable ..................................................................................... 362 Podpisane dane CMS ................................................................................................. 363 Struktura ASN.1 ................................................................................................... 363 Klasa SignerInformation ........................................................................................ 368 Klasa SignerInformationStore ................................................................................ 370 Klasa CMSSignedData .......................................................................................... 370 Koperty cyfrowe CMS ................................................................................................. 376 Struktura ASN.1 ................................................................................................... 376 Klasa RecipientInformation .................................................................................... 379 Klasa KeyTransRecipientInformation ...................................................................... 380 Klasa RecipientInformationStore ............................................................................ 381 Klasa CMSEnvelopedData ..................................................................................... 381 Klasa KEKRecipientInformation .............................................................................. 386 Kompresja danych w CMS .......................................................................................... 389 Struktura ASN.1 ................................................................................................... 389 Klasa CMSCompressedData .................................................................................. 390 Protokół S/MIME ....................................................................................................... 391 Klasa CMSProcessableBodyPart ............................................................................ 392 Klasa SMIMEUtil ................................................................................................... 392 Podpisane wiadomości S/MIME .................................................................................. 393 Klasa CMSProcessableBodyPartInbound ................................................................ 394 Klasa CMSProcessableBodyPartOutbound .............................................................. 394 Klasa SMIMESigned ............................................................................................. 394 Koperty cyfrowe S/MIME ............................................................................................ 399 Klasa SMIMEEnveloped ........................................................................................ 400 Łączenie podpisywania z szyfrowaniem ................................................................... 402 Kompresowane wiadomości S/MIME ........................................................................... 407 Klasa SMIMECompressed ..................................................................................... 407 Podsumowanie .......................................................................................................... 409 Ćwiczenia .................................................................................................................. 409 Rozdział 10. Protokoły SSL i TLS ...............................................................................................................411 Protokoły SSL i TLS .................................................................................................... 411 Klasa narzędziowa ..................................................................................................... 413 Prosty klient i serwer SSL ........................................................................................... 415 Klasa SSLSocketFactory ........................................................................................ 416 Klasa SSLServerSocketFactory .............................................................................. 417 10 Kryptografia w Javie. Od podstaw Klasa SSLSocket .................................................................................................. 417 Klasa SSLServerSocket ......................................................................................... 419 Interfejs HandshakeCompletedListener .................................................................. 424 Uwierzytelnianie klienta .............................................................................................. 425 Konfiguracja klasy SSLServerSocket ...................................................................... 426 Konfiguracja klasy SSLSocket w trybie serwerowym ................................................. 426 Klasa SSLContext ................................................................................................. 427 Klasa KeyManagerFactory ..................................................................................... 429 Klasa TrustManagerFactory ................................................................................... 434 Zarządzanie danymi sesji SSL ..................................................................................... 437 Interfejs SSLSession ............................................................................................ 438 Obsługa protokołu HTTPS ........................................................................................... 443 Klasa HttpsURLConnection .................................................................................... 444 Interfejs HostnameVerifier ..................................................................................... 446 Podsumowanie .......................................................................................................... 451 Ćwiczenia .................................................................................................................. 451 Dodatek A Rozwiązania ćwiczeń ............................................................................................................453 Rozwiązania do rozdziału 1. ........................................................................................ 453 Rozwiązania do rozdziału 2. ........................................................................................ 454 Rozwiązania do rozdziału 3. ........................................................................................ 454 Rozwiązania do rozdziału 4. ........................................................................................ 455 Rozwiązania do rozdziału 5. ........................................................................................ 456 Rozwiązania do rozdziału 6. ........................................................................................ 458 Rozwiązania do rozdziału 7. ........................................................................................ 459 Rozwiązania do rozdziału 8. ........................................................................................ 460 Rozwiązania do rozdziału 9. ........................................................................................ 463 Rozwiązania do rozdziału 10. ...................................................................................... 466 Dodatek B Algorytmy obsługiwane przez dostawcę Bouncy Castle ...................................................467 Szyfry asymetryczne ................................................................................................... 467 Walidacja ścieżek certyfikatów .................................................................................... 467 Algorytmy uzgadniania klucza ...................................................................................... 468 Repozytoria kluczy i certyfikatów .................................................................................. 468 Algorytmy MAC ........................................................................................................... 468 Algorytmy podpisu ...................................................................................................... 468 Skróty wiadomości ..................................................................................................... 468 Symetryczne szyfry blokowe ........................................................................................ 469 Symetryczne szyfry strumieniowe ................................................................................. 470 Dodatek C Krzywe eliptyczne w Bouncy Castle ....................................................................................471 Interfejsy obsługi krzywych eliptycznych ........................................................................ 471 Interfejs ECKey ..................................................................................................... 472 Interfejs ECPrivateKey ........................................................................................... 472 Interfejs ECPublicKey ............................................................................................ 472 Interfejs ECPointEncoder ....................................................................................... 472 Klasy obsługi krzywych eliptycznych ............................................................................. 472 Klasa ECNamedCurveParameterSpec ..................................................................... 473 Klasa ECNamedCurveSpec .................................................................................... 473 Klasa ECParameterSpec ....................................................................................... 473 Klasa ECPrivateKeySpec ....................................................................................... 474 Klasa ECPublicKeySpec ......................................................................................... 474 Spis treści 11 Dodatek D Bibliografia i dodatkowe zasoby ..........................................................................................475 Standardy ASN.1 ....................................................................................................... 475 Strony grup roboczych IETF ......................................................................................... 476 Publikacje NIST .......................................................................................................... 476 Standardy PKCS ........................................................................................................ 477 Dokumenty RFC ......................................................................................................... 477 Inne przydatne standardy ............................................................................................ 479 Przydatna literatura .................................................................................................... 479 Przydatne adresy internetowe ...................................................................................... 479 Skorowidz ...............................................................................................................................................481 Podstawowy problem związany z używaniem szyfrów, kodów MAC i kodów HMAC z kluczem symetrycznym polega na bezpiecznym dostarczeniu tajnego klucza do odbiorcy, by mógł on odszyfrować otrzymaną wiadomość. Jednego z rozwiązań tego problemu do- starcza kryptografia asymetryczna. Nazwa pochodzi stąd, że do szyfrowania i deszyfrowania używane są różne klucze, najczęściej nazywane kluczem publicznym i prywatnym. W tym rozdziale poznamy podstawy kryptografii asymetrycznej, w tym możliwości wyko- rzystania kluczy publicznych i prywatnych do wymiany kluczy tajnych i do generowania podpisów cyfrowych. Istnieje wiele różnych rodzajów algorytmów asymetrycznych, więc przyjrzymy się również parametrom wymaganym do utworzenia klucza oraz odpowiednim mechanizmom dopełnienia podczas szyfrowania wiadomości. W przeciwieństwie do algo- rytmów symetrycznych algorytmy asymetryczne nie są najlepsze do szyfrowania dużych ilości danych, stąd też zajmiemy się metodami łączenia obu rodzajów szyfrowania, by ten cel osiągnąć. Pod koniec tego rozdziału powinieneś: n znać i rozumieć najpopularniejsze obecnie algorytmy, n rozumieć metody wymiany i uzgadniania klucza, jak również najważniejsze ich wady i zalety, n rozumieć zasady używania mechanizmów dopełnienia z algorytmami asymetrycznymi, n umieć tworzyć i weryfikować podpisy cyfrowe. Poznasz też w praktyce różne API Javy wspomagające generowanie, modyfikację i stoso- wanie kluczy i szyfrów asymetrycznych. 110 Kryptografia w Javie. Od podstaw W tym rozdziale zostanie wykorzystana wersja klasy Utils rozszerzona o implementację SecureRanSec zwracającą przewidywalne wyniki. Z kryptograficznego punktu widzenia może się to wydać szaleństwem, ale bardzo ułatwi korzystanie z przykładów w tym roz- dziale, gdyż będzie możliwe uzyskanie dokładnie takich wyników, jak w książce. Oto kod klasy: package rozdzial4; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; /** * Klasa narzędziowa dla przykładów z rozdziału 4. */ public class ptils extends rozdziale.ptils { private static class FixedRand extends SecureRandom { MessageDigest sha; byte[] state; FixedRand() { try { this.sha = MessageDigest.getInstance( SHA-1 ); this.state = sha.digest(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException( nie znaleziono SHA-1! ); } } public void nextBytes(byte[] bytes) { int off = 0; sha.update(state); while (off bytes.length) { state = sha.digest(); if (bytes.length - off state.length) { System.arraycopy(state, 0, bytes, off, state.length); } else { System.arraycopy(state, 0, bytes, off, bytes.length - off); } Rozdział 4. n Kryptografia asymetryczna 111 off += state.length; sha.update(state); } } } /** * Zwraca obiekt SecureRandom generujący stałą wartość. * b Wyłącznie do celów testowych! /b * @return stała wartość losowa */ public static SecureRandom createFixedRandom() { return new FixedRand(); } } Jak widać, wykorzystany tu pomysł opiera się na użyciu skrótu wiadomości do wygenero- wania pseudolosowego strumienia bajtów. Przepisz tę wersję klasy Utils, skompiluj ją jako pierwszą klasę pakietu rezSzial4 i możesz zaczynać. Omówienie kryptografii asymetrycznej w Javie nie obejdzie się bez dwóch interfejsów: java.security.PublicKey i java.security.PrivateKey. Każdy klucz wykorzystywany pod- czas szyfrowania asymetrycznego będzie implementował jeden z tych interfejsów, stąd też często pojawiają się one jako typy obiektów zwracanych przez wszelkiego rodzaju klasy operujące na kluczach i danych klucza. Same interfejsy bezpośrednio rozszerzają interfejs java.security.Key, ale nie wprowadzają żadnych własnych metod — jedynym powodem ich istnienia jest zapewnienie bezpieczeń- stwa typów. Uzasadnienie takiego stanu rzeczy poznamy podczas szczegółowego omawia- nia poszczególnych algorytmów. Większość algorytmów ma własne zestawy interfejsów obsługi klucza, gdyż w przeciwieństwie do algorytmów klucza symetrycznego, które moż- na stosować w zasadzie zamiennie, każdy algorytm asymetryczny różni się od pozostałych nie tylko sposobem działania, ale i parametrami potrzebnymi do utworzenia klucza. Na początek zajmiemy się zwykłym szyfrowaniem danych, ale w dalszej części rozdziału zobaczymy, że kryptografia asymetryczna stanowi też podstawę mechanizmów uzgadniania klucza i podpisów cyfrowych. Algorytm RSA został opublikowany w 1977 roku przez Ronalda Rivesta, Adi Shamira i Le- onarda Adlemana. Odtajnione w ostatnich latach dokumenty ujawniły, że metodę używaną w RSA odkrył jeszcze w 1973 roku Clifford Cocks z brytyjskiego GCHQ. 112 Kryptografia w Javie. Od podstaw Podstawą bezpieczeństwa algorytmu jest trudność rozkładu dużych liczb na czynniki pierw- sze (faktoryzacji). Mechanizm polega na tym, że klucze publiczny i prywatny są funkcjami pary dużych liczb pierwszych, a odtworzenie tekstu jawnego na podstawie znajomości szy- frogramu i klucza publicznego, którym został zaszyfrowany, jest uważane za zadanie o trudności porównywalnej z zadaniem ustalenia liczb pierwszych, na podstawie których wygenerowano klucze. Istotną kwestią jest wymagana długość klucza. Klucze w przykła- dach zostały tak dobrane, by było je łatwo wpisać, a wynik ich użycia mieścił się w jednym wierszu, więc nie mają one nic wspólnego z bezpieczeństwem. W praktyce klucz powinien mieć długość co najmniej 1024 bitów, a jeśli tworzona aplikacja ma chronić wiadomości przez więcej niż 10 lat, to długość tę należy podwoić. Wyprowadzenie pełnego algorytmu znacznie wykracza poza ramy tej książki, ale samą ideę działania można wyrazić bardzo prosto. Niech p i q będą liczbami pierwszymi, a n, e i d będą liczbami takimi, że: n = pq oraz ed ≡ 1mod((p - 1)(q - 1)) Dla danej wiadomości m mamy wtedy: c = m m = c e mod n d mod n gdzie c jest szyfrogramem. Liczby n, e i d mają też dłuższe nazwy — są to odpowiednio moduł, wykładnik publiczny i wykładnik prywatny. Ogólną zasadą jest taki dobór wartości wykładnika publicznego, by etap szyfrowania był mało kosztowny obliczeniowo, po czym wykładnik prywatny jest generowany zgodnie z powyższym wzorem. Długość wygenero- wanego klucza RSA jest określana długością n, więc każda z liczb p i q musi mieć długość połowy klucza. Przed skorzystaniem z algorytmu należy się upewnić, że każdą szyfrowaną wiadomość da się zapisać w postaci dużej, dodatniej liczby całkowitej, nieprzekraczającej n. Na szczęście nie jest to trudne. W Javie wystarczy stworzyć dodatni obiekt BigInteger na podstawie bajtów składających się na wiadomość. Cały czas korzystamy z JCE, więc nigdy nie będziemy musieli samodzielnie zamieniać wiadomości na obiekt BigInteger. Trzeba jednak mieć świadomość, że taka właśnie opera- cja odbywa się za kulisami, gdyż ma ona wpływ na bezpieczne stosowanie algorytmu RSA. Wspomniałem na przykład, że liczbowa reprezentacja wiadomości m musi być arytmetycznie mniejsza od liczby n. Powodem takiego wymagania jest to, że obliczenia w ramach algo- rytmu RSA odbywają się modulo n, czyli wymagają dzielenia przez n i przyjmowania reszty z tego dzielenia jako wyniku. Oznacza to, że każda wartość większa od n zostanie podczas szyfrowania zredukowana do mod n. Nieco później zobaczymy, jak można sobie z tym ograniczeniem poradzić i szyfrować długie wiadomości szyfrem RSA, ale na razie wy- starczy pamiętać, że działanie algorytmu opiera się na arytmetyce dużych liczb całkowitych. Rozdział 4. n Kryptografia asymetryczna 113 Spróbuj sam: Podstawowe RSA Na początek spróbuj uruchomić poniższy przykład. Wprowadza on podstawowe klasy ob- sługujące algorytm RSA i pokazuje, że JCE pozwala nadal korzystać z jednolitego API, nie- zależnie od tego, że faktyczna implementacja RSA diametralnie różni się od wcześniej po- znanych algorytmów. Długość klucza wynosi 128 bitów, czyli zaledwie jedną ósmą minimalnej wymaganej długości, ale dla potrzeb przykładu to w zupełności wystarczy. package rozdzial4; import java.math.BigInteger; import java.security.KeyFactory; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security.spec.RSAPrivateKeySpec; import java.security.spec.RSAPublicKeySpec; import javax.crypto.iipher; /** * Podstawowy przykład RSA. */ public class BaseRSAExample { public static void main(String[] args) throws Exception { byte[] input = new byte[] { (byte)0xbe, (byte)0xef }; iipher cipher = iipher.getInstance( RSA/None/NoPadding , Bi ); KeyFactory keyFactory = KeyFactory.getInstance( RSA , Bi ); // tworzenie kluczy RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec( new BigInteger( d46f47ea2d7465e7de2056aee092c451 , 16), new BigInteger( 11 , 16)); RSAPrivateKeySpec privKeySpec = new RSAPrivateKeySpec( new BigInteger( d46f47ea2d7465e7de2056aee092c451 , 16), new BigInteger( 57791d54e0d59e1640820e6ad8b29fb1 , 16)); RSAPublicKey pubKey = (RSAPublicKey)keyFactory.generatePublic(pubKeySpec); RSAPrivateKey privKey = (RSAPrivateKey)keyFactory.generatePrivate(privKeySpec); System.out.println( dane wejściowe: + ptils.toHex(input)); // szyfrowanie cipher.init(iipher.ENiR PciMhDE, pubKey); byte[] ciphercext = cipher.doFinal(input); System.out.println( dane zaszyfrowane: + ptils.toHex(ciphercext)); // deszyfrowanie cipher.init(iipher.DEiR PciMhDE, privKey); byte[] plaincext = cipher.doFinal(ciphercext); 114 Kryptografia w Javie. Od podstaw System.out.println( dane odszyfrowane: + ptils.toHex(plaincext)); } } Uruchomienie przykładu powinno dać następujący wynik: dane wejściowe: beef dane zaszyfrowane: d2db158e8f6c1c98702c5d54fe0add42 dane odszyfrowane: beef Jak to działa Sposób użycia klasy Cipher nie różni się tu specjalnie od przykładów z wcześniejszych rozdziałów. Różnica polega jedynie na tym, że klasy reprezentujące wartość klucza oraz interfejsy odpowiadające samym kluczom są bardziej wyspecjalizowane — już z samych ich nazw wynika, że są one przeznaczone dla RSA. Poszczególne klasy opisujące klucz omówię szczegółowo nieco później, ale z kodu widać, że inicjalizacja szyfru RSA wymaga zdefiniowania obiektów wartości zawierających liczby odpowiadające kluczowi publicznemu i prywatnemu. Obiekty te są następnie przekształcane w klucze i przekazywane obiektowi szyfru za pośrednictwem klasy fabrykującej obsługują- cej klucze asymetryczne — klasy KeyFactery. Potem wszystko postępuje zgodnie ze zna- nymi już zasadami. Przyjrzyjmy się zatem bliżej klasie KeyFactery, pamiętając, że jest ona abstrakcją, więc wszystko, co powiemy na jej temat, odnosi się do wszystkich algorytmów asymetrycznych. Klasa KeyFactory Klasa java.security.KeyFactery stanowi warstwę abstrakcji pozwalającą zamieniać obiekty parametrów klucza utworzone poza środowiskiem danego dostawcy na obiekty Key, jak również konwertować już istniejące klucze na specyfikacje nadające się do eksportu. Po- dobnie jak klasa Cipher, KeyFactery używa metody fabrykującej getInstance(), która w kwestii lokalizacji i priorytetów dostawców zachowuje się dokładnie tak samo, jak ana- logiczne metody innych klas JCA. Klasa KeyFactery udostępnia cztery metody konwersji. Metody generatePublic() i generate- Private() konwertują specyfikacje klucza na obiekty reprezentujące klucz, getKeySpec() pozwala tworzyć i eksportować parametry klucza, a metoda translateKey() przekształca klucze jednego dostawcy do postaci nadającej się do użytku z innym dostawcą. Z punktu widzenia poprzedniego przykładu najciekawsze są metody generatePublic() i generatePrivate(). Jak widać z kodu, służą one do zamiany obiektów zawierających pa- rametry kluczy RSA na faktyczne obiekty klucza, wypada zatem bliżej przyjrzeć się klasom parametrów kluczy i interfejsom do obsługi kluczy. Rozdział 4. n Kryptografia asymetryczna 115 Klasa RSAPublicKeySpec i interfejs RSAPublicKey Jak sugeruje końcówka nazwy, klasa RSAPublicKeySpec pozwala tworzyć obiekty wartości zawierające parametry niezbędne do wygenerowania klucza publicznego RSA, czyli moduł i wykładnik publiczny. Przekazując obiekt RSAPublicKeySpec metodzie KeyFactery.generatePublic(), można uzy- skać obiekt implementujący PublicKey. Ponieważ chodzi o szyfr RSA, klasa KeyFactery zwróci w tym przypadku obiekt implementujący RSAPublicKey o takich samych sygnatu- rach metod, co klasa RSAPublicKeySpec. Istnieje też metoda getMeSulus() zwracająca obiekt BigInteger odpowiadający modułowi oraz metoda getPublicgepenent() zwracająca analo- giczny obiekt dla wykładnika publicznego. Klasa RSAPrivateKeySpec i interfejs RSAPrivateKey Klasa RSAPrivateKeySpec pozwala tworzyć obiekty wartości zawierające parametry niezbędne do wygenerowania klucza prywatnego RSA, czyli moduł i wykładnik prywatny. Działanie klasy opisującej klucz oraz interfejsu RSAPrivateKey stanowi odzwierciedlenie działania ich odpowiedników do tworzenia obiektów klucza publicznego, z tą tylko różnicą, że w miejsce metody getPublicgepenent() wywoływana jest metoda getPrivategepenent(). Symetria klas, metod i interfejsów nie powinna tu dziwić, gdyż wynika bezpośrednio z sy- metrii samego algorytmu RSA. Tworzenie losowych kluczy RSA Zamiast podawać gotowe dane dla klucza, można go też wygenerować losowo. Z opisu działa- nia algorytmów asymetrycznych wiemy, że potrzebne są dwa klucze: publiczny i prywatny. Oznacza to, że zamiast klasy KeyGenerater generującej pojedynczy obiekt Key trzeba będzie skorzystać z klasy KeyPairGenerater, generującej parę kluczy w postaci obiektu KeyPair. Szczegółowym omówieniem tych klas zajmiemy się już niebawem, ale najlepiej zapoznać się z nimi na praktycznym przykładzie. Spróbuj sam: Generowanie losowych kluczy RSA Spróbuj uruchomić poniższy przykład. Generuje on parę kluczy RSA na podstawie loso- wych danych, szyfruje prostą wiadomość pobranym z tej pary kluczem publicznym, a na- stępnie deszyfruje szyfrogram pobranym z pary kluczem prywatnym. package rozdzial4; import java.security.Key; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.SecureRandom; 116 Kryptografia w Javie. Od podstaw import javax.crypto.iipher; /** * Przykład RSA z losowym generowaniem klucza. */ public class RandomKeyRSAExample { public static void main(String[] args) throws Exception { byte[] input = new byte[] { (byte)0xbe, (byte)0xef }; iipher cipher = iipher.getInstance( RSA/NhNE/NoPadding , Bi ); SecureRandom random = ptils.createFixedRandom(); // generowanie kluczy KeyPairGenerator generator = KeyPairGenerator.getInstance( RSA , Bi ); generator.initialize(256, random); KeyPair pair = generator.generateKeyPair(); Key pubKey = pair.getPublic(); Key privKey = pair.getPrivate(); System.out.println( dane wejściowe: + ptils.toHex(input)); // szyfrowanie cipher.init(iipher.ENiR PciMhDE, pubKey, random); byte[] ciphercext = cipher.doFinal(input); System.out.println( dane zaszyfrowane: + ptils.toHex(ciphercext)); // deszyfrowanie cipher.init(iipher.DEiR PciMhDE, privKey); byte[] plaincext = cipher.doFinal(ciphercext); System.out.println( dane odszyfrowane: + ptils.toHex(plaincext)); } } Uruchomienie przykładu daje następujący wynik: dane wejściowe: beef dane zaszyfrowane: 8274caf4a1f54beb58f6798755d2cfceeeeef710aef520865c0ccdca0a672601 dane odszyfrowane: beef Jak widać, długość szyfrogramu rośnie wraz z długością klucza. Choć w tym przykładzie wykorzystany został klucz o długości zaledwie 256 bitów (czyli jednej czwartej długości klucza dla aplikacji produkcyjnej), to i tak wyraźnie widać, że zastosowanie RSA spowo- dowało znaczne wydłużenie pierwotnej 4-bajtowej wiadomości. W przypadku RSA nie ma żadnego odpowiednika trybu CRT, więc trzeba się pogodzić z tym efektem jako ceną tej metody szyfrowania. Rozdział 4. n Kryptografia asymetryczna 117 Jak to działa Podobnie jak we wcześniejszym programie BaseRSAgeacple, kod wygląda tu bardzo podob- nie do kodów z rozdziału 2. Jedyną znaczącą różnicą jest wprowadzenie obiektów KeyPair i KeyPairGenerater, gdyż mamy tym razem do czynienia z szyfrem asymetrycznym. Do zrozumienia przykładu wystarczy zrozumienie działania klas biorących udział w genero- waniu klucza publicznego i prywatnego. Klasa KeyPair Klasa java.security.KeyPair stanowi pojemnik dla klucza prywatnego i odpowiadającego mu klucza publicznego. Obiekt KeyPair jest prostym obiektem wartości udostępniającym metody getPrivate() i getPublic(), zwracające odpowiednio klucz prywatny i klucz pu- bliczny. Klasa KeyPairGenerator Instancje klasy java.security.KeyPairGenerater są pobierane za pomocą typowej metody fabrykującej getInstance(), której zachowanie w kwestii wyboru i priorytetu dostawcy usług jest identyczne, jak w przypadku metod getInstance() innych poznanych już klas JCA. Obsługa samej klasy jest bardzo prosta. Dostępne są cztery wersje metody initialize(): dwie przyjmujące liczbę całkowitą określającą długość klucza (z czego jedna wymaga do- datkowo przekazania źródła danych losowych) i dwie przyjmujące pełniący tę samą funkcję obiekt AlgerithcParaceterSpec. Jak się okaże w dalszych przykładach, najwięcej możliwości daje wykorzystanie wersji przyjmujących obiekty AlgerithcParaceterSpec, gdyż w przy- padku algorytmów asymetrycznych długość klucza jest tylko jednym z wielu możliwych parametrów, których wartości przydaje się kontrolować. Pozostają już tylko metody zwracające generowany przez klasę obiekt pary kluczy: KeyPair- Generater.generateKeyPair() i KeyPairGenerater.genKeyPair(). Metody te działają iden- tycznie, a różnią się wyłącznie nazwą, więc wybór jednej z nich zależy wyłącznie od uznania programisty. Istnieje też właściwa algorytmowi RSA klasa implementująca AlgerithcParaceterSpec — jest to RSAKeyGenParaceterSpec. Klasa ta jest bardzo prosta, więc przyjrzyjmy jej się od razu. Klasa RSAKeyGenParameterSpec Jak już wspomniałem, generowanie par kluczy RSA wiąże się najczęściej z wybraniem wykładnika publicznego i wygenerowaniem dla niego odpowiedniego wykładnika prywat- nego. JCA pozwala określić zarówno pożądaną długość klucza, jak i wykładnik publiczny dla pary kluczy generowanej za pomocą obiektu KeyPairGenerater — wystarczy przekazać metodzie KeyPairGenerater.initialize() odpowiedni parametr w postaci obiektu implemen- tującego AlgerithcParaceterSpec. Powinien to być obiekt klasy java.security.spec.RSA- KeyGenParaceterSpec, która pojawiła się w JDK 1.3. Stworzenie takiego obiektu jest bardzo proste i wymaga jedynie podania w konstruktorze wykładnika publicznego i długości klucza. 118 Kryptografia w Javie. Od podstaw Biorąc konkretny przykład, wykorzystanie jednego ze standardowych wykładników pu- blicznych w postaci zalecanej w standardzie X.509 wartości F4 (w przypadku dostawcy Bouncy Castle jest to wartość domyślna) wymagałoby zamiany wywołania metody initialize() obiektu generater na: generator.initialize( new RSAKeyGenParameterSpec(256, RSAKeyGenParameterSpec.F4), random); Po takiej inicjalizacji wszystkie klucze publiczne RSA generowane przez obiekt generater będą miały wykładnik publiczny o wartości odpowiadającej stałej F4, czyli liczbie całko- witej 0x10001. Przyspieszanie pracy RSA Wystarczy rzut oka na pierwszy przykład algorytmu RSA, by stwierdzić, że wykładnik prywatny klucza prywatnego jest znacznie większy od wykładnika publicznego. Z tego też względu korzystanie z klucza prywatnego RSA jest znacznie wolniejsze od korzystania z klucza publicznego. Zachowanie to można łatwo uzasadnić — dzięki niemu szyfrowanie danych jest szybkie i można je wykonywać na klientach o ograniczonej mocy obliczeniowej. Jak się wkrótce przekonamy, dodatkową zaletą jest szybkie sprawdzanie podpisów cyfrowych. Czy da się przyspieszyć proces deszyfrowania kluczem prywatnym? Okazuje się, że tak. Wymaga to wprawdzie wykorzystania znajomości liczb użytych do stworzenia modułu, a te powinny raczej być utrzymywane w tajemnicy, ale skoro wszelkie informacje o wykładni- ku prywatnym i tak powinny być tajne, to dołożenie jeszcze kilku tajnych danych nie po- winno być wielkim problemem. Znajomość wykorzystanych liczb pierwszych jest tu konieczna, gdyż pozwala wykorzystać w praktyce chińskie twierdzenie o resztach (ang. Chinese Re- mainder Theorem, CRT). Chińskie twierdzenie o resztach Odkryte w pierwszym wieku naszej ery przez chińskiego matematyka Sun Tsu twierdzenie o resztach w uproszczeniu głosi, że: „Dla liczby n o rozkładzie na liczby pierwsze p1 * p2 * … * pi układ kongruencji postaci: (x mod pj) ≡ aj, j = 1, 2,…, i ma dokładnie jedno rozwiązanie modulo n”. Ujmując to samo nieco inaczej, dowolną liczbę mniejszą od n można jednoznacznie wyra- zić jako ciąg reszt z dzielenia jej przez kolejne czynniki pierwsze n. Nie będę się zagłębiał w matematyczny dowód prawdziwości tego twierdzenia, gdyż jest on podany w wielu innych publikacjach, ale najważniejszym następstwem praktycznym jest to, że obliczenia dotyczące wykładnika prywatnego można wykonywać inaczej niż obliczenia dla wykładnika publicznego. Obliczenia takie odbywają się na liczbach całkowitych znacz- nie mniejszych od modułu, dzięki czemu są dużo szybsze. Z tego właśnie względu przed- stawione poniżej klasy RSAPrivateCrtKey i RSAPrivateCrtKeySpec mają metody do pobiera- nia nie dwóch, lecz ośmiu wartości. Klasy RSAPrivateCrtKeySpec i RSAPrivateCrtKey Rozdział 4. n Kryptografia asymetryczna 119 Klasa java.security.spec.RSAPrivateCrtKeySpec dostarcza obiektów wartości zawierają- cych dane klucza dla klucza prywatnego RSA, które można wykorzystać zgodnie z CRT. Obiekt RSAPrivateCrtKeySpec można przekazać obiektowi KeyFactery dla RSA w dokładnie taki sam sposób, jak opisany wcześniej obiekt RSAPrivateKeySpec. Klasa fabrykująca powinna zwrócić obiekt klucza implementujący interfejs java.security.interjaces.RSA- PrivateCrtKey, który z kolei rozszerza RSAPrivateKey. Jeśli mimo przekazania RSAPrivate- CrtKeySpec zwracany jest klucz implementujący jedynie sam RSAPrivateKey, to używany dostawca prawdopodobnie nie implementuje CRT. To samo może być powodem powolne- go wykonywania operacji RSA z kluczem prywatnym. RSAPrivateCrtKeySpec i RSAPrivateCrtKey mają identyczne metody. Dostępne metody po- zwalają pobierać poszczególne wartości składające się na klucz CRT: n n n n getMeSulus() zwraca wartość modułu n, getPrivategepenent() zwraca wartość prywatnego wykładnika d, getPriceP() zwraca wartość liczby pierwszej p, getPriceQ() zwraca wartość liczby pierwszej q. Poza tym dostępne są jeszcze metody getPricegepenentP(), getPricegepenentQ() i getCrt- Ceejjicient() zwracające wstępnie wyliczone wartości bazujące na p i q, których wykorzy- stanie pozwala dodatkowo przyspieszyć wykonywanie obliczeń z kluczem prywatnym RSA. W przypadku dostawcy Bouncy Castle obiekty RSAPrivateCrtKey są zwracane przez imple- mentację klasy KeyPairGenerater, ale można się samodzielnie przekonać o znacznym kosz- cie operacji na kluczu publicznym bez wykorzystania CRT, tworząc własną implementację klasy RSAPrivateKeySpec, pobierającą potrzebne wartości z obiektu RSAPrivateCrtKey. Chińskie twierdzenie o resztach z wieloma liczbami pierwszymi Z podanego wcześniej opisu CRT wynika, że twierdzenie opiera się na swobodnym dostę- pie do liczb pierwszych stanowiących czynniki modułu. Co ciekawe, ani w CRT, ani w al- gorytmie RSA nigdzie nie jest powiedziane, że takie liczby muszą być akurat dwie — można równie dobrze wziąć na przykład cztery. Gdyby więc pracować z kluczem 2048-bitowym, to zamiast wykonywać obliczenia dla generowania i używania klucza na dwóch liczbach 1024-bitowych, można by te same operacje wykonywać na czterech liczbach 512-bitowych. Niezależnie od dodatkowych trudności wynikających z obecności więcej niż dwóch czyn- ników w procesie generowania modułu operacje na kluczu prywatnym w wersji z czterema liczbami pierwszymi będą znacznie szybsze od tych samych operacji dla wersji z dwiema liczbami. Tę metodę obliczeń obsługuje interfejs java.security.interjaces.RSAMultiPricePrivate- CrtKey oraz klasy java.security.spec.RSAMultiPricePrivateCrtKeySpec i java.security. åspec.RSAOtherPriceInje. W tej książce nie będę tej techniki omawiał, gdyż obecnie nie ma jej implementacji w dostawcy Bouncy Castle, a sam algorytm jest opatentowany. Jeśli 120 Kryptografia w Javie. Od podstaw jednak chcesz się dowiedzieć więcej, to polecam zapoznanie się z dokumentacją i dotyczą- cym między innymi tego zagadnienia standardem PKCS #1 firmy RSA Security. Zawarte tam informacje stanowią naturalne rozwinięcie przedstawionego wyżej opisu CRT. W ten sposób kończymy omawianie zasad działania samego algorytmu RSA. Pora zająć się mechanizmami służącymi do przekształcenia bajtów szyfrowanej wiadomości w dużą liczbę całkowitą, którą można następnie wprowadzić na wejście tego algorytmu. Mechanizmy dopełniania RSA Największą różnicę między RSA a zwykłym szyfrem symetrycznym można zobaczyć, za- stępując w ostatnim przykładzie wiersz: byte[] input = new byte[] { (byte)0xbe, (byte)0xef }; wierszem: byte[] input = new byte[] { 0x00, (byte)0xbe, (byte)0xef }; Po wprowadzeniu tej zmiany wynik działania programu wygląda tak: dane wejściowe: 00beef dane zaszyfrowane: 8274caf4a1f54beb58f6798755d2cfceeeeef710aef520865c0ccdca0a672601 dane odszyfrowane: beef Zwracają tu uwagę dwie rzeczy. Najbardziej oczywiste jest to, że dane odszyfrowane różnią się od danych wejściowych — zniknęło początkowe zero. Nietrudno też zauważyć, że po- mimo innych danych wejściowych szyfrogram jest ten sam, co poprzednio. W pewnym sensie może to tłumaczyć brak początkowego zera w tekście odszyfrowanym, ale nadal nie wiadomo, dlaczego zero zostało usunięte przed szyfrowaniem. Czyżby błąd algorytmu RSA, a przynajmniej jego implementacji? Na szczęście zarówno algorytm, jak i jego implementacja działają bez zarzutu. W części poświęconej opisowi działania algorytmu RSA dowiedzieliśmy się, że przetworzenie tablicy bajtów przekazywanej jako dane wejściowe algorytmu wymaga jej zamiany na dużą liczbę całkowitą. Początkowe zera giną właśnie na etapie konwersji —w świecie liczb początkowe zera nie mają znaczenia. Oczywiście w naszym przypadku zera początkowe mają znaczenie, więc przydałby się me- chanizm dopełnienia, który pozwoliłby je zachować. Dopełnienie ma też znacznie ważniejsze zadanie od zachowywania początkowych zer. Spróbuj zmienić przykład tak, by wykładni- kiem publicznym był F0 (wartość 0x3), a nie F4 (wartość 0x
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Kryptografia w Javie. Od podstaw
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: