那些遇到过的问题

从PEM BASE64获取RSA私钥编码的私钥文件

Ven*_*hav 28 java cryptography certificate pkcs#8 x509

我有一个私钥文件(PEM BASE64编码).我想用它来解密一些其他数据.使用Java我试图读取文件并解码其中的BASE64编码数据...这是我试过的代码片段....

import java.io.*;
import java.nio.ByteBuffer;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import com.ibm.crypto.fips.provider.RSAPrivateKey;
import com.ibm.misc.BASE64Decoder;

public class GetPrivateKey {
    public static RSAPrivateKey get() throws Exception {
        File privateKeyFile = new File("privatekey.key");
        byte[] encodedKey = new byte[(int) privateKeyFile.length()];
        new FileInputStream(privateKeyFile).read(encodedKey);
        ByteBuffer keyBytes = new BASE64Decoder().decodeBufferToByteBuffer(encodedKey.toString());
        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(keyBytes.array());
        KeyFactory kf = KeyFactory.getInstance("RSA", "IBMJCEFIPS");
        RSAPrivateKey pk = (RSAPrivateKey) kf.generatePrivate(privateKeySpec);
        return pk;
    }

    public static void main(String[] args) throws Exception {
        PrivateKey privKey = FormatMePlease.get();
        System.out.println(privKey.toString());
    }

}
Run Code Online (Sandbox Code Playgroud)

我收到以下错误

Exception in thread "main" java.security.spec.InvalidKeySpecException: Inappropriate key specification: DerInputStream.getLength(): lengthTag=127, too big.
at com.ibm.crypto.fips.provider.RSAKeyFactory.b(Unknown Source)
at com.ibm.crypto.fips.provider.RSAKeyFactory.engineGeneratePrivate(Unknown Source)
at java.security.KeyFactory.generatePrivate(Unknown Source)
at GetPrivateKey.get(GetPrivateKey.java:24)
at GetPrivateKey.main(GetPrivateKey.java:29)
Run Code Online (Sandbox Code Playgroud)

文件"privatekey.key"的内容

-----BEGIN RSA PRIVATE KEY-----
MIIEuwIBADANBgkqhkiG9w0BAQEFAASCBKUwggShAgEAAoIBAF53wUbKmDHtvfOb8u1HPqEBFNNF
csnOMjIcSEhAwIQMbgrOuQ+vH/YgXuuDJaURS85H8P4UTt6lYOJn+SFnXvS82E7LHJpVrWwQzbh2
QKh13/akPe90DlNTUGEYO7rHaPLqTlld0jkLFSytwqfwqn9yrYpM1ncUOpCciK5j8t8MzO71LJoJ
g24CFxpjIS0tBrJvKzrRNcxWSRDLmu2kNmtsh7yyJouE6XoizVmBmNVltHhFaDMmqjugMQA2CZfL
rxiR1ep8TH8IBvPqysqZI1RIpB/e0engP4/1KLrOt+6gGS0JEDh1kG2fJObl+N4n3sCOtgaz5Uz8
8jpwbmZ3Se8CAwEAAQKCAQAdOsSs2MbavAsIM3qo/GBehO0iqdxooMpbQvECmjZ3JTlvUqNkPPWQ
vFdiW8PsHTvtackhdLsqnNUreKxXL5rr8vqi9qm0/0mXpGNi7gP3m/FeaVdYnfpIwgCe6lag5k6M
yv7PG/6N8+XrWyBdwlOe96bGohvB4Jp2YFjSTM67QONQ8CdmfqokqJ8/3RyrpDvGN3iX3yzBqXGO
jPkoJQv3I4lsYdR0nl4obHHnMSeWCQCYvJoZ7ZOliu/Dd0ksItlodG6s8r/ujkSa8VIhe0fnXTf0
i7lqa55CAByGN4MOR0bAkJwIB7nZzQKurBPcTAYJFFvAc5hgMnWT0XW83TehAoGBALVPGnznScUw
O50OXKI5yhxGf/XDT8g28L8Oc4bctRzI+8YfIFfLJ57uDGuojO/BpqtYmXmgORru0jYR8idEkZrx
gf62czOiJrCWTkBCEMtrNfFHQJQCQrjfbHofp7ODnEHbHFm7zdlbfNnEBBaKXxd2rVv4UTEhgftv
wsHcimbXAoGBAIViWrHWElMeQT0datqlThE/u51mcK4VlV7iRWXVa1/gAP85ZAu44VvvDlkpYVkF
zSRR+lHSOzsubDMN45OBQW6UA3RPg4TCvrTOmhQUeF5XPuSdcD0R2At6pdaLwAKnOtILg13Ha6ym
Igjv8glodvem3hWLmpHIhNBiaXtf8wqpAoGADH5a8OhvKOtd8EChGXyp9LDW+HRw9vbyN/gi9dQX
ltgyoUBb1jDllgoJSRHgRFUvyvbb/ImR5c03JwqtiQ8siWTC9G5WGeS+jcSNt9fVmG7W1L14MbrG
Jj8fFns/7xrOlasnlPdgA+5N+CONtI/sZY2D/KZr0drhPhZBcWJlFxkCgYAn+4SOPEo/6hjKNhA6
vER7fSxDEVsDg+rDh3YgAWpvUdlaqBxqOyAqi600YugQZGHK2lv7vNYOdmrunuIx7BPuDqY+bjtR
R4Mc9bVQAZbXSLXMl7j2RWwKfNhLSJbk9LX4EoVtTgLjvOUE4tAdq9fFgpqdwLwzqPTO9kECP4++
CQKBgH6tO/xcNxG/uXUideluAn3H2KeyyznZMJ7oCvzf26/XpTAMI243OoeftiKVMgxuZ7hjwqfn
/VHXABc4i5gchr9RzSb1hZ/IqFzq2YGmbppg5Ok2cgwalDoDBi21bRf8aDRweL62mO+7aPnCQZ58
j5W72PB8BAr6xg0Oro25O4os
-----END RSA PRIVATE KEY-----
Run Code Online (Sandbox Code Playgroud)

这里也发布了类似的问题,但这些问题对我来说都没有用.几乎所有人都建议使用不愿意使用的Bouncycastle提供商,因为我应该使用符合FIPS标准的提供商,并且不确定BC提供商是否符合FIPS标准.

帮助我摆脱这一点将非常感谢...提前感谢.

Jam*_*olk 36

你刚刚发布了这个私钥,现在全世界都知道它是什么.希望这只是为了测试.

编辑:其他人已经注意到已发布密钥的openssl文本标题----- BEGIN RSA PRIVATE KEY -----表示它是PKCS#1.但是,有关密钥的实际Base64内容是PKCS#8.很明显OP复制并将PKCS#1密钥的标题和预告片粘贴到PKCS#8密钥上,原因不明.我在下面提供的示例代码适用于PKCS#8私钥.

以下是一些将从该数据创建私钥的代码.您必须使用IBM Base64解码器替换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);
    }
}
Run Code Online (Sandbox Code Playgroud)

  • 我收到此错误:`java.security.spec.InvalidKeySpecException:java.security.InvalidKeyException:IOException:algid parse错误,而不是java.security中sun.security.rsa.RSAKeyFactory.engineGeneratePrivate(未知来源)的序列. KeyFactory.generatePrivate(未知来源)` (9认同)
  • @GregS,这是一个很好的代码,但我不相信`----- BEGIN RSA PRIVATE KEY -----`表示PKCS8格式的密钥.根据我的理解,这些是SSLeay格式化,这导致一些用户的错误.请参阅我的回答:http://stackoverflow.com/a/22218774/1554386 (3认同)
  • @AlastairMcCormack:感谢您的评论.我没有注意标题和预告片,其中的内容显然是PKCS#8编码.要看到这一点,只需将其粘贴到您最喜欢的ASN.1解码器中即可.我喜欢[lapo.it](http://lapo.it/asn1js/).OP可能会从不同类型的文件中剪切并粘贴不同的标题？如果这样会误导别人,那么你的评论非常感激. (3认同)
  • 也许您应该在答案中添加说明，说明它适用于 PKCS#8 格式 (2认同)

Yur*_* G. 30

这是私钥的PKCS#1格式.试试这个代码.它不使用Bouncy Castle或其他第三方加密提供程序.只需java.security和sun.security进行DER sequece解析.它还支持解析PKCS#8格式的私钥(具有标题"----- BEGIN PRIVATE KEY -----"的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");
    }
Run Code Online (Sandbox Code Playgroud)

  • 从 JDK 9 开始，“DerInputStream”和“DerValue”不再可用。 (3认同)

Jea*_*vre 25

您将在下面找到一些用于读取以下格式编码的未加密RSA 密钥的代码：

  • PKCS#1 PEM ( -----BEGIN RSA PRIVATE KEY-----)
  • PKCS#8 PEM ( -----BEGIN PRIVATE KEY-----)
  • PKCS#8 DER（二进制）

它适用于 Java 7+（以及 9 之后）并且不使用第三方库（如 BouncyCastle）或内部 Java API（如DerInputStream或DerValue）。

private static final String PKCS_1_PEM_HEADER = "-----BEGIN RSA PRIVATE KEY-----";
private static final String PKCS_1_PEM_FOOTER = "-----END RSA PRIVATE KEY-----";
private static final String PKCS_8_PEM_HEADER = "-----BEGIN PRIVATE KEY-----";
private static final String PKCS_8_PEM_FOOTER = "-----END PRIVATE KEY-----";

public static PrivateKey loadKey(String keyFilePath) throws GeneralSecurityException, IOException {
    byte[] keyDataBytes = Files.readAllBytes(Paths.get(keyFilePath));
    String keyDataString = new String(keyDataBytes, StandardCharsets.UTF_8);

    if (keyDataString.contains(PKCS_1_PEM_HEADER)) {
        // OpenSSL / PKCS#1 Base64 PEM encoded file
        keyDataString = keyDataString.replace(PKCS_1_PEM_HEADER, "");
        keyDataString = keyDataString.replace(PKCS_1_PEM_FOOTER, "");
        return readPkcs1PrivateKey(Base64.decodeBase64(keyDataString));
    }

    if (keyDataString.contains(PKCS_8_PEM_HEADER)) {
        // PKCS#8 Base64 PEM encoded file
        keyDataString = keyDataString.replace(PKCS_8_PEM_HEADER, "");
        keyDataString = keyDataString.replace(PKCS_8_PEM_FOOTER, "");
        return readPkcs8PrivateKey(Base64.decodeBase64(keyDataString));
    }

    // We assume it's a PKCS#8 DER encoded binary file
    return readPkcs8PrivateKey(Files.readAllBytes(Paths.get(keyFilePath)));
}

private static PrivateKey readPkcs8PrivateKey(byte[] pkcs8Bytes) throws GeneralSecurityException {
    KeyFactory keyFactory = KeyFactory.getInstance("RSA", "SunRsaSign");
    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pkcs8Bytes);
    try {
        return keyFactory.generatePrivate(keySpec);
    } catch (InvalidKeySpecException e) {
        throw new IllegalArgumentException("Unexpected key format!", e);
    }
}

private static PrivateKey readPkcs1PrivateKey(byte[] pkcs1Bytes) throws GeneralSecurityException {
    // We can't use Java internal APIs to parse ASN.1 structures, so we build a PKCS#8 key Java can understand
    int pkcs1Length = pkcs1Bytes.length;
    int totalLength = pkcs1Length + 22;
    byte[] pkcs8Header = new byte[] {
            0x30, (byte) 0x82, (byte) ((totalLength >> 8) & 0xff), (byte) (totalLength & 0xff), // Sequence + total length
            0x2, 0x1, 0x0, // Integer (0)
            0x30, 0xD, 0x6, 0x9, 0x2A, (byte) 0x86, 0x48, (byte) 0x86, (byte) 0xF7, 0xD, 0x1, 0x1, 0x1, 0x5, 0x0, // Sequence: 1.2.840.113549.1.1.1, NULL
            0x4, (byte) 0x82, (byte) ((pkcs1Length >> 8) & 0xff), (byte) (pkcs1Length & 0xff) // Octet string + length
    };
    byte[] pkcs8bytes = join(pkcs8Header, pkcs1Bytes);
    return readPkcs8PrivateKey(pkcs8bytes);
}

private static byte[] join(byte[] byteArray1, byte[] byteArray2){
    byte[] bytes = new byte[byteArray1.length + byteArray2.length];
    System.arraycopy(byteArray1, 0, bytes, 0, byteArray1.length);
    System.arraycopy(byteArray2, 0, bytes, byteArray1.length, byteArray2.length);
    return bytes;
}
Run Code Online (Sandbox Code Playgroud)

来源：https : //github.com/Mastercard/client-encryption-java/blob/master/src/main/java/com/mastercard/developer/utils/EncryptionUtils.java

Ala*_*ack 23

您将面临的问题是,有两种类型的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借用了少量必要的代码来支持以PEM和DER格式解析PKCS8和SSLeay密钥:http: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-----本地工作)

Bor*_*hov 16

解析PKCS1(只有PKCS8格式在Android上开箱即用)键在Android上是一项繁琐的任务,因为缺少ASN1支持,但如果你包括Spongy castle jar来阅读DER Integers ,那么这个任务是可以解决的.

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);
}
Run Code Online (Sandbox Code Playgroud)

  • @VenkatMadhav DER 不是加密标准 - 它是一种编码标准。 (2认同)

小智 5

正如其他人的回答一样，您尝试解析的密钥没有Oracle PKCS8EncodedKeySpec需要理解的正确的PKCS＃8标头。如果您不想openssl pkcs8使用JDK内部API 转换密钥或使用JDK内部API解析密钥，则可以在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;
}
Run Code Online (Sandbox Code Playgroud)

一旦该方法就位，您可以将其输出馈送到PKCS8EncodedKeySpec构造函数，如下所示：new PKCS8EncodedKeySpec(buildPKCS8Key(privateKey));

归档时间：

查看次数：

123750 次

最近记录：

6 年，5 月 前
使用PEM编码的加密私钥本地签名消息 14
如何从RSA Privatekey.pem文件中获取java.security.PrivateKey对象？ 9
使用Java解密OpenSSL PEM编码的RSA私钥？ 5
更多相关链接
相关归档
构造函数中的可覆盖方法调用有什么问题？ 366
使用Retrofit 2进行记录 287
如果性能很重要,我应该使用Java的String.format()吗？ 207
Clone()vs Copy构造函数 - 在java中推荐 137
在Eclipse中自动导入IntelliJ IDEA中的类的任何方式(或快捷方式)？ 111
如何自动化REST API文档(Jersey实现) 62
异常与断言 54
将double转换为Int,向下舍入 44
将Blob转换为字节数组的最简单方法 42
XML签名验证 1
难疑归档
循环内的JavaScript闭包 - 简单实用的例子 2689
如何测试私有函数或具有私有方法,字段或内部类的类？ 2593
我是否施放了malloc的结果？ 2318
PHP'foreach'如何实际工作？ 1926
使用jQuery获取当前URL？ 1761
<button>与<input type ="button"/>.哪个用？ 1588
从客户端检测到潜在危险的Request.Form值 1437
从JSON文件中解析值？ 1400
什么是monad？ 1373
如何在同一元素上组合背景图像和CSS3渐变？ 1203