streamalism.org

Most jelentettem be az újat Tanulj tavaszt tanfolyam, amelynek középpontjában az 5. tavasz és a tavaszi bakancs 2 alapjai állnak:

1. Áttekintés

A nyilvános kulcsú titkosításban (más néven aszimmetrikus kriptográfia) a titkosítási mechanizmus két kapcsolódó kulcsra támaszkodik, egy nyilvános és egy magánkulcsra. A nyilvános kulcs az üzenet titkosítására szolgál, míg az üzenetet csak a privát kulcs tulajdonosa tudja visszafejteni.

Ebben az oktatóanyagban azt fogjuk megtudni, hogyan lehet nyilvános és privát kulcsokat olvasni egy PEM fájlból.

Először néhány fontos fogalmat tanulmányozunk a nyilvános kulcsú titkosítás körül. Ezután megtanuljuk, hogyan kell olvasni a PEM fájlokat tiszta Java használatával.

Végül alternatív megközelítésként megvizsgáljuk a BouncyCastle könyvtárat.

2. Fogalmak

Mielőtt elkezdenénk, értsünk meg néhány kulcsfogalmat.

Az X.509 a nyilvános kulcsú tanúsítványok formátumát meghatározó szabvány. Tehát ez a formátum egy nyilvános kulcsot ír le más információk mellett.

DER a legnépszerűbb kódolási formátum olyan adatok tárolására, mint az X.509 tanúsítványok, a PKCS8 magánkulcsok fájlokban. Ez egy bináris kódolás, és a kapott tartalom nem tekinthető meg szövegszerkesztővel.

PKCS8 egy szabványos szintaxis a magánkulcs információk tárolásához. A privát kulcs opcionálisan titkosítható szimmetrikus algoritmus segítségével.

Ez a szabvány nemcsak az RSA magánkulcsokat, hanem más algoritmusokat is képes kezelni. A PKCS8 magánkulcsokat általában a PEM kódolási formátumon keresztül cserélik.

PEM a DER tanúsítvány alap-64 kódolási mechanizmusa. A PEM más típusú adatokat is kódolhat, például nyilvános / magánkulcsokat és tanúsítványkéréseket.

A PEM fájl tartalmaz egy fejlécet és egy láblécet is, amely leírja a kódolt adatok típusát:

----- KÖZBETTEK KEZDÉSE ----- ... A DER kódolt tanúsítvány Base64 kódolása ... ----- KÖZBETÉT VÉGE -----

3. A Pure Java használata

3.1. Olvassa el a PEM-adatokat egy fájlból

Kezdjük azzal, hogy elolvassuk a PEM fájlt, és tartalmát egy karakterláncba tároljuk:

String kulcs = új karakterlánc (Files.readAllBytes (file.toPath ()), Charset.defaultCharset ());

3.2. Nyissa meg a PEM karakterlánc nyilvános kulcsát

Olyan segédprogram-módszert fogunk létrehozni, amely a PEM kódolt karaktersorozatból kapja meg a nyilvános kulcsot:

----- BEGIN NYILVÁNOSKULCS ----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsjtGIk8SxD + OEiBpP2 / T JUAF0upwuKGMk6wH8Rwov88VvzJrVm2NCticTk5FUg + UG5r8JArrV4tJPRHQyvqK wF4NiksuvOjv3HyIf4oaOhZjT8hDne1Bfv + cFqZJ61Gk0MjANh / T5q9vxER / 7TdU NHKpoRV + NVlKN5bEU / NQ5FQjVXicfswxh6Y6fl2PIFqT2CfjD + FkBPU1iT9qyJYH A38IRvwNtcitFgCeZwdGPoxiPPh1WHY8VxpUVBv / 2JsUtrB / rAIbGqZoxAIWvijJ Pe9o1TY3VlOzk9ASZ1AeatvOir + iDVJ5OpKmLnzc46QgGPUsjIyo6Sje9dxpGtoG QQIDAQAB ----- END KÖZKULCS -----

Tegyük fel, hogy kapunk egy File paraméterként:

public static RSAPublicKey readPublicKey (File file) dobja a Kivételt {String key = new String (Files.readAllBytes (file.toPath ()), Charset.defaultCharset ()); String publicKeyPEM = kulcs .replace ("----- BEGIN PUBLIC KEY -----", "") .replaceAll (System.lineSeparator (), "") .replace ("----- END PUBLIC KEY ----- "," "); byte [] kódolt = Base64.decodeBase64 (publicKeyPEM); KeyFactory keyFactory = KeyFactory.getInstance ("RSA"); X509EncodedKeySpec keySpec = új X509EncodedKeySpec (kódolt); return (RSAPublicKey) keyFactory.generatePublic (keySpec); }

Mint láthatjuk, először el kell távolítanunk a fejlécet, a láblécet és az új vonalakat is. Ezután dekódolnunk kell a Base64 kódolású karakterláncot a megfelelő bináris formátumra.

Ezután be kell töltenünk az eredményt egy kulcs specifikációs osztályba, amely képes kezelni egy nyilvános kulcs anyagát. Esetünkben a X509EncodedKeySpec osztály.

Végül létrehozhatunk egy nyilvános kulcs objektumot a specifikációból a KeyFactory osztály.

3.3. Szerezzen privát kulcsot a PEM karakterláncból

Most, hogy tudjuk, hogyan kell nyilvános kulcsot olvasni, a magánkulcs olvasásának algoritmusa nagyon hasonló.

PK kódolt titkos kulcsot fogunk használni PKCS8 formátumban. Lássuk, milyen a fejléc és a lábléc:

----- BEVIN PRIVATE KEY ----- ... Base64 kódolású kulcs ... ----- END PRIVATE KEY -----

Mint korábban megtudtuk, szükségünk van egy osztályra, amely képes kezelni a PKCS8 kulcsanyagot. A PKCS8EncodedKeySpec osztály tölti be ezt a szerepet.

Lássuk tehát az algoritmust:

public RSAPrivateKey readPrivateKey (Fájl fájl) dobja a Kivételt {String kulcs = új karakterlánc (Files.readAllBytes (file.toPath ()), Charset.defaultCharset ()); String privateKeyPEM = kulcs .replace ("----- BEGIN PRIVATE KEY -----", "") .replaceAll (System.lineSeparator (), "") .replace ("----- END PRIVATE KEY ----- "," "); byte [] kódolt = Base64.decodeBase64 (privateKeyPEM); KeyFactory keyFactory = KeyFactory.getInstance ("RSA"); PKCS8EncodedKeySpec keySpec = új PKCS8EncodedKeySpec (kódolt); return (RSAPrivateKey) keyFactory.generatePrivate (keySpec); }

4. A BouncyCastle Library használata

4.1. Olvassa el a nyilvános kulcsot

Felfedezzük a BouncyCastle könyvtárat, és megtudjuk, hogyan lehet a tiszta Java megvalósítás alternatívájaként használni.

Szerezzük meg a nyilvános kulcsot:

public RSAPublicKey readPublicKey (fájl fájl) a Kivételt dobja {KeyFactory gyár = KeyFactory.getInstance ("RSA"); try (FileReader keyReader = new FileReader (fájl); PemReader pemReader = új PemReader (keyReader)) {PemObject pemObject = pemReader.readPemObject (); bájt [] tartalom = pemObject.getContent (); X509EncodedKeySpec pubKeySpec = új X509EncodedKeySpec (tartalom); return (RSAPublicKey) gyár.generatePublic (pubKeySpec); }}

Van néhány fontos osztály, amelyekkel tisztában kell lennünk a BouncyCastle használatakor:

• PemReader - veszi a Olvasó paraméterként és elemzi annak tartalmát. Eltávolítja a felesleges fejléceket és dekódolja az alapul szolgáló Base64 PEM adatokat bináris formátumra.
• PemObject – tárolja a PemReader.

Sőt, nézzünk meg egy másik megközelítést, amely beburkolja a Java osztályait (X509EncodedKeySpec, KeyFactory) a BouncyCastle saját osztályába (JcaPEMKeyConverter):

public RSAPublicKey readPublicKeySecondApproach (File file) dobja az IOException {try (FileReader keyReader = new FileReader (file)) {PEMParser pemParser = new PEMParser (keyReader); JcaPEMKeyConverter átalakító = új JcaPEMKeyConverter (); SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfo.getInstance (pemParser.readObject ()); return (RSAPublicKey) converter.getPublicKey (publicKeyInfo); }}

4.2. Olvassa el a privát kulcsot

Két példát fogunk látni, amelyek nagyon hasonlítanak a fentiekhez.

Az első példában csak le kell cserélnünk a X509EncodedKeySpec osztály a PKCS8EncodedKeySpec osztály és vissza egy RSAPrivateKey objektum helyett RSAPublicKey:

public RSAPrivateKey readPrivateKey (fájl fájl) dobja a Kivételt {KeyFactory gyár = KeyFactory.getInstance ("RSA"); try (FileReader keyReader = new FileReader (fájl); PemReader pemReader = új PemReader (keyReader)) {PemObject pemObject = pemReader.readPemObject (); bájt [] tartalom = pemObject.getContent (); PKCS8EncodedKeySpec privKeySpec = új PKCS8EncodedKeySpec (tartalom); return (RSAPrivateKey) factory.generatePrivate (privKeySpec); }}

Most dolgozzuk át egy kicsit az előző szakasz második megközelítését a privát kulcs elolvasása érdekében:

public RSAPrivateKey readPrivateKeySecondApproach (File file) az IOException-t dobja {try (FileReader keyReader = new FileReader (file)) {PEMParser pemParser = new PEMParser (keyReader); JcaPEMKeyConverter átalakító = új JcaPEMKeyConverter (); PrivateKeyInfo privateKeyInfo = PrivateKeyInfo.getInstance (pemParser.readObject ()); return (RSAPrivateKey) converter.getPrivateKey (privateKeyInfo); }}

Mint láthatjuk, csak kicseréltük SubjectPublicKeyInfo val vel PrivateKeyInfo és RSAPublicKey val vel RSAPrivateKey.

4.3. Előnyök

Van néhány előnye a BouncyCastle könyvtárnak.

Az egyik előny az nem kell manuálisan kihagynunk vagy eltávolítanunk a fejlécet és a láblécet. Egy másik az nem vagyunk felelősek az Base64 dekódolásáért bármelyik. Ezért kevesebb hibára hajlamos kódot írhatunk a BouncyCastle segítségével.

Sőt, a A BouncyCastle könyvtár támogatja a PKCS1 formátumot is. Annak ellenére, hogy a PKCS1 a kriptográfiai kulcsok (csak RSA kulcsok) tárolására is használt népszerű formátum, a Java önmagában nem támogatja.

5. Következtetés

Ebben a cikkben megtanultuk, hogyan kell nyilvános és privát kulcsokat olvasni a PEM fájlokból.

Először néhány kulcsfogalmat tanulmányoztunk a nyilvános kulcsú titkosítás körül. Aztán láttuk, hogyan lehet tiszta és Java segítségével olvasni a nyilvános és a magánkulcsokat.

Végül felfedeztük a BouncyCastle könyvtárat, és megtudtuk, hogy ez egy jó alternatíva, mivel néhány előnyt nyújt a tiszta Java megvalósításhoz képest.

A Java és a BouncyCastle megközelítések teljes forráskódja elérhető a GitHubon.

Most jelentettem be az újat Tanulj tavaszt tanfolyam, amelynek középpontjában az 5. tavasz és a tavaszi bakancs 2 alapjai állnak: