Java의 PKCS#5 암호화 PKCS#8 개인 키를 해독하려면 어떻게해야합니까?
https://stackoverflow.com/questions/809590
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
PKCS#5 암호화 된 PKCS#8 RSA 개인 키가 디스크 파일 (원래 1997 년경 SSLPlus에 의해 생성)에 저장되어 있습니다.
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIICmDAaBgkqhkiG9w0BBQMwDQQIybM2XFqx4EwCAQUEggJ4MKg/NE+L6NJgbOf4
...
8QnGu4R7lFlweH/VAK8n0L75h3q2g62MKLJqmKLtAILNve4zymnO+LVZ4Js=
-----END ENCRYPTED PRIVATE KEY-----
이를 위해 Java 키 객체를 얻어야하는 다음 키 스토어에 일치하는 인증서와 함께 추가 할 수 있습니다. 개인 키는 100 바이트 바이너리 키로 암호화됩니다.
인증서 객체의 생성은 간단했지만 위의 Base64 인코딩 된 PKCS#5 키에서 해독 된 PKCS#8 RSA 개인 키로가는 방법을 알 수는 없습니다. 이 시점에서 나는 secretkeyfactory.generatesecret () 호출이 다음과 같이 실패하기 때문에 stymied입니다.
InvalidKeySpecException: Password is not ASCII
이제 암호가 ASCII가 아니라 0x00에서 0x7f의 엄격한 의미에서 ASCII가 아니라 PBEWITHMD5andDES 알고리즘은 0x00에서 0xff의 문자 값을 허용해야합니다.
누구든지 Base64 인코딩 된 값에서 키 스토어에 추가 할 수있는 키 객체로 얻는 방법을 보여줄 수 있습니까?
결론
Java와 함께 발행 된 Pbekey는 0x20 <= char <= 0x7e 범위에서 ASCII 값의 비밀번호를 허용합니다. 비 ASCII 비밀번호에 대한이 문제는 0x00에서 0xff의 바이트 값을 허용하는 내 자신의 binarypbekey를 만들어 해결되었습니다 (아래 참조).
후속 문제는 PKCS#8 데이터가 PKCS#1 데이터가 ASN.1 Octet String으로 래핑해야한다는 점에서 제대로 인코딩되지 않았다는 것입니다 (SSL의 초기 구현에 대한 일반적인 실수). 나는 길이가 512 ~ 4096 비트로 알려진 내 키를 다루는 간단한 패치 루틴을 썼습니다 (아래 참조).
개인 키 디코더
private PrivateKey readPrivateKey(File inpfil) throws IOException, GeneralSecurityException {
String[] pbeb64s; // PBE ASN.1 data base-64 encoded
byte[] pbedta; // PBE ASN.1 data in bytes
EncryptedPrivateKeyInfo pbeinf; // PBE key info
PBEParameterSpec pbeprm; // PBE parameters
Cipher pbecph; // PBE decryption cipher
byte[] pk8dta; // PKCS#8 ASN.1 data in bytes
KeyFactory pk8fac=KeyFactory.getInstance("RSA"); // PKCS#8 key factory for decoding private key from ASN.1 data.
pbeb64s=readDataBlocks(inpfil,"ENCRYPTED PRIVATE KEY");
if(pbeb64s.length!=1) { throw new GeneralSecurityException("The keystore '"+inpfil+"' contains multiple private keys"); }
pbedta=base64.decode(pbeb64s[0]);
log.diagln(" - Read private key data");
pbeinf=new EncryptedPrivateKeyInfo(pbedta);
pbeprm=(PBEParameterSpec)pbeinf.getAlgParameters().getParameterSpec(PBEParameterSpec.class);
pbecph=Cipher.getInstance(pbeinf.getAlgName());
pbecph.init(Cipher.DECRYPT_MODE,pbeDecryptKey,pbeprm);
pk8dta=pbecph.doFinal(pbeinf.getEncryptedData());
log.diagln(" - Private Key: Algorithm= "+pbeinf.getAlgName()+", Iterations: "+pbeprm.getIterationCount()+", Salt: "+Base16.toString(pbeprm.getSalt()));
pk8dta=patchKeyData(inpfil,pk8dta);
return pk8fac.generatePrivate(new PKCS8EncodedKeySpec(pk8dta));
}
binarypbekey
import java.io.*;
import java.security.*;
import java.security.spec.*;
import java.util.*;
import javax.crypto.*;
import javax.crypto.spec.*;
class BinaryPBEKey
extends Object
implements SecretKey
{
private final byte[] key;
/**
* Creates a PBE key from a given binary key.
*
* @param key The key.
*/
BinaryPBEKey(byte[] key) throws InvalidKeySpecException {
if(key==null) { this.key=new byte[0]; }
else { this.key=(byte[])key.clone(); }
Arrays.fill(key,(byte)0);
}
public byte[] getEncoded() {
return (byte[])key.clone();
}
public String getAlgorithm() {
return "PBEWithMD5AndDES";
}
public String getFormat() {
return "RAW";
}
/**
* Calculates a hash code value for the object.
* Objects that are equal will also have the same hashcode.
*/
public int hashCode() {
int ret=0;
for(int xa=1; xa<this.key.length; xa++) { ret+=(this.key[xa]*xa); }
return (ret^=getAlgorithm().toLowerCase().hashCode());
}
public boolean equals(Object obj) {
if(obj==this ) { return true; }
if(obj.getClass()!=getClass()) { return false; }
BinaryPBEKey oth=(BinaryPBEKey)obj;
if(!(oth.getAlgorithm().equalsIgnoreCase(getAlgorithm()))) {
return false;
}
byte[] othkey=oth.getEncoded();
boolean ret =Arrays.equals(key,othkey);
Arrays.fill(othkey,(byte)0);
return ret;
}
public void destroy() {
Arrays.fill(this.key,(byte)0);
}
/**
* Ensure that the password bytes of this key are zeroed out when there are no more references to it.
*/
protected void finalize() throws Throwable {
try { destroy(); } finally { super.finalize(); }
}
PKCS#8 패치
/**
* Patch the private key ASN.1 data to conform to PKCS#8.
* <p>
* The SSLPlus private key is not properly encoded PKCS#8 - the PKCS#1 RSAPrivateKey should have been wrapped
* inside an OctetString, thus:
* <pre>
* SSLPlus Encoding:
* 0 30 627: SEQUENCE {
* 4 02 1: INTEGER 0
* 7 30 13: SEQUENCE {
* 9 06 9: OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
* 20 05 0: NULL
* : }
* 22 30 605: SEQUENCE {
* 26 02 1: INTEGER 0
* 29 02 129: INTEGER
* : 00 CA 72 B8 D1 B8 8E B9 39 C0 92 C1 4C 53 B4 F4
* ...
*
* PKCS#8 Encoding
* 0 30 631: SEQUENCE {
* 4 02 1: INTEGER 0
* 7 30 13: SEQUENCE {
* 9 06 9: OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
* 20 05 0: NULL
* : }
* ==> 22 04 609: OCTET STRING, encapsulates {
* 26 30 605: SEQUENCE {
* 30 02 1: INTEGER 0
* 33 02 129: INTEGER
* : 00 CA 72 B8 D1 B8 8E B9 39 C0 92 C1 4C 53 B4 F4
* ...
* </pre>
*
* Hex Dumps (1K key, space padded for clarity):
* Before : 30 820271 020100300D06092A864886F70D0101010500 30 82025B ... A228
* After : 30 820275 020100300D06092A864886F70D0101010500 04 82025F 30 82025B ... A228
* ^^^^^^ ^^^^^^
* Add 4 for later 0482xxxx Original total + 4 - 22 (equals the key length of 025B+4)
*/
private byte[] patchKeyData(File inpfil, byte[] asndta) throws IOException, GeneralSecurityException { // except it really doesn't throw an exception
ByteArrayOutputStream patdta=new ByteArrayOutputStream();
int orglen=decodeAsnLength(inpfil,asndta,1);
patdta.write(asndta,0,1); // original leader type
patdta.write(encodeAsnLength(inpfil,(orglen+4))); // new total length
patdta.write(asndta,4,(22-4)); // bit between total length an where octet-string wrapper needs to be inserted
patdta.write(0x04); // octet-string type
patdta.write(encodeAsnLength(inpfil,(orglen+4-22))); // octet-string length (key data type+key data length+key data)
patdta.write(asndta,22,asndta.length-22); // private key data
return patdta.toByteArray();
}
private int decodeAsnLength(File inpfil, byte[] asndta, int ofs) throws GeneralSecurityException {
if((asndta[ofs]&0xFF)==0x82) { return (((asndta[ofs+1]&0x000000FF)<< 8)|((asndta[ofs+2]&0x000000FF))); }
else { throw new GeneralSecurityException("The private key in file '"+inpfil+"' is not supported (ID="+Base16.toString(asndta,0,4)+")"); }
}
private byte[] encodeAsnLength(File inpfil, int len) throws GeneralSecurityException {
if(len>=0x0100 && len<=0xFFFF) { return new byte[]{ (byte)0x82,(byte)((len>>>8)&0x000000FF),(byte)len }; }
else { throw new GeneralSecurityException("The new length of "+len+" for patching the private key in file '"+inpfil+"' is out of range"); }
}
해결책
방금 해독 된 데이터를 ASN.1 파서에 버렸고 완벽하게 좋은 ASN.1처럼 보입니다.
0 30 627: SEQUENCE {
4 02 1: INTEGER 0
7 30 13: SEQUENCE {
9 06 9: OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
20 05 0: NULL
: }
22 30 605: SEQUENCE {
26 02 1: INTEGER 0
29 02 129: INTEGER
: 00 CA 72 B8 D1 B8 8E B9 39 C0 92 C1 4C 53 B4 F4
: 38 48 3F C3 1C DC 6B BC BE 26 A3 B2 F7 7C 60 A8
: 2C 0D 86 ED FC 2D D2 5C 99 B6 B6 71 A8 6D 2F 51
: 25 FA 9C 42 FE 10 C1 2F 39 EA E8 FF 1A 78 BA 6B
: 64 B8 39 34 3B F4 1C 45 06 C3 B9 98 DC 01 FF 41
: 56 36 4F DD 35 69 A4 27 BB 5F FD DD 5C 73 BA 9A
: 94 5A 4F 37 A9 48 3D 5B 89 EA EE BA 8D 02 6E D7
: 6E D4 6F BC 7D 7A A4 41 4C 4D CA 08 05 20 66 A3
: [ Another 1 bytes skipped ]
161 02 3: INTEGER 65537
166 02 128: INTEGER
: 21 6A E2 7B 2B DD D3 51 67 2A 52 62 09 07 3B B0
: F6 AC 1F C6 E9 D3 96 EA 44 72 8D 1E 31 17 BB 6A
: DA 28 C5 AB F4 DC 5E 90 B9 0A 50 A4 9E B1 4A D1
: DC 16 63 30 91 0F 72 7E 3A FA 8E F1 8D B0 27 FD
: C2 BA B5 F8 FC 7C 46 C0 FD AD A7 39 7C 36 71 7A
: 33 8B AD 0D 0C DA 50 B7 0E BF D8 64 7D 44 BD 64
: 6F E2 51 B7 5E 2D 7B BA 02 DB A6 2F 20 88 66 98
: 85 34 2E EF D4 29 61 23 79 87 27 27 55 15 8D 21
297 02 65: INTEGER
: 00 F9 62 BD 22 4A C8 56 7A C3 17 EB CE CC 5F 42
: E1 40 F5 A5 66 60 32 54 86 67 26 AD 7C 34 C2 FE
: FE 8A F7 7F BE 79 53 5F C9 73 D9 47 8B 0F 89 A1
: 09 F1 27 16 FC F1 4B C3 A9 27 59 29 0D DA 9C AE
: 53
364 02 65: INTEGER
: 00 CF D1 4A 31 50 9A B4 BA 90 42 25 49 54 7C 20
: 54 2E CF E8 F1 35 DA 92 C2 A3 94 9D B7 B1 85 3F
: 13 D0 CA BC 77 D9 8A F3 32 83 59 93 E1 F0 11 1B
: 4C E5 A2 30 50 FE 1F B6 8D A5 B1 44 DA 4D 4B 11
: 09
431 02 64: INTEGER
: 46 53 3A C4 9D D4 0A D7 09 87 08 5F 43 B0 A5 5A
: 82 08 03 81 70 25 21 42 D9 79 C5 B8 5D E4 93 25
: D2 A8 62 A4 A2 F0 08 F5 F5 2E 53 87 7A 75 34 2D
: 6A 8C BC 65 CD E1 B0 A6 55 CB 45 D1 7B 51 6D B3
497 02 65: INTEGER
: 00 81 CC 61 7F 9D AD 92 F5 F7 86 28 CD BD 43 ED
: D9 46 87 BB 21 75 16 78 95 B3 1F EE C6 3D CD 50
: 91 6A D6 45 92 C1 C0 24 97 C7 2C 5A CE 42 68 1C
: DA 11 8F 14 88 71 C0 92 FF B3 9E 9D B7 8F 91 34
: 29
564 02 65: INTEGER
: 00 88 7A 99 AC AA A9 D5 2B 6E E1 87 0A E8 D2 4C
: 04 8E A2 EA 00 3F 8D AF 9F 76 61 86 B0 1D 18 69
: C8 64 22 D4 6B A3 A4 BB 52 B1 AC 38 DB 6B 5C 28
: F0 78 73 3E 37 FD C8 54 72 C7 FD A9 EB C9 F2 45
: 96
: }
: }
불행히도 그것은 올바르게 인코딩 된 PKCS#8 PrivateKeyInfo가 아닙니다. 인덱스 22에서 시작하는 서열은 PKCS#1 PKCS1RSAPrivatekey이며, 구조가 올바르게 인코딩되기 위해 옥타 스트링 내부에 포장되어야합니다.
대신 시도해보십시오.
구문 분석 :
0 30 631: SEQUENCE {
4 02 1: INTEGER 0
7 30 13: SEQUENCE {
9 06 9: OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
20 05 0: NULL
: }
22 04 609: OCTET STRING, encapsulates {
26 30 605: SEQUENCE {
30 02 1: INTEGER 0
33 02 129: INTEGER
: 00 CA 72 B8 D1 B8 8E B9 39 C0 92 C1 4C 53 B4 F4
: 38 48 3F C3 1C DC 6B BC BE 26 A3 B2 F7 7C 60 A8
: 2C 0D 86 ED FC 2D D2 5C 99 B6 B6 71 A8 6D 2F 51
: 25 FA 9C 42 FE 10 C1 2F 39 EA E8 FF 1A 78 BA 6B
: 64 B8 39 34 3B F4 1C 45 06 C3 B9 98 DC 01 FF 41
: 56 36 4F DD 35 69 A4 27 BB 5F FD DD 5C 73 BA 9A
: 94 5A 4F 37 A9 48 3D 5B 89 EA EE BA 8D 02 6E D7
: 6E D4 6F BC 7D 7A A4 41 4C 4D CA 08 05 20 66 A3
: [ Another 1 bytes skipped ]
165 02 3: INTEGER 65537
170 02 128: INTEGER
: 21 6A E2 7B 2B DD D3 51 67 2A 52 62 09 07 3B B0
: F6 AC 1F C6 E9 D3 96 EA 44 72 8D 1E 31 17 BB 6A
: DA 28 C5 AB F4 DC 5E 90 B9 0A 50 A4 9E B1 4A D1
: DC 16 63 30 91 0F 72 7E 3A FA 8E F1 8D B0 27 FD
: C2 BA B5 F8 FC 7C 46 C0 FD AD A7 39 7C 36 71 7A
: 33 8B AD 0D 0C DA 50 B7 0E BF D8 64 7D 44 BD 64
: 6F E2 51 B7 5E 2D 7B BA 02 DB A6 2F 20 88 66 98
: 85 34 2E EF D4 29 61 23 79 87 27 27 55 15 8D 21
301 02 65: INTEGER
: 00 F9 62 BD 22 4A C8 56 7A C3 17 EB CE CC 5F 42
: E1 40 F5 A5 66 60 32 54 86 67 26 AD 7C 34 C2 FE
: FE 8A F7 7F BE 79 53 5F C9 73 D9 47 8B 0F 89 A1
: 09 F1 27 16 FC F1 4B C3 A9 27 59 29 0D DA 9C AE
: 53
368 02 65: INTEGER
: 00 CF D1 4A 31 50 9A B4 BA 90 42 25 49 54 7C 20
: 54 2E CF E8 F1 35 DA 92 C2 A3 94 9D B7 B1 85 3F
: 13 D0 CA BC 77 D9 8A F3 32 83 59 93 E1 F0 11 1B
: 4C E5 A2 30 50 FE 1F B6 8D A5 B1 44 DA 4D 4B 11
: 09
435 02 64: INTEGER
: 46 53 3A C4 9D D4 0A D7 09 87 08 5F 43 B0 A5 5A
: 82 08 03 81 70 25 21 42 D9 79 C5 B8 5D E4 93 25
: D2 A8 62 A4 A2 F0 08 F5 F5 2E 53 87 7A 75 34 2D
: 6A 8C BC 65 CD E1 B0 A6 55 CB 45 D1 7B 51 6D B3
501 02 65: INTEGER
: 00 81 CC 61 7F 9D AD 92 F5 F7 86 28 CD BD 43 ED
: D9 46 87 BB 21 75 16 78 95 B3 1F EE C6 3D CD 50
: 91 6A D6 45 92 C1 C0 24 97 C7 2C 5A CE 42 68 1C
: DA 11 8F 14 88 71 C0 92 FF B3 9E 9D B7 8F 91 34
: 29
568 02 65: INTEGER
: 00 88 7A 99 AC AA A9 D5 2B 6E E1 87 0A E8 D2 4C
: 04 8E A2 EA 00 3F 8D AF 9F 76 61 86 B0 1D 18 69
: C8 64 22 D4 6B A3 A4 BB 52 B1 AC 38 DB 6B 5C 28
: F0 78 73 3E 37 FD C8 54 72 C7 FD A9 EB C9 F2 45
: 96
: }
: }
: }
파일을 수정하려면 ASN.1-Library를 사용할 수 있습니다 (그러나 Java에게는 좋은 것을 알지 못합니다).
데이터가 시작되는지 확인하십시오 30(*1)020100300D06092A864886F70D010101050030(*2)
(*1) 그리고 (*2) 다음 형식 중 하나의 길이 인코딩이됩니다
- 길이 <= 0x7f :
XX, 여기서 xx는 길이입니다 - 0x80 <= 길이 <= 0xff :
81XX, 여기서 xx는 길이입니다 - 0x0100 <= 길이 <= 0xffff :
82XXXX, 여기서 xxxx는 길이입니다 - 0x010000 <= 길이 <= 0xffffff :
83XXXXXX, 여기서 xxxxxx는 길이 등입니다.
키가 길이가 모두 같은 경우 길이 인코딩이 항상 형태에 있다고 가정 할 수 있습니다. 82XXXX, 그러나 실제 길이는 아마도 다를 것입니다.
길이를 읽으십시오 (*2), 길이를 바이트로 추가하십시오 30(*2) 숫자 (이것은 아마도 4 일)에 위와 같이 길이를 인코딩합니다 (아마도 형식 일 것입니다. 82XXXX). 이 길이 인코딩이라고 부릅니다 (*3). 끼워 넣다 04(*3) 직전 30(*2). 이제 길이를 추가하십시오 04(*3) (아마도 4) (*1) 그리고 이것 (아마도 여전히 적합 할 수 있습니다 82XXXX) 그리고 교체하십시오 (*1) 이것으로.
이해할 수 있기를 바랍니다. 그렇지 않으면 읽는 것이 좋습니다. ASN.1, BER 및 DER의 서브 세트에 대한 평신도 안내서.
다른 팁
탄력있는 성 내부 수업으로 키를 여는 시도해 보셨습니까? 아마도 BC를 암호화 제공 업체로 정의하는 대신 직접 사용하면 해당 파일을 구문 분석 할 수 있습니다 ...
제휴하지 않습니다 StackOverflow
