Wie lese ich PEM-codierte private RSA-Schlüssel in Java ohne Bouncycastle?

Lesen eines PEM-codierten RSA-Privatschlüssels (ohne Verwendung von Bouncycastle)

Die meisten Java-Lösungen zum Lesen eines privaten Schlüssels aus einer PEM-Datei verlassen sich auf den Bouncycastle-Anbieter, was möglicherweise nicht der Fall ist in manchen Umgebungen akzeptabel sein. In diesem Artikel wird eine alternative Methode vorgestellt, die nur die Java Cryptographic Extensions (JCE) und sun.security für die DER-Analyse verwendet.

Codebeispiel

Unten finden Sie einen Codeausschnitt, der sowohl PKCS#8 als auch unterstützt PKCS#1-Formate privater Schlüssel in PEM-Dateien:

import sun.security.util.DerInputStream;
import sun.security.util.DerValue;

import java.io.File;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateCrtKeySpec;
import java.util.Base64;

public static PrivateKey pemFileLoadPrivateKeyPkcs1OrPkcs8Encoded(File pemFileName) throws GeneralSecurityException, IOException {
    // PKCS#8 format
    final String PEM_PRIVATE_START = "-----BEGIN PRIVATE KEY-----";
    final String PEM_PRIVATE_END = "-----END PRIVATE KEY-----";

    // PKCS#1 format
    final String PEM_RSA_PRIVATE_START = "-----BEGIN RSA PRIVATE KEY-----";
    final String PEM_RSA_PRIVATE_END = "-----END RSA PRIVATE KEY-----";

    Path path = Paths.get(pemFileName.getAbsolutePath());

    String privateKeyPem = new String(Files.readAllBytes(path));

    if (privateKeyPem.indexOf(PEM_PRIVATE_START) != -1) { // PKCS#8 format
        privateKeyPem = privateKeyPem.replace(PEM_PRIVATE_START, "").replace(PEM_PRIVATE_END, "");
        privateKeyPem = privateKeyPem.replaceAll("\s", "");

        byte[] pkcs8EncodedKey = Base64.getDecoder().decode(privateKeyPem);

        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(new PKCS8EncodedKeySpec(pkcs8EncodedKey));

    } else if (privateKeyPem.indexOf(PEM_RSA_PRIVATE_START) != -1) {  // PKCS#1 format

        privateKeyPem = privateKeyPem.replace(PEM_RSA_PRIVATE_START, "").replace(PEM_RSA_PRIVATE_END, "");
        privateKeyPem = privateKeyPem.replaceAll("\s", "");

        DerInputStream derReader = new DerInputStream(Base64.getDecoder().decode(privateKeyPem));

        DerValue[] seq = derReader.getSequence(0);

        if (seq.length < 9) {
            throw new GeneralSecurityException("Could not parse a PKCS1 private key.");
        }

        // skip version seq[0];
        BigInteger modulus = seq[1].getBigInteger();
        BigInteger publicExp = seq[2].getBigInteger();
        BigInteger privateExp = seq[3].getBigInteger();
        BigInteger prime1 = seq[4].getBigInteger();
        BigInteger prime2 = seq[5].getBigInteger();
        BigInteger exp1 = seq[6].getBigInteger();
        BigInteger exp2 = seq[7].getBigInteger();
        BigInteger crtCoef = seq[8].getBigInteger();

        RSAPrivateCrtKeySpec keySpec = new RSAPrivateCrtKeySpec(modulus, publicExp, privateExp, prime1, prime2, exp1, exp2, crtCoef);

        KeyFactory factory = KeyFactory.getInstance("RSA");

        return factory.generatePrivate(keySpec);
    }

    throw new GeneralSecurityException("Not supported format of a private key");
}

Verwendung

Zu Wenn Sie diesen Code verwenden, übergeben Sie einfach den Pfad zur PEM-Datei, die den privaten Schlüssel enthält, als Argument an die Methode pemFileLoadPrivateKeyPkcs1OrPkcs8Encoded. Die Methode gibt eine Instanz der PrivateKey-Klasse zurück, die dann zur Entschlüsselung oder für andere geeignete Zwecke verwendet werden kann.

Das obige ist der detaillierte Inhalt vonWie lese ich PEM-codierte private RSA-Schlüssel in Java ohne Bouncycastle?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!