Получение секретного ключа RSA из PEM BASE64 Зашифрованный файл секретного ключа

Ответ 1

Parsing PKCS1 (только формат PKCS8 работает из коробки на Android) ключ оказался утомительной задачей на Android из-за отсутствия поддержки ASN1, но разрешимой, если вы включили Spongy castle, чтобы читать целые числа DER.

String privKeyPEM = key.replace(
"-----BEGIN RSA PRIVATE KEY-----\n", "")
    .replace("-----END RSA PRIVATE KEY-----", "");

// Base64 decode the data

byte[] encodedPrivateKey = Base64.decode(privKeyPEM, Base64.DEFAULT);

try {
    ASN1Sequence primitive = (ASN1Sequence) ASN1Sequence
        .fromByteArray(encodedPrivateKey);
    Enumeration<?> e = primitive.getObjects();
    BigInteger v = ((DERInteger) e.nextElement()).getValue();

    int version = v.intValue();
    if (version != 0 && version != 1) {
        throw new IllegalArgumentException("wrong version for RSA private key");
    }
    /**
     * In fact only modulus and private exponent are in use.
     */
    BigInteger modulus = ((DERInteger) e.nextElement()).getValue();
    BigInteger publicExponent = ((DERInteger) e.nextElement()).getValue();
    BigInteger privateExponent = ((DERInteger) e.nextElement()).getValue();
    BigInteger prime1 = ((DERInteger) e.nextElement()).getValue();
    BigInteger prime2 = ((DERInteger) e.nextElement()).getValue();
    BigInteger exponent1 = ((DERInteger) e.nextElement()).getValue();
    BigInteger exponent2 = ((DERInteger) e.nextElement()).getValue();
    BigInteger coefficient = ((DERInteger) e.nextElement()).getValue();

    RSAPrivateKeySpec spec = new RSAPrivateKeySpec(modulus, privateExponent);
    KeyFactory kf = KeyFactory.getInstance("RSA");
    PrivateKey pk = kf.generatePrivate(spec);
} catch (IOException e2) {
    throw new IllegalStateException();
} catch (NoSuchAlgorithmException e) {
    throw new IllegalStateException(e);
} catch (InvalidKeySpecException e) {
    throw new IllegalStateException(e);
}

Ответ 2

Вы только что опубликовали этот закрытый ключ, так что теперь весь мир знает, что это такое. Надеюсь, это было просто для тестирования.

EDIT: Другие отметили, что текстовый заголовок openssl опубликованного ключа, ----- BEGIN RSA PRIVATE KEY -----, указывает, что он является PKCS # 1. Однако фактическое содержимое Base64 данного ключа является PKCS # 8. Очевидно, копия OP и вставила заголовок и трейлер ключа PKCS # 1 на ключ PKCS # 8 по неизвестной причине. Пример кода, который я привел ниже, работает с закрытыми ключами PKCS # 8.

Вот некоторый код, который создаст секретный ключ из этих данных. Вам придется заменить декодирование Base64 на ваш декодер IBM Base64.

public class RSAToy {

    private static final String BEGIN_RSA_PRIVATE_KEY = "-----BEGIN RSA PRIVATE KEY-----\n"
            + "MIIEuwIBADAN ...skipped the rest\n"
         // + ...   
         // + ... skipped the rest
         // + ...   
            + "-----END RSA PRIVATE KEY-----";

    public static void main(String[] args) throws Exception {

        // Remove the first and last lines

        String privKeyPEM = BEGIN_RSA_PRIVATE_KEY.replace("-----BEGIN RSA PRIVATE KEY-----\n", "");
        privKeyPEM = privKeyPEM.replace("-----END RSA PRIVATE KEY-----", "");
        System.out.println(privKeyPEM);

        // Base64 decode the data

        byte [] encoded = Base64.decode(privKeyPEM);

        // PKCS8 decode the encoded RSA private key

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        PrivateKey privKey = kf.generatePrivate(keySpec);

        // Display the results

        System.out.println(privKey);
    }
}

Ответ 3

Это формат закрытого ключа PKCS # 1. Попробуйте этот код. Он не использует Bouncy Castle или других сторонних поставщиков криптографии. Просто java.security и sun.security для разбора парсеров DER. Также он поддерживает разбор секретного ключа в формате PKCS # 8 (файл PEM с заголовком "----- НАЧАТЬ ЧАСТНЫЙ КЛЮЧ -----" ).

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");
    }

Ответ 4

Проблема, с которой вы столкнетесь, состоит в том, что существуют два типа ключей в формате PEM: PKCS8 и SSLeay. Это не помогает OpenSSL, как представляется, использовать оба в зависимости от команды:

Обычная команда openssl genrsa будет генерировать формат SSLeay PEM. Экспорт из файла PKCS12 с помощью openssl pkcs12 -in file.p12 создаст файл PKCS8.

Последний формат PKCS8 можно открыть изначально на Java с помощью PKCS8EncodedKeySpec. С другой стороны, отформатированные ключи SSLeay не могут быть открыты изначально.

Чтобы открыть закрытые ключи SSLeay, вы можете использовать провайдер BouncyCastle, как это делали многие, или Not-Yet-Commons-SSL заимствовали минимальный объем необходимого кода от BouncyCastle для поддержки разбора ключей PKCS8 и SSLeay в форматах PEM и DER: http://juliusdavies.ca/commons-ssl/pkcs8.html. (Я не уверен, что Not-Yet-Commons-SSL будет соответствовать FIPS)

Идентификация формата ключа

Вывод из справочных страниц OpenSSL заголовков заголовков для двух форматов выглядит следующим образом:

Формат PKCS8

Не шифруется: -----BEGIN PRIVATE KEY-----
Зашифровано: -----BEGIN ENCRYPTED PRIVATE KEY-----

Формат SSLeay

-----BEGIN RSA PRIVATE KEY-----

(Кажется, это противоречит другим ответам, но я тестировал вывод OpenSSL с использованием PKCS8EncodedKeySpec. Только ключи PKCS8, показывающие ----BEGIN PRIVATE KEY----- работают изначально)

Ответ 5

Как ответили другие, ключ, который вы пытаетесь выполнить, не имеет правильных заголовков PKCS # 8, которые Oracle PKCS8EncodedKeySpec должен понять. Если вы не хотите преобразовывать ключ с помощью openssl pkcs8 или анализировать его с помощью внутренних API JDK, вы можете добавить заголовок PKCS # 8 следующим образом:

static final Base64.Decoder DECODER = Base64.getMimeDecoder();

private static byte[] buildPKCS8Key(File privateKey) throws IOException {
  final String s = new String(Files.readAllBytes(privateKey.toPath()));
  if (s.contains("--BEGIN PRIVATE KEY--")) {
    return DECODER.decode(s.replaceAll("-----\\w+ PRIVATE KEY-----", ""));
  }
  if (!s.contains("--BEGIN RSA PRIVATE KEY--")) {
    throw new RuntimeException("Invalid cert format: "+ s);
  }

  final byte[] innerKey = DECODER.decode(s.replaceAll("-----\\w+ RSA PRIVATE KEY-----", ""));
  final byte[] result = new byte[innerKey.length + 26];
  System.arraycopy(DECODER.decode("MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKY="), 0, result, 0, 26);
  System.arraycopy(BigInteger.valueOf(result.length - 4).toByteArray(), 0, result, 2, 2);
  System.arraycopy(BigInteger.valueOf(innerKey.length).toByteArray(), 0, result, 24, 2);
  System.arraycopy(innerKey, 0, result, 26, innerKey.length);
  return result;
}

Как только этот метод будет установлен, вы можете подать его на конструктор PKCS8EncodedKeySpec следующим образом: new PKCS8EncodedKeySpec(buildPKCS8Key(privateKey));

Ответ 6

Убедитесь, что ваш файл id_rsa не имеет расширения, например .txt или .rtf. Формат Rich Text добавляет дополнительные символы в ваш файл, и они добавляются в массив байтов. Который в конечном итоге вызывает недопустимую ошибку частного ключа. Короче говоря, скопируйте файл, а не контент.

Ответ 7

Вместо того, чтобы вручную разбора файла PEM, используйте BouncyCastle org.bouncycastle.util.io.pem.PemReader.

    String pem = "-----BEGIN......";
    byte[] content;
    try (PemReader pemReader = new PemReader(new StringReader(pem))) {
        content = pemReader.readPemObject().getContent();
    }
    PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(content);
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    PrivateKey result = keyFactory.generatePrivate(encodedKeySpec);