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必须是默认的私钥文件：目前为了命令的兼容性。