Getting RSA private key from PEM BASE64 Encoded private key file

Question

I have a private key file  PEM BASE64 encoded   I want to use it else where to decrypt some other data Using Java i tried to read the file and decode the BASE64 encoded data in it    This is the code snippet which i tried       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                I am getting the following errors  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    The contents of the file  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-----   Similar questions have been posted here  but those were of no avail for me   Almost all of them suggested using Bouncycastle provider which am not willing to use as am supposed to use a provider which is FIPS compliant and am not sure if BC provider is FIPS compliant   A help in gettin me out of this would be highly appreciated    Thanks in advance

User · Answer

Make sure your id rsa file doesn t have any extension like  txt or  rtf  Rich Text Format adds additional characters to your file and those gets added to byte array  Which eventually causes invalid private key error  Long story short  Copy the file  not content

User · Answer

As others have responded  the key you are trying to parse doesn t have the proper PKCS 8 headers which Oracle s PKCS8EncodedKeySpec needs to understand it  If you don t want to convert the key using openssl pkcs8 or parse it using JDK internal APIs you can prepend the PKCS 8 header like this    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      Once that method is in place you can feed it s output to the PKCS8EncodedKeySpec constructor like this  new PKCS8EncodedKeySpec buildPKCS8Key privateKey

User · Answer

You will find below some code for reading unencrypted RSA keys encoded in the following formats:

PKCS#1 PEM (-----BEGIN RSA PRIVATE KEY-----)
PKCS#8 PEM (-----BEGIN PRIVATE KEY-----)
PKCS#8 DER (binary)

It works with Java 7+ (and after 9) and doesn't use third-party libraries (like BouncyCastle) or internal Java APIs (like DerInputStream or 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;
}

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

User · Answer

This is PKCS 1 format of a private key  Try this code  It doesn t use Bouncy Castle or other third-party crypto providers  Just java security and sun security for DER sequece parsing  Also it supports parsing of a private key in PKCS 8 format  PEM file that has a header  -----BEGIN PRIVATE KEY-----     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  lt  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

User · Answer

You ve just published that private key  so now the whole world knows what it is  Hopefully that was just for testing   EDIT  Others have noted that the openssl text header of the published key   -----BEGIN RSA PRIVATE KEY-----  indicates that it is PKCS 1  However  the actual Base64 contents of the key in question is PKCS 8  Evidently the OP copy and pasted the header and trailer of a PKCS 1 key onto the PKCS 8 key for some unknown reason  The sample code I ve provided below works with PKCS 8 private keys   Here is some code that will create the private key from that data  You ll have to replace the Base64 decoding with your IBM Base64 decoder   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

User · Answer

The problem you ll face is that there s two types of PEM formatted keys  PKCS8 and SSLeay  It doesn t help that OpenSSL seems to use both depending on the command   The usual openssl genrsa command will generate a SSLeay format PEM  An export from an PKCS12 file with openssl pkcs12 -in file p12 will create a PKCS8 file   The latter PKCS8 format can be opened natively in Java using PKCS8EncodedKeySpec  SSLeay formatted keys  on the other hand  can not be opened natively    To open SSLeay private keys  you can either use BouncyCastle provider as many have done before or Not-Yet-Commons-SSL have borrowed a minimal amount of necessary code from BouncyCastle to support parsing PKCS8 and SSLeay keys in PEM and DER format  http   juliusdavies ca commons-ssl pkcs8 html   I m not sure if Not-Yet-Commons-SSL will be FIPS compliant   Key Format Identification  By inference from the OpenSSL man pages  key headers for two formats are as follows   PKCS8 Format  Non-encrypted  -----BEGIN PRIVATE KEY----- Encrypted  -----BEGIN ENCRYPTED PRIVATE KEY-----  SSLeay Format  -----BEGIN RSA PRIVATE KEY-----   These seem to be in contradiction to other answers but I ve tested OpenSSL s output using PKCS8EncodedKeySpec  Only PKCS8 keys  showing ----BEGIN PRIVATE KEY----- work natively

User · Answer

Parsing PKCS1  only PKCS8 format works out of the box on Android  key turned out to be a tedious task on Android because of the lack of ASN1 suport  yet solvable if you include Spongy castle jar to read 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 lt   gt  e   primitive getObjects        BigInteger v     DERInteger  e nextElement    getValue         int version   v intValue        if  version    0  amp  amp  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

[java] Getting RSA private key from PEM BASE64 Encoded private key file

The answer is

Key Format Identification

Examples related to java

Examples related to cryptography

Examples related to certificate

Examples related to x509

Examples related to pkcs#8

Tags