pbe加密
Ⅰ 在.NET中，我怎麼能解密用PBEWithMD5AndDES在java中的加密值
答：import java.security.*; import java.util.logging.Level; import java.util.logging.Logger; public class md5{ public String md5(String str) { String s=str; if(s==null){ return ""; }else{ String value = null; MessageDigest md5 = nu...
Ⅱ jasypt mybatis嗎
jasypt既然是以簡單的方式來解決java開發中的加密問題，自然使用起來難度不是很大。加密是從系統安全性方面考慮的，因此jasypt更像是面向方面的解決辦法，不管你的系統中配置文件，敏感信息是否已經加密或者沒有加密，jasypt都能夠輕松的嵌入其中，開發人員就不用專門考慮加密演算法和代碼的編寫。
要想深入了解jasypt是如何將加密解密和摘要演算法組織起來，輕松的解決開發中加密問題以及和第三方組件集成，查看它的源代碼是不錯的選擇。
下面主要說說如何在Spring框架中如何輕松使用jasypt。（下面的加密機是對jasypt中的加密解密，摘要演算法的統稱）
第一種方式：以bean的形式將加密機（即：加密類的實例對象）交給Spring託管
第二種方式：以配置XML的形式將加密機與Spring集成。
第一種方式：
1.託管一個StandardPBEStringEncryptor加密機
<!-- 加密機 -->
<bean id="strongEncryptor" class="org.jasypt.encryption.pbe.StandardPBEStringEncryptor">
<property name="algorithm">
<value>PBEWithMD5AndTripleDES</value>
</property>
<property name="password">
<value>${user.home}</value>
</property>
</bean>
這里的屬性"password"的值為系統屬性的值，實際開發中在對某一個數據進行加密的時候這個password是要進行記錄的，如果password在這里設置之後將默認提供了一個password的取值。
其它的屬性設置可以參見： http://aiilive.blog.51cto.com/1925756/1420837 這篇文章中關於jasypt命令行工具的介紹。
在程序中使用strongEncrypt加密機對象：
@Test
public void test1() {
StandardPBEStringEncryptor spe = (StandardPBEStringEncryptor) context
.getBean("strongEncryptor");
String src = "admin@123";
String encrypt = spe.encrypt(src);
System.out.println("src=\'#\'" //加密解密
Assert.assertEquals(decrypt, src);
}
2.託管一個StandardStringDigester加密機
<!-- 摘要演算法 -->
<bean id="digestEncryptor" class="org.jasypt.digest.StandardStringDigester">
<property name="algorithm">
<value>MD5</value>
</property>
</bean>
在程序中使用digestEncryptor加密機對象
@Test
public void test7() {
StandardStringDigester ssd = (StandardStringDigester) context
.getBean("digestEncryptor");
String rs1 = ssd.digest("admin");
String rs2 = ssd.digest("admin");
System.out.println(rs1 + " [vs] " + rs2);
//判斷是否匹配
Assert.assertTrue(ssd.matches("admin", rs1));
}
StrandardStringDigester類提供了matches方法用來檢測原始數據和進行摘要計算後的數據是否匹配。
1,2介紹了數據的處理，下面3講介紹使用jasypt對配置文件進行處理.
3.使用jasypt對配置文件進行處理
比如資料庫連接的屬性值一般要進行加密處理，然後在程序運行時對其進行解密連接資料庫，這樣就保證了在程序代碼已經配置中資料庫的連接相關敏感數據不至於明文暴露。
jasypt是如何處理這一過程的呢？
首先，配置環境變數（這里指用來加解密的環境），
然後，通過環境變數來裝載加密機，
最後，使用jasypt對Spring的org.springframework.beans.factory.config.PropertyPlaceholderConfigurer類的子類來配置屬性文件替換配置。
下面是具體的配置信息：
<!-- 基於環境變數，配置加密機 -->
<bean id=""
class="org.jasypt.encryption.pbe.config.EnvironmentStringPBEConfig">
<property name="algorithm" value="PBEWithMD5AndDES" />
<!-- <property name="passwordEnvName" value=""/> -->
<!-- <property name="passwordSysPropertyName" value=""></property> -->
<property name="password" value="sa" />
</bean>
<!-- 配置加密器，將用於解密 -->
<bean id="configurationEncryptor" class="org.jasypt.encryption.pbe.StandardPBEStringEncryptor">
<property name="config" ref="" />
</bean>
<!-- 外部屬性文件配置 -->
<bean id="propertyConfigurer"
class="org.jasypt.spring31.properties.">
<constructor-arg ref="configurationEncryptor" />
<property name="locations">
<list>
<value>classpath:db.properties</value>
</list>
</property>
</bean>
<!--數據源配置, jasypt的將確保${dataSource.password}是解密 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${dataSource.driver}</value>
</property>
<property name="url">
<value>${dataSource.url}</value>
</property>
<property name="username">
<value>${dataSource.username}</value>
</property>
<property name="password">
<value>${dataSource.password}</value>
</property>
</bean>
說明：
EnvironmentStringPBEConfig 中的屬性
passwordEnvName， passwordSysPropertyName，password
三者的區別是：
passwordEnvName的值直接設置為環境變數，比如value="APP_PASSWORD", APP_PASSWORD則是系統環境變數，在實際生產環境中建議使用這個屬性，具體使用步驟如：配置環境變數APP_PASSWORD --> 啟動應用程序 --> 應用程序啟動完成 --> 刪除環境變數APP_PASSWORD。
passwordSysPropertyName的值就是用 System.getProperties() 獲取的屬性值，比如：value="${user.home}"
password和使用jasypt命令行工具時的password參數用法一致。
屬性配置文件加密
dataSource.driver=org.postgresql.Driver
dataSource.url=jdbc:postgresql://localhost:5432/dbname
dataSource.username=postgres
#dataSource.password=postgres
dataSource.password=ENC()
這里將password的加密結果放置在ENC（機密結果）中，注意這樣的寫法是jasypt的規定，可以查看源代碼，在解密過程中會根據這個標志對屬性配置文件中的加密數據進行解密。
屬性配置文件中的機密結果產生則需要用jasypt的命令行工具（具體使用可以參見：http://aiilive.blog.51cto.com/1925756/1420837 ），這里要注意的是加密過程中的演算法，password參數值需要和Spring配置文件中的(bean)的屬性取值保持一致。
數據源中使用屬性配置信息中的值
以前Spring中怎麼使用，現在就怎麼使用。
jasypt和Spring集成的依賴
jasypt.jar+jasypt-springx-x.jar , x表示一些版本信息。
第二種方式
第一種方式將jasypt中的類作為bean的形式在Spring中應用，第二種方式則更加強大，有獨立的XML配置命名空間，更像是Spring的一部分。
首先需要在Spring的配置文件中添加jasypt的命名空間。
配置完成jasypt的命名空間就可以在Spring的配置文件中直接進行加密機，加密機參數配置，下面是一個示例：
<!-- 基本的密碼加密機 -->
<encryption:basic-password-encryptor id="bpe" scope="singleton" />
<!-- 摘要配置 -->
<encryption:digester-config id="digester-config" algorithm="SHA-256" algorithm-env-name=""/>
<!-- 字元串摘要機 -->
<encryption:string-digester id="sd" algorithm="MD5" config-bean="digester-config"/>
<!-- 加密機配置 -->
<encryption:encryptor-config id="encryptor-config" algorithm="PBEWITHMD5ANDTRIPLEDES"/>
<!-- 字元串加密機 -->
<encryption:string-encryptor id="se" algorithm="PBEWITHMD5ANDDES" config-bean="encryptor-config"/>
<!-- 加密的屬性佔位符 -->
<encryption:encryptable-property-placeholder encryptor="se" location="classpath:db.properties"/>
第二種方式同樣可以實現方式一中的功能。
通過介紹了jasypt和Spring集成的兩種方式可以看出使用jasypt能夠比較輕松自定義加密的參數，配置文件的加解密，整個過程對於應用程序的代碼侵入性是很小的，可以在程序中使用jasypt提供的加密演算法和方法來實現對需要加密的數據進行處理。
此外jasypt與Hibernate集成則以一個完全對程序邏輯透明的方式可以在ORM映射中對數據進行加解密。
最後jasypt也是開放的，它開放了JCE Provider API，允許開發者使用任何存在的JCE Provider在jasypt中進行消息摘要和加密處理。
Ⅲ jsp url地址加密問題
jsp中url地址加密通常使用對稱加密如：DES或者是PBE演算法。
加密演算法如下：
public static String encrypt(String key, String plainText) throws Exception {
String encryptTxt = "";
try {
byte[] salt = new byte[8];
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(key.getBytes());
byte[] digest = md.digest();
for (int i = 0; i < 8; i++) {
salt[i] = digest[i];
}
PBEKeySpec pbeKeySpec = new PBEKeySpec(key.toCharArray());
SecretKeyFactory keyFactory = SecretKeyFactory
.getInstance("PBEWithMD5AndDES");
SecretKey skey = keyFactory.generateSecret(pbeKeySpec);
PBEParameterSpec paramSpec = new PBEParameterSpec(salt, ITERATIONS);
Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES");
cipher.init(Cipher.ENCRYPT_MODE, skey, paramSpec);
byte[] cipherText = cipher.doFinal(plainText.getBytes());
String saltString = new String(Base64.encode(salt));
String ciphertextString = new String(Base64.encode(cipherText));
return saltString + ciphertextString;
} catch (Exception e) {
throw new Exception("Encrypt Text Error:" + e.getMessage(), e);
}
使用方法：
把jsp?後面的參數作為參數傳入encrypt();然後就可以返回加密串了。
Ⅳ 請問大家如何將單個文件夾上鎖或加密
推薦易通文件夾鎖軟體，安全易用的文件夾加密軟體。支持所有windows系統。可以加密文件夾，加密文件，加密磁碟，安全易用。加密後的資料防刪除，復制。
第一步：下載安裝易通文件夾鎖軟體
第二步：右擊你想要加密的文件或文件夾，右鍵菜單里有易通加密菜單，直接就可以加密。
第三步：雙擊你已加密的文件或文件夾，將彈出密碼框輸入你加密設置的密碼，即可解密碼。
軟體下載參考地址：http://..com/question/109992099.htm
Ⅳ 紅寶石在java AES加密/解密的PBE問題，怎麼解決
import javax.crypto.*; //導入crypto包下所有類 import javax.crypto.spec.*; //導入spec包下所有類 其實import javax.crypto.*下面就包含了import javax.crypto.spec.*、 導入了import javax.crypto.*就不必在導入import javax.crypto.spec.*、
Ⅵ PBE是什麼意思
PBE
基於密碼加密(Password-Based Encryption)
基於密碼加密(Password-Based Encryption)
Password-based encryption (PBE) 【密碼加密】Elliptic Curve Cryptography (ECC) 【橢圓曲線加密】 Key agreement algorithms
例句篩選
1.
We've already mentioned the Patterns and Guidelines, so we'd like to take aminute to discuss the PBE Practice.
我們已經提到了模式和指南，所以我們想花點兒時間來討論一下PBE實踐。
2.
PBE can introce special concerns regarding model structures.
PBE可以引入關於模型結構的特殊關注。
Ⅶ 如何實現jsp的url加密
加密參數是jsp參數傳遞中的一種安全措施，加密方法如下：
建議使用對稱加密如：DES或者是PBE演算法。
加密演算法如下：
public static String encrypt(String key, String plainText) throws Exception {
String encryptTxt = "";
try {
byte[] salt = new byte[8];
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(key.getBytes());
byte[] digest = md.digest();
for (int i = 0; i < 8; i++) {
salt[i] = digest[i];
}
PBEKeySpec pbeKeySpec = new PBEKeySpec(key.toCharArray());
SecretKeyFactory keyFactory = SecretKeyFactory
.getInstance("PBEWithMD5AndDES");
SecretKey skey = keyFactory.generateSecret(pbeKeySpec);
PBEParameterSpec paramSpec = new PBEParameterSpec(salt, ITERATIONS);
Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES");
cipher.init(Cipher.ENCRYPT_MODE, skey, paramSpec);
byte[] cipherText = cipher.doFinal(plainText.getBytes());
String saltString = new String(Base64.encode(salt));
String ciphertextString = new String(Base64.encode(cipherText));
return saltString + ciphertextString;
} catch (Exception e) {
throw new Exception("Encrypt Text Error:" + e.getMessage(), e);
}
使用方法：
把jsp?後面的參數作為參數傳入encrypt();然後就可以返回加密串了。
Ⅷ [JSP]如何加密URL中.jsp後面的參數
先將參數加密 然後在接收的時候解密
至於第二個問題,我想可以在加密的時候對數據長度進行處理,長度不符合邏輯的禁止訪問,或者是加密的參數有特殊的關聯,通過特殊標記判斷是否符合標准,提交數據只能做到這一步了,其餘的只能是伺服器端解決了
Ⅸ 一個php加密方法，怎麼用java實現，高分！
Java OpenSSLPBEInputStream
importjava.io.IOException;
importjava.io.InputStream;
importjava.security.;
importjava.security.InvalidKeyException;
importjava.security.NoSuchAlgorithmException;
importjava.security.spec.InvalidKeySpecException;
importjavax.crypto.BadPaddingException;
importjavax.crypto.Cipher;
importjavax.crypto.IllegalBlockSizeException;
importjavax.crypto.NoSuchPaddingException;
{
privatefinalstaticintREAD_BLOCK_SIZE=64*1024;
privatefinalCiphercipher;
;
privatefinalbyte[]bufferCipher=newbyte[READ_BLOCK_SIZE];
privatebyte[]bufferClear=null;
privateintindex=Integer.MAX_VALUE;
privateintmaxIndex=0;
publicOpenSSLPBEInputStream(finalInputStreamstreamIn,StringalgIn,intiterationCount,char[]password)
throwsIOException{
this.inStream=streamIn;
try{
byte[]salt=readSalt();
cipher=OpenSSLPBECommon.initializeCipher(password,salt,Cipher.DECRYPT_MODE,algIn,iterationCount);
}catch(Exceptione){
thrownewIOException(e);
}
}
@Override
publicintavailable()throwsIOException{
returninStream.available();
}
@Override
publicintread()throwsIOException{
if(index>maxIndex){
index=0;
intread=inStream.read(bufferCipher);
if(read!=-1){
bufferClear=cipher.update(bufferCipher,0,read);
}
if(read==-1||bufferClear==null||bufferClear.length==0){
try{
bufferClear=cipher.doFinal();
}catch(Exceptione){
bufferClear=null;
}
}
if(bufferClear==null||bufferClear.length==0){
return-1;
}
maxIndex=bufferClear.length-1;
}
if(bufferClear==null||bufferClear.length==0){
return-1;
}
returnbufferClear[index++]&0xff;
}
privatebyte[]readSalt()throwsIOException{
byte[]headerBytes=newbyte[OpenSSLPBECommon.OPENSSL_HEADER_STRING.length()];
inStream.read(headerBytes);
StringheaderString=newString(headerBytes,OpenSSLPBECommon.OPENSSL_HEADER_ENCODE);
if(!OpenSSLPBECommon.OPENSSL_HEADER_STRING.equals(headerString)){
thrownewIOException("unexpectedfileheader"+headerString);
}
byte[]salt=newbyte[OpenSSLPBECommon.SALT_SIZE_BYTES];
inStream.read(salt);
returnsalt;
}
}
Java OpenSSLPBEOutputStream
importjava.io.IOException;
importjava.io.OutputStream;
importjava.security.SecureRandom;
importjavax.crypto.Cipher;
{
privatestaticfinalintBUFFER_SIZE=5*1024*1024;
privatefinalCiphercipher;
;
privatefinalbyte[]buffer=newbyte[BUFFER_SIZE];
privateintbufferIndex=0;
publicOpenSSLPBEOutputStream(finalOutputStreamoutputStream,StringalgIn,intiterationCount,
char[]password)throwsIOException{
outStream=outputStream;
try{
/*.*/
byte[]salt=newbyte[OpenSSLPBECommon.SALT_SIZE_BYTES];
newSecureRandom().nextBytes(salt);
cipher=OpenSSLPBECommon.initializeCipher(password,salt,Cipher.ENCRYPT_MODE,algIn,iterationCount);
/*Writeheader*/
writeHeader(salt);
}catch(Exceptione){
thrownewIOException(e);
}
}
@Override
publicvoidwrite(intb)throwsIOException{
buffer[bufferIndex]=(byte)b;
bufferIndex++;
if(bufferIndex==BUFFER_SIZE){
byte[]result=cipher.update(buffer,0,bufferIndex);
outStream.write(result);
bufferIndex=0;
}
}
@Override
publicvoidflush()throwsIOException{
if(bufferIndex>0){
byte[]result;
try{
result=cipher.doFinal(buffer,0,bufferIndex);
outStream.write(result);
}catch(Exceptione){
thrownewIOException(e);
}
bufferIndex=0;
}
}
@Override
publicvoidclose()throwsIOException{
flush();
outStream.close();
}
privatevoidwriteHeader(byte[]salt)throwsIOException{
outStream.write(OpenSSLPBECommon.OPENSSL_HEADER_STRING.getBytes(OpenSSLPBECommon.OPENSSL_HEADER_ENCODE));
outStream.write(salt);
}
}
Main Class 測試以上兩個class
importjavax.crypto.Cipher;
importjavax.crypto.NoSuchPaddingException;
importjavax.crypto.SecretKey;
importjavax.crypto.SecretKeyFactory;
importjavax.crypto.spec.PBEKeySpec;
importjavax.crypto.spec.PBEParameterSpec;
importjava.security.;
importjava.security.InvalidKeyException;
importjava.security.NoSuchAlgorithmException;
importjava.security.spec.InvalidKeySpecException;
classOpenSSLPBECommon{
protectedstaticfinalintSALT_SIZE_BYTES=8;
_HEADER_STRING="Salted__";
_HEADER_ENCODE="ASCII";
(char[]password,byte[]salt,intcipherMode,
finalStringalgorithm,intiterationCount),InvalidKeySpecException,
InvalidKeyException,NoSuchPaddingException,{
PBEKeySpeckeySpec=newPBEKeySpec(password);
SecretKeyFactoryfactory=SecretKeyFactory.getInstance(algorithm);
SecretKeykey=factory.generateSecret(keySpec);
Ciphercipher=Cipher.getInstance(algorithm);
cipher.init(cipherMode,key,newPBEParameterSpec(salt,iterationCount));
returncipher;
}
}
來源引用
https://github.com/guardianproject/ChatSecureAndroid/tree/master/src/info/guardianproject/otr
Ⅹ ios支付寶怎麼把私鑰轉換成pkcs8 格式
用途：
pkcs8格式的私鑰轉換工具。它處理在PKCS#8格式中的私鑰文件。它可以用多樣的PKCS#5 (v1.5 and v2.0)和 PKCS#12演算法來處理沒有解密的PKCS#8 PrivateKeyInfo格式和EncryptedPrivateKeyInfo格式。
用法：
[cpp] view plain
openssl pkcs8 [-inform PEM|DER] [-outform PEM|DER] [-in filename] [-passin arg] [-out filename]
[-passout arg] [-topk8] [-noiter] [-nocrypt] [-nooct] [-embed] [-nsdb] [-v2 alg] [-v1 alg] [-engine id]
選項說明：
-inform PEM|DER：：輸入文件格式，DER或者PEM格式。DER格式採用ASN1的DER標准格式。一般用的多的都是PEM格式，就是base64編碼格式。
-outform DER|PEM：輸出文件格式，DER或者PEM格式。
-in filename：輸入的密鑰文件，默認為標准輸入。如果密鑰被加密，會提示輸入一個密鑰口令。
-passin arg：輸入文件口令保護來源。
-out filename：輸出文件，默認為標准輸出。如果任何加密操作已經執行，會提示輸入一個密鑰值。輸出的文件名字不能和輸入的文件名一樣。
-passout arg：輸出文件口令保護來源。
-topk8：通常的是輸入一個pkcs8文件和傳統的格式私鑰文件將會被寫出。設置了此選項後，位置轉換過來：輸入一個傳統格式的私鑰文件，輸出一個PKCS#8格式的文件。
-noiter：MAC保護計算次數為1。
-nocrypt：PKCS#8密鑰產生或輸入一般用一個適當地密鑰來加密PKCS#8 EncryptedPrivateKeyInfo結構。設置了此選項後，一個不加密的PrivateKeyInfo結構將會被輸出。這個選項一直不加密私鑰文件，在絕對必要的時候才能夠使用。某些軟體例如一些JAVA代碼簽名軟體使用不加密的私鑰文件。
-nooct：這個選項產生的RSA私鑰文件是一個壞的格式，一些軟體將會使用。特別的是，私鑰文件必須附上一個八位組字元串，但是一些軟體僅僅包含本身的結構體沒有使八位組字元串所環繞。不採用八位組表示私鑰。
-embed：這個選項產生的RSA私鑰文件是一個壞的格式。在私鑰結構體中採用嵌入式DSA參數格式。在這個表單中，八位組字元串包含了ASN1 SEQUENCE中的兩種結構：一個SEQUENCE包含了密鑰參數，一個ASN1 INTEGER包含私鑰值。
-nsdb：這個選項產生的RSA私鑰文件是一個壞的格式並兼容了Netscape私鑰文件資料庫。採用NetscapeDB的DSA格式。
-v2 alg：採用PKCS#5 v2.0，並指定加密演算法，默認的是PKCS#8私鑰文件被叫做B<pbeWithMD5AndDES-CBC>（該演算法用56位元組的DES加密但是在PKCS#5 v1.5中有更加強壯的加密演算法）的加密演算法用口令進行加密。用B<-v2>選項，PKCS#5 v2.0相關的演算法將會被使用，可以是des3（168位元組）和rc2（128位元組），推薦des3。
-v1 alg：採用PKCS#5 v1.5或pkcs12，並指定加密演算法。可採用的演算法見下面。
-engine id：指定硬體引擎。
注意：
加密了的PEM編碼PKCS#8文件表單用下面的頭部和尾部：
-----BEGIN ENCRYPTED PRIVATE KEY-----
-----END ENCRYPTED PRIVATE KEY-----
未加密的表單用：
-----BEGIN PRIVATE KEY-----
-----END PRIVATE KEY-----
跟傳統的SSLeay演算法相比，用PKCS#5 v2.0系列的演算法加密私鑰，有更高的安全性以及迭代次數。於是附加的安全性是經過深思熟慮的。
默認的加密演算法僅僅是56位元組的，是因為它是PKCS#8所支持的最好的方法。
有一些軟體使用PKCS#12基於密鑰的加密演算法來加密PKCS#8格式的私鑰：它們會自動的處理但是沒有選項來操作。
在PKCS#8格式中，有可能的是輸出DER編碼格式的經過加密的私鑰文件，是因為加密的詳細說明包含在DER等級中，相反的是傳統的格式包含在PEM鄧麗中。
PKCS#5 v1.5和 PKCS#12 演算法：
各種各樣的演算法可以被選項-v1所使用。包含PKCS#5 v1.5和 PKCS#12 演算法。詳細描述如下：
B<PBE-MD2-DES PBE-MD5-DES>：這兩個演算法包含在PKCS#5 v1.5中。它們僅僅提供56位元組的保護，加密演算法用DES。
B<PBE-SHA1-RC2-64 PBE-MD2-RC2-64 PBE-MD5-RC2-64 PBE-SHA1-DES>：它們在傳統的PKCS#5 v1.5中沒有被提到，但是它們用同樣地密鑰引出演算法，被一些軟體所支持。在PKCS#5 v2.0中所提到。它們使用64位元組的RC2以及56位元組的DES。
B<PBE-SHA1-RC4-128 PBE-SHA1-RC4-40 PBE-SHA1-3DES PBE-SHA1-2DES PBE-SHA1-RC2-128 PBE-SHA1-RC2-40>：它們是PKCS#12基於密鑰的加密演算法，它們允許使用高強度的加密演算法，例如3des或128位的RC2。
實例：
用3des演算法將傳統的私鑰文件轉換為PKCS#5 v2.0：
[cpp] view plain
openssl pkcs8 -in key.pem -topk8 -v2 des3 -out enckey.pem
用PKCS#5 1.5兼容的DES演算法將私鑰文件轉換為pkcs8文件：
[html] view plain
openssl pkcs8 -in ocspserverkey.pem -topk8 -out ocspkcs8key.pem
用PKCS#12兼容的3DES演算法將私鑰文件轉換為pkcs8文件：
[html] view plain
openssl pkcs8 -in key.pem -topk8 -out enckey.pem -v1 PBE-SHA1-3DES
讀取一個DER格式加密了的PKCS#8格式的私鑰：
[cpp] view plain
openssl pkcs8 -inform DER -nocrypt -in key.der -out key.pem
轉換一個PKCS#8格式的私鑰到傳統的私鑰：
[cpp] view plain
openssl pkcs8 -in pk8.pem -out key.pem
pkcs8中的私鑰以明文存放：
[html] view plain
openssl pkcs8 -in ocspserverkey.pem -topk8 -nocrypt -out ocspkcs8key.pem
標准：
PKCS#5 v2.0的測試向量的實現是以通告的形式用高強度的迭代次數演算法3DES、DES和RC2來加密的。很多人要確認能夠解密產生的私鑰。
PKCS#8格式的DSA私鑰文件沒有備注文件中的：在PKCS#11 v2.01中的11.9節被隱藏了的。OpenSSL的默認DSA PKCS#8私鑰格式隱藏在這個標准中。
BUGs：
必須有一個選項列印使用的加密演算法的其他詳細細節，例如迭代次數。
PKCS#8用3DES和PKCS#5 v2.0必須是默認的私鑰文件：目前為了命令的兼容性。