ארכיטקטורת קריפטוגרפיה של Java: היכרות ראשונה

אבטחת חילופי נתונים היא אחד המאפיינים החשובים ביותר של יישומים מודרניים. מאז ימי קדם, אנשים הגיעו עם שיטות ערמומיות, שעם התפתחות האנושות הפכו לכל מדע הקריפטוגרפיה. באופן טבעי, ג'אווה לא עמדה בצד והציעה למפתחים את ארכיטקטורת ה-Java Cryptography Architecture (JCA). סקירה זו אמורה לתת מושג ראשון כיצד זה עובד.

הַקדָמָה

אני מציע לנסוע אחורה בזמן. לפנינו רומא העתיקה. ולפנינו גאיוס יוליוס קיסר, ששולח מסר למפקדיו. בוא נראה מה יש בהודעה הזו: מה זה יכול להיות אומר: "ЕСКЕУГЬГМХИФЯ Е УЛП"? בואו נפתח את Java Online Compiler, למשל: repl.it

class Main {
  public static void main(String[] args) {
    String code = "ЕСКЕУГЬГМХИФЯ Е УЛП";
    for (char symbol : code.toCharArray()) {
      if (symbol != ' ') {
        symbol = (char) (symbol - 3);
      }
      System.out.print(symbol);
    }
  }
}

לפנינו היישום הפשוט ביותר של צופן קיסר. על פי עבודתו של ההיסטוריון הרומי הקדום סואטוניוס בשם "חיי שנים עשר הקיסרים", כך בדיוק הצפין קיסר הודעות לגנרלים שלו. וזו אחת ההתייחסויות העתיקות ביותר לשימוש בדבר כזה כמו קריפטוגרפיה . המילה "קריפטוגרפיה" באה מהמילים היווניות העתיקות "נסתר" ו"כתוב", כלומר. זה המדע של טכניקות פרטיות. ל-Java יש תמיכה משלה בקריפטוגרפיה והיא נקראת Java Cryptography Architecture (JCA). את התיאור ניתן למצוא בתיעוד הרשמי של אורקל - " Java Cryptography Architecture (JCA) ". אני מציע לך לבדוק אילו הזדמנויות אנו מקבלים הודות ל-JCA.

J.C.A.

כפי שלמדנו בעבר, Java מציעה את ארכיטקטורת הקריפטוגרפיה של Java (JCA) לעבודה עם קריפטוגרפיה. ארכיטקטורה זו מכילה API (כלומר קבוצה מסוימת של ממשקים) וספקים (שמיישמים אותם): כפי שאומר התיעוד, " פלטפורמת Java כוללת מספר ספקים מובנים ". כלומר, פלטפורמת Java מספקת קבוצה של ספקים מובנים אותם ניתן להרחיב במידת הצורך. אתה יכול לראות את זה בעצמך:

import java.security.Provider;
import java.security.Security;
class Main {
  public static void main(String[] args) {
    Provider[] providers = Security.getProviders();
    for (Provider p : providers) {
      System.out.println(p.getName());
    }
  }
}

רישום ספק צד שלישי הוא קל מאוד. לדוגמה: Security.addProvider(new BouncyCastleProvider()); דוגמה זו מחברת את אחד הספקים המפורסמים ביותר - BouncyCastle . אבל בסקירה זו נשתמש רק בכלים בסיסיים, ללא ספריות של צד שלישי. המסמך הראשי שלנו: " ארכיטקטורת ג'אווה קריפטוגרפיה (JCA) ". הבנה כיצד פועלת JCA תעזור לך להבין ביתר קלות את הטכנולוגיות שבהן נעשה שימוש פעיל באותו JCA. לדוגמה: HTTPS (ראה " מ-HTTP ל-HTTPS ").

MessageDigest

הדבר הראשון שהוזכר בתיעוד JCA הוא MessageDigest. באופן כללי, Digest ברוסית יהיה זהה - תקציר תואם במשמעותו ל"סיכום". אבל בהצפנה, תקציר הוא סכום חשיש. אפשר גם לזכור בקלות שבאנגלית Digest יכול להיות מתורגם גם כ-digest. פרטים נוספים ניתן למצוא בתיעוד JCA בסעיף " MessageDigest ". כפי שאומר התיעוד, MessageDigest מייצר תוצאה בגודל קבוע שנקראת digest או hash. Hashing היא פונקציה חד-כיוונית, כלומר. אם גיבשנו משהו, אז מהתוצאה (כלומר מה-hash) לא נוכל לקבל את המקור המקורי. אבל אם אובייקטים זהים עוברים גיבוב (לדוגמה, מחרוזות של תווים זהים), אז הגיבוב שלהם חייב להתאים. כפי שצוין בתיעוד, חשיש כזה נקרא לפעמים גם "צ'ק-סום" או "טביעת אצבע דיגיטלית" של נתונים. ניתן לבצע גיבוב באמצעות אלגוריתמים שונים. ניתן לראות אלגוריתמים זמינים במסמך " תיעוד שם האלגוריתם הסטנדרטי של Java Cryptography Architecture עבור JDK 8 ". בוא נעשה את הגיבוב ונדפיס את הגיבוב לקונסולה:

import javax.xml.bind.DatatypeConverter;
import java.security.*;
public class Main {
  public static void main(String[] args) {
    try {
      MessageDigest digester = MessageDigest.getInstance("SHA-512");
      byte[] input = "Secret string".getBytes();
      byte[] digest = digester.digest(input);
      System.out.println(DatatypeConverter.printHexBinary(digest));
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException(e);
    }
  }
}

Hashing יכול להיות שימושי, למשל, בעת אחסון סיסמאות. מכיוון שניתן לבדוק את ה-hash של הסיסמה שהוזנה מול hash שנשמר בעבר. אם ה-hashs תואמים, אז גם הסיסמה תואמת. לגיבוב מאובטח עוד יותר, נעשה שימוש במושג שנקרא "מלח". ניתן ליישם את המלח באמצעות המחלקה SecureRandom . לפני ביצוע שיטת העיכול, בואו נתאר הוספת "מלח":

byte[] salt = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(salt);
digester.update(salt);

אבל חשיש הוא פונקציה חד-כיוונית. אבל מה אם אתה רוצה להיות מסוגל להצפין ולפענח?

קריפטוגרפיה של מפתח סימטרי

הצפנה סימטרית היא הצפנה המשתמשת באותו מפתח להצפנה ולפענוח. על מנת להשתמש בהצפנה סימטרית אנו זקוקים למפתח. כדי להשיג זאת אנו משתמשים ב- KeyGenerator . בנוסף, נצטרך מחלקה שמייצגת צופן ( Cipher ). כפי שצוין בתיעוד JCA בסעיף " יצירת אובייקט צופן ", כדי ליצור צופן אתה צריך לציין לא רק אלגוריתם, אלא "טרנספורמציה" בשורה. תיאור הטרנספורמציה נראה כך: "אלגוריתם/מצב/ריפוד":

• אלגוריתם : כאן אנו מסתכלים על השמות הסטנדרטיים עבור " אלגוריתמים של צופן (הצפנה) . מומלץ להשתמש ב-AES.
• מצב : מצב הצפנה. לדוגמה: ECB או CBC (נדבר על זה קצת מאוחר יותר)
• הזחה/פיצול : כל בלוק נתונים מוצפן בנפרד. פרמטר זה קובע כמה נתונים ייספרו כגוש אחד.

לדוגמה, קח את השינוי הבא: "AES/ECB/PKCS5Padding". כלומר, אלגוריתם ההצפנה הוא AES, מצב ההצפנה הוא ECB (קיצור של Electronic Codebook), גודל הבלוק הוא PKCS5Padding. PKCS5Padding אומר שהגודל של בלוק אחד הוא 2 בתים (16 סיביות). מצב ההצפנה של ספר קודים אלקטרוני כולל הצפנה רציפה של כל בלוק: זה עשוי להיראות כך בקוד:

import javax.xml.bind.DatatypeConverter;
import javax.crypto.*;
import java.security.Key;
public class Main {
  public static void main(String[] args) throws Exception {
    String text = "secret!!secret!!secret!!secret!!";
    // Generate new key
    KeyGenerator keygen = KeyGenerator.getInstance("AES");
    keygen.init(256);
    Key key = keygen.generateKey();
    // Encrypt with key
    String transformation = "AES/ECB/PKCS5Padding";
    Cipher cipher = Cipher.getInstance(transformation);
    cipher.init(Cipher.ENCRYPT_MODE, key);
    byte[] encrypted = cipher.doFinal(text.getBytes());
    System.out.println(DatatypeConverter.printHexBinary(encrypted));
    // Decrypt with key
    cipher.init(Cipher.DECRYPT_MODE, key);
    String result = new String(cipher.doFinal(encrypted));
    System.out.println(result);
  }
}

אם נבצע, נצפה לראות חזרה, כי ציינו 32 תווים. התווים האלה מרכיבים 2 בלוקים של 16 סיביות: כדי להימנע מהשמעה חוזרת במקרה זה, עליך להשתמש במצב אחר - Cipher Block Chaining (CBC). מצב זה מציג את הרעיון של אתחול וקטור (מיוצג על ידי המחלקה IvParameterSpec). וגם הודות למצב הזה, התוצאה של יצירת הבלוק האחרון תשמש ליצירת הבא: בוא נכתוב את זה בקוד:

import javax.xml.bind.DatatypeConverter;
import javax.crypto.*;
import java.security.*;
import javax.crypto.spec.IvParameterSpec;
public class Main {
  public static void main(String[] args) throws Exception {
    // Initialization Vector
    SecureRandom random = SecureRandom.getInstanceStrong();
    byte[] rnd = new byte[16];
    random.nextBytes(rnd);
    IvParameterSpec ivSpec = new IvParameterSpec(rnd);
    // Prepare key
    KeyGenerator keygen = KeyGenerator.getInstance("AES");
    keygen.init(256);
    Key key = keygen.generateKey();
    // CBC
    String text = "secret!!secret!!secret!!secret!!";
    String transformation = "AES/CBC/PKCS5Padding";
    Cipher cipher = Cipher.getInstance(transformation);
    cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
    byte[] enc = cipher.doFinal(text.getBytes());
    System.out.println(DatatypeConverter.printHexBinary(enc));
    // Decrypt
    cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
    String result = new String(cipher.doFinal(enc));
    System.out.println(result);
  }
}

כפי שאנו רואים, כתוצאה מכך איננו רואים בלוקי צופן חוזרים. מסיבה זו, מצב ECB אינו מומלץ, כי מאפשר לראות חזרות ולהשתמש בידע הזה לפענוח. למידע נוסף על ECB ו-CBC, אני ממליץ לך לקרוא את החומר: " מצב ספר קודים אלקטרוני ". אבל להצפנה סימטרית יש בעיה ברורה - אתה צריך איכשהו להעביר את המפתח ממי שמצפין לזה שמצפין. ולאורך הנתיב הזה אפשר ליירט את המפתח הזה ואז יהיה אפשר ליירט נתונים. והצפנה אסימטרית נועדה לפתור בעיה זו.

הצפנה אסימטרית

הצפנה אסימטרית או קריפטוגרפיה של מפתח ציבורי היא שיטת הצפנה המשתמשת בזוג מפתחות: מפתח פרטי (שנשמר בסוד מכולם) ומפתח ציבורי (זמין לציבור). הפרדה זו נחוצה על מנת להחליף בצורה מאובטחת את המפתח הציבורי בין הצדדים לחילופי המידע, תוך שמירה על המפתח הסודי. כשיוצרים זוג מפתחות, KeyGenerator כבר לא מספיק לנו; אנחנו צריכים KeyPairGenerator . בואו נסתכל על דוגמה:

import javax.crypto.*;
import java.security.*;
public class Main {
  public static void main(String[] args) throws Exception {
    KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
    generator.initialize(1024);
    KeyPair keyPair = generator.generateKeyPair();
    // Encrypt with PRIVATE KEY
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
    byte[] data = cipher.doFinal("Hello!".getBytes());
    // Decrypt with PUBLIC KEY
    cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
    byte[] result = cipher.doFinal(data);
    System.out.println(new String(result));
  }
}

חשוב להבין כאן שכאשר משתמשים בהצפנה אסימטרית, אנו תמיד משתמשים ב-KeyPair כדי להשתמש במפתח אחד להצפנה ובאחר לפענוח. אלא בגלל נקודת ההצפנה היא שרק הנמען יכול לפענח אותה; היא מוצפנת עם מפתח ציבורי, ומפענחת רק עם מפתח פרטי.

חתימה דיגיטלית

כפי שראינו למעלה, בהכרת המפתח הציבורי, ניתן לשלוח נתונים כך שרק הבעלים של המפתח הפרטי יוכל לפענח אותם. כלומר, המהות של הצפנה אסימטרית היא שכל אחד מצפין, אבל רק אנחנו קוראים. ישנו גם הליך הפוך - חתימה דיגיטלית, המיוצגת על ידי המחלקה Signature . חתימה דיגיטלית יכולה להשתמש באלגוריתמים הבאים: " אלגוריתמי חתימה ". תיעוד JCA מציע להסתכל מקרוב על שני אלה: DSAwithMD5 ו-RSAwithMD5 מה טוב יותר מ-DSA או RSA ומה ההבדל ביניהם תוכלו לקרוא כאן: " איזה עובד הכי טוב עבור העברות קבצים מוצפנות - RSA או DSA? ". או קרא את הדיונים כאן: " RSA לעומת DSA עבור מפתחות אימות SSH ". אז, חתימה דיגיטלית. נצטרך, כמו קודם, KeyPair ומחלקת Signature חדשה. אם בדקתם עד כה במהדרים מקוונים, הדוגמה הבאה עשויה להיות מעט קשה עבורם. הדוגמה שלי רצה רק כאן: rextester.com . אנו מייבאים את השיעורים שאנו צריכים:

import javax.crypto.*;
import java.security.*;

אנו גם נשכתב את השיטה העיקרית:

public static void main(String[] args) throws Exception {
    // Generate keys
    KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
    SecureRandom random = SecureRandom.getInstanceStrong();
    generator.initialize(2048, random);
    KeyPair keyPair = generator.generateKeyPair();
    // Digital Signature
    Signature dsa = Signature.getInstance("SHA256withRSA");
    dsa.initSign(keyPair.getPrivate());
    // Update and sign the data
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
    byte[] data = cipher.doFinal("Hello!".getBytes());
    dsa.update(data);
    byte[] signature = dsa.sign();
    // Verify signature
    dsa.initVerify(keyPair.getPublic());
    dsa.update(data);
    boolean verifies = dsa.verify(signature);
    System.out.println("Signature is ok: " + verifies);
    // Decrypt if signature is correct
    if (verifies) {
      cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
      byte[] result = cipher.doFinal(data);
      System.out.println(new String(result));
    }
}

כך עובדת חתימה דיגיטלית. חתימה דיגיטלית היא נושא מעניין. אני ממליץ לך לעיין בדוח בנושא זה:

לעיל ראינו כיצד הצדדים מחליפים נתונים. האם אין ממשק סטנדרטי לאינטראקציה הזו מסופק ב-JCA? מסתבר שיש. בואו נסתכל על זה.

הסכם מפתח

ה-Java Cryptography Architecture מציגה כלי חשוב - הסכם מפתח הוא פרוטוקול. הוא מיוצג על ידי מחלקת KeyAgreement . כפי שצוין בתיעוד JCA, פרוטוקול זה מאפשר למספר צדדים להגדיר את אותו מפתח קריפטוגרפי מבלי לשתף מידע סודי כלשהו בין הצדדים. נשמע מוזר? אז בואו נסתכל על דוגמה:

// 1. Одна из сторон (Алиса) генерирует пару ключей. Encoded публичный ключ отдаёт.
KeyPairGenerator generator = KeyPairGenerator.getInstance("DH");
KeyPair aliceKeyPair = generator.generateKeyPair();
byte[] alicePubKeyEncoded = aliceKeyPair.getPublic().getEncoded();

// 2. Другая сторона (например, Боб) получает открытый ключ Алисы
KeyFactory bobKeyFactory = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(alicePubKeyEncoded);
PublicKey alicePubKey = bobKeyFactory.generatePublic(x509KeySpec);
// Параметры, которые использовала Алиса при генерации ключей
DHParameterSpec dhParamFromAlicePubKey = ((DHPublicKey)alicePubKey).getParams();
// Создаёт свою пару ключей. Отдаёт свой Encoded открытый ключ
KeyPairGenerator bobKpairGen = KeyPairGenerator.getInstance("DH");
bobKpairGen.initialize(dhParamFromAlicePubKey);
KeyPair bobKeyPair = bobKpairGen.generateKeyPair();
byte[] bobPubKeyEncoded = bobKeyPair.getPublic().getEncoded();

Теперь, у Алисы есть открытый ключ Боба, а у Боба есть открытый ключ Алисы. What дальше?
Как сказано в documentации JCA, у нас есть инструмент KeyAgreement, https://docs.oracle.com/javase/8/docs/technotes/guides/security/crypto/CryptoSpec.html#KeyAgreement который позволяет установить одинаковые ключи шифрования без необходимости обмениваться секретной информацией (т.е. без обмена private key). Соглашение выглядит следующим образом:
// 3. Соглашение по протоколу Диффи-Хеллмана (Diffie–Hellman, DH)
KeyAgreement aliceKeyAgree = KeyAgreement.getInstance("DH");
aliceKeyAgree.init(aliceKeyPair.getPrivate());
// Алиса на основе ключа боба и своего private key создаёт общий shared ключ
KeyFactory aliceKeyFactory = KeyFactory.getInstance("DH");
x509KeySpec = new X509EncodedKeySpec(bobPubKeyEncoded);
PublicKey bobPubKey = aliceKeyFactory.generatePublic(x509KeySpec);
aliceKeyAgree.doPhase(bobPubKey, true);
byte[] aliceSharedSecret = aliceKeyAgree.generateSecret();
SecretKeySpec aliceAesKey = new SecretKeySpec(aliceSharedSecret, 0, 16, "AES");
// Боб на основе ключа Алисы и своего private key создаёт общий shared ключ
KeyAgreement bobKeyAgree = KeyAgreement.getInstance("DH");
bobKeyAgree.init(bobKeyPair.getPrivate());
bobKeyAgree.doPhase(alicePubKey, true);
byte[] bobSharedSecret = bobKeyAgree.generateSecret();
SecretKeySpec bobAesKey = new SecretKeySpec(bobSharedSecret, 0, 16, "AES");
// Общий ключ у Алисы и Боба одинаков
System.out.println("Shared keys are equals: " + Arrays.equals(aliceSharedSecret, bobSharedSecret));

Далее Боб и Алиса, используя общий ключ, про который больше никто не знает, обмениваются зашифрованными данными:
// 4. Боб шифрует сообщение для Алисы
Cipher bobCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
bobCipher.init(Cipher.ENCRYPT_MODE, bobAesKey);
byte[] ciphertext = bobCipher.doFinal("Hello, Alice!".getBytes());
// Передаёт Алисе параметры, с которыми выполнялась шифровка
byte[] encodedParamsFromBob = bobCipher.getParameters().getEncoded();

// 5. Алиса принимает сообщение и расшифровывает его
AlgorithmParameters aesParams = AlgorithmParameters.getInstance("AES");
aesParams.init(encodedParamsFromBob);
Cipher aliceCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
aliceCipher.init(Cipher.DECRYPT_MODE, aliceAesKey, aesParams);
byte[] recovered = aliceCipher.doFinal(ciphertext);
System.out.println(new String(recovered));

דוגמה זו נלקחה מדוגמא התיעוד של JCA: " חילופי מפתחות דיפי-הלמן בין 2 צדדים ". כך נראית בערך הצפנה א-סימטרית בארכיטקטורת ה-Java Cryptography באמצעות פרוטוקול Key Agreement. למידע נוסף על הצפנה אסימטרית, סרטונים מומלצים:

• הצפנה אסימטרית. איך זה עובד?
• שיעור 10 פרוטוקול דיפי-הלמן

תעודות

ובכן, לקינוח יש לנו עדיין משהו לא פחות חשוב - תעודות. בדרך כלל, אישורים נוצרים באמצעות כלי השירות keytool הכלול ב-jdk. אתה יכול לקרוא פרטים נוספים, למשל, כאן: " יצירת תעודת SSL בחתימה עצמית באמצעות פקודת Java keytool ". אתה יכול גם לקרוא את המדריכים של אורקל. לדוגמה, כאן: " כדי להשתמש בכלי מפתח ליצירת אישור שרת ". לדוגמה, בואו נשתמש ב- Tutorialspoint Java Online Compiler :

import sun.security.tools.keytool.CertAndKeyGen;
import sun.security.x509.*;
import java.security.cert.*;
import java.security.*;
// Compiler args: -XDignore.symbol.file
public class Main {
  public static void main(String[] args) throws Exception {
    CertAndKeyGen certGen = new CertAndKeyGen("RSA", "SHA256WithRSA", null);
    // generate it with 2048 bits
    certGen.generate(2048);
    PrivateKey privateKey = certGen.getPrivateKey();
    X509Key publicKey = certGen.getPublicKey();
    // prepare the validity of the certificate
    long validSecs = (long) 365 * 24 * 60 * 60; // valid for one year
    // enter your details according to your application
    X500Name principal = new X500Name("CN=My Application,O=My Organisation,L=My City,C=DE");
    // add the certificate information, currently only valid for one year.
    X509Certificate cert = certGen.getSelfCertificate(principal, validSecs);
    // Public Key from Cert equals Public Key from generator
    PublicKey publicKeyFromCert = cert.getPublicKey();
    System.out.println(publicKeyFromCert.equals(publicKey));
  }
}

כפי שאנו יכולים לראות, תעודה מספקת את היכולת לספק מפתח ציבורי. לשיטה זו יש חיסרון - אנו משתמשים sun.securityב- שנחשב מסוכן, כי... חבילה זו אינה חלק מממשק ה-API הציבורי של Java. לכן במהלך ההידור יש צורך לציין את הפרמטר - XDignore.symbol.file. יש דרך נוספת - ליצור תעודה באופן ידני. החיסרון הוא שהוא משתמש ב-API פנימי שאינו מתועד. עם זאת, כדאי לדעת על כך. לכל הפחות, כי זה נראה בבירור כיצד נעשה שימוש במפרט RFC-2459: " Internet X.509 Public Key Infrastructure ". הנה דוגמה:

// 1. Генерируем пару ключей
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(4096);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 2. Определяем данные сертификата
// Определяем срок действия сертификата
Date from = new Date();
Date to = new Date(from.getTime() + 365 * 1000L * 24L * 60L * 60L);
CertificateValidity interval = new CertificateValidity(from, to);
// Определяем subject name, т.е. Name того, с чем ассоциирован публичный ключ
// CN = Common Name. Через точку с запятой могут быть указаны также другие атрибуты
// См. https://docs.oracle.com/cd/E24191_01/common/tutorials/authz_cert_attributes.html
X500Name owner = new X500Name("cn=Unknown");
// Уникальный в пределах CA, т.е. Certificate Authority (тот, кто выдаёт сертификат) номер
BigInteger number = new BigInteger(64, new SecureRandom());
CertificateSerialNumber serialNumber = new CertificateSerialNumber(number);
// Определяем алгоритм подписи сертификата
AlgorithmId algorithmId = new AlgorithmId(AlgorithmId.md5WithRSAEncryption_oid);
CertificateAlgorithmId certificateAlgorithmId = new CertificateAlgorithmId(algorithmId);
// 3. По подготовленной информации создаём сертификат
X509CertInfo info = new X509CertInfo();
info.set(X509CertInfo.VALIDITY, interval);
info.set(X509CertInfo.SERIAL_NUMBER, serialNumber);
info.set(X509CertInfo.SUBJECT, owner);
info.set(X509CertInfo.ISSUER, owner);
info.set(X509CertInfo.KEY, new CertificateX509Key(keyPair.getPublic()));
info.set(X509CertInfo.VERSION, new CertificateVersion(CertificateVersion.V3));
info.set(X509CertInfo.ALGORITHM_ID, certificateAlgorithmId);
// 4. Подписываем сертификат
X509CertImpl certificate = new X509CertImpl(info);
certificate.sign(keyPair.getPrivate(), "SHA256withRSA");
// 5. Проверка сертификата
try {
	// В случае ошибки здесь будет брошено исключение. Например: java.security.SignatureException
	certificate.verify(keyPair.getPublic());
} catch (Exception e) {
	throw new IllegalStateException(e);
}

Keystore (KeyStore)

הדבר האחרון שהייתי רוצה לדבר עליו הוא חנות המפתחות והתעודות, שנקראת KeyStore. ברור שהפקה מתמדת של תעודות ומפתחות היא יקרה וחסרת טעם. לכן, הם צריכים להיות מאוחסנים איכשהו בבטחה. יש כלי לזה - KeyStore. מאגר המפתחות מתואר בתיעוד JCA בפרק " ניהול מפתחות ". ה-API לעבודה איתו מאוד ברור. הנה דוגמה קטנה:

KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(null, null);
String alias = "EntityAlias";
java.security.cert.Certificate[] chain = {certificate};
keyStore.setKeyEntry(alias, keyPair.getPrivate(), "keyPassword".toCharArray(), chain);
// Загрузка содержимого (Private Key + Certificate)
Key key = keyStore.getKey(alias, "keyPassword".toCharArray());
Certificate[] certificateChain = keyStore.getCertificateChain(alias);
// Сохранение KeyStore на диск
File file = File.createTempFile("security_", ".ks");
System.out.println(file.getAbsolutePath());
try (FileOutputStream fos = new FileOutputStream(file)) {
	keyStore.store(fos, "keyStorePassword".toCharArray());
}

כפי שניתן לראות מהדוגמה, הוא מבוצע תחילה loadעבור ה-KeyStore. אבל במקרה שלנו, ציינו את התכונה הראשונה כ-null, כלומר. אין מקור ל-KeyStore. המשמעות היא שה-KeyStore נוצר ריק כדי לשמור אותו עוד יותר. גם הפרמטר השני הוא null, כי אנו יוצרים חנות KeyStore חדשה. אם היינו מטילים את KeyStore מקובץ, אז היינו צריכים לציין כאן סיסמה (בדומה לשיטת KeyStore שנקראת store).

שורה תחתונה

אז סקרנו איתך את הפעולות הבסיסיות והיסודיות ביותר במסגרת ארכיטקטורת ה-Java Cryptography (aka JCA). ראינו מהי הצפנה סימטרית ואסימטרית וכיצד היא מיושמת ב-JCA. ראינו כיצד נוצרים תעודות וחתימות דיגיטליות וכיצד משתמשים בהן. כל אלה הם רק היסודות, שמאחוריהם יש הרבה יותר דברים מורכבים ומעניינים. אני מקווה שחומר סקירה זה יהיה שימושי ויעניין אותך בלימוד נוסף של תחום זה.