Java安全 – JCE Blowfish算法报错

时间 2019-11-10

标签 java 安全 jce blowfish 算法报错栏目 Java 繁體版

原文原文链接

代码里用Blowfish算法加解密，结果jdk升到1.7后算法初始化失败 javascript

java.lang.RuntimeException: java.lang.RuntimeException: PANIC: Unreachable code reached.html

JCE不熟悉，更新到原来jdk6的security后报java

java.lang.SecurityException: The jurisdiction policy files are not signed by a trusted signernode

解决方法：git

单独下载JCE 扩展：需单独从Oracle官网下载对应JDK版本的Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 算法

JDK7对应的jurisdiction policy files：swift

http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html
数组

JDK8安全

http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html服务器

jdk6

http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html

JCE，Java Cryptography Extension，在早期JDK版本中，因为受美国的密码出口条例约束，Java中涉及加解密功能的API被限制出口，因此Java中安全组件被分红了两部分: 不含加密功能的JCA（Java Cryptography Architecture ）和含加密功能的JCE（Java Cryptography Extension）。在JDK1.1-1.3版本期间，JCE属于扩展包，仅供美国和加拿大的用户下载，JDK1.4+版本后，随JDK核心包一块儿分发；

JCA和JCE的API体系架构

JCE的API都在javax.crypto包下，核心功能包括：加解密、密钥生成（对称）、MAC生成、密钥协商，下面咱们就详细介绍下这些功能。

一. 加解密
加解密功能由Cipher组件提供，其也是JCE中最核心的组件。
1. Cipher的几个知识点：
——————————————————————————————–
a. Cipher在使用时需以参数方式指定transformation
b. transformation的格式为algorithm/mode/padding，其中algorithm为必输项，如: DES/CBC/PKCS5Padding
c. 缺省的mode为ECB，缺省的padding为PKCS5Padding
d. 在block算法与流加密模式组合时, 需在mode后面指定每次处理的bit数, 如DES/CFB8/NoPadding, 如未指定则使用缺省值, SunJCE缺省值为64bits
e. Cipher有4种操做模式: ENCRYPT_MODE(加密), DECRYPT_MODE(解密), WRAP_MODE(导出Key), UNWRAP_MODE(导入Key)，初始化时需指定某种操做模式

2. 对称加密的算法与密钥长度选择

算法名称	密钥长	块长	速度	说明
DES	56	64	慢	不安全, 不要使用
3DES	112/168	64	很慢	中等安全, 适合加密较小的数据
AES	128, 192, 256	128	快	安全
Blowfish	（4至56）*8	64	快	应该安全, 在安全界还没有被充分分析、论证
RC4	40-1024	64	很快	安全性不明确

通常状况下，不要选择DES算法，推荐使用AES算法。通常认为128bits的密钥已足够安全，若是能够请选择256bits的密钥。注意：
——————————————————————————————–
a. 密钥长度是在生成密钥时指定的，如：

KeyGenerator generator = KeyGenerator.getInstance("AES/CBC/PKCS5PADDING"); generator.init(256); SecretKey key = generator.generateKey();

b. 生成长度超128bits的密钥，需单独从Oracle官网下载对应JDK版本的Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files文件，例如JDK7对应的jurisdiction policy files

3. 加密示例代码

/** * 根据密钥{@link #getKey()}对指定的明文plainText进行加密. * * @param plainText 明文 * @return 加密后的密文. */ public static final String encrypt(String plainText) { Key secretKey = getKey(); try { Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, secretKey); byte[] p = plainText.getBytes("UTF-8"); byte[] result = cipher.doFinal(p); BASE64Encoder encoder = new BASE64Encoder(); String encoded = encoder.encode(result); return encoded; } catch (Exception e) { throw new RuntimeException(e); } }

4. 解密示例代码

/** * 根据密钥{@link #getKey()}对指定的密文cipherText进行解密. * * @param cipherText 密文 * @return 解密后的明文. */ public static final String decrypt(String cipherText) { Key secretKey = getKey(); try { Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); cipher.init(Cipher.DECRYPT_MODE, secretKey); BASE64Decoder decoder = new BASE64Decoder(); byte[] c = decoder.decodeBuffer(cipherText); byte[] result = cipher.doFinal(c); String plainText = new String(result, "UTF-8"); return plainText; } catch (Exception e) { throw new RuntimeException(e); } }

5. 带算法参数的加解密
Cipher可能用到算法参数（AlgorithmParameterSpec或AlgorithmParameters）的情形:
——————————————————————————————–
a. DES, DES-EDE, and Blowfish使用feedback模式时(如CBC, CFB, OFB或PCBC), 将用到IV
b. PBEWithMD5AndDES将用到salt和iteration count

下面是采用PBE算法进行加解密的示例：

/** * 提供基于口令的加密功能. * * @param plainText 明文 * @return 加密后的密文. */ public static final String pbeEncrypt(String plainText) { Key pbeSecretKey = getPBEKey(); PBEParameterSpec pbeParamSpec = getParamSpec(); try { Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES"); cipher.init(Cipher.ENCRYPT_MODE, pbeSecretKey, pbeParamSpec); byte[] p = plainText.getBytes("UTF-8"); byte[] result = cipher.doFinal(p); BASE64Encoder encoder = new BASE64Encoder(); String encoded = encoder.encode(result); return encoded; } catch (Exception e) { throw new RuntimeException(e); } } /** * 提供基于口令的解密功能. * * @param cipherText 密文 * @return 解密后的明文. */ public static final String pbeDecrypt(String cipherText) { Key pbeSecretKey = getPBEKey(); PBEParameterSpec pbeParamSpec = getParamSpec(); try { Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES"); cipher.init(Cipher.DECRYPT_MODE, pbeSecretKey, pbeParamSpec); BASE64Decoder decoder = new BASE64Decoder(); byte[] c = decoder.decodeBuffer(cipherText); byte[] result = cipher.doFinal(c); String plainText = new String(result, "UTF-8"); return plainText; } catch (Exception e) { throw new RuntimeException(e); } } /** * 获取PBE算法的密钥. 注意PBE密钥由用户提供的口令构造出来的, * 用户提供的口令务必使用char数组, 而不能使用字符串, 字符数 * 组用完即清空. * * @return PBE算法的密钥. */ private static final Key getPBEKey() { // TODO come from db or System.in, NOTE: MUST be char array, not java.lang.String char[] pwd = {'%', '_', 'A', 's', '9', 'K'}; SecretKey pbeKey = null; PBEKeySpec pbeKeySpec = new PBEKeySpec(pwd); try { SecretKeyFactory keyFac = SecretKeyFactory.getInstance("PBEWithMD5AndDES"); pbeKey = keyFac.generateSecret(pbeKeySpec); return pbeKey; } catch (Exception e) { throw new RuntimeException(e); } finally { Arrays.fill(pwd, ' '); } } /** * 获取PBE的算法参数, 涉及salt和iterate count两个参数. * * @return PBE的算法参数. */ private static final PBEParameterSpec getParamSpec() { byte[] salt = { (byte) 0xab, (byte) 0x58, (byte) 0xa1, (byte) 0x8c, (byte) 0x3e, (byte) 0xc8, (byte) 0x9d, (byte) 0x7a }; int count = 20; PBEParameterSpec paramSpec = new PBEParameterSpec(salt, count); return paramSpec; }

测试代码：

String pbePlainText = "127Kjk$%2^"; String pbeCipherText = pbeEncrypt(pbePlainText); String pbePlainText2 = pbeDecrypt(pbeCipherText); if (!pbePlainText.equals(pbePlainText2)) { System.out.println("PBE Something wrong"); }

二. 密钥生成
非对称密钥的生成请参考java.security.KeyPairGenerator，样例代码请参考JCA中的示例，对称密钥生成的示例代码以下：

KeyGenerator gen = KeyGenerator.getInstance("DES"); gen.init(56, new SecureRandom()); Key key= gen.generateKey();

三. MAC生成
MAC技术用于确认数据的完整性，Mac要求通信双方共享一个secret key，示例代码以下：

Key key = KeyGeneratorDemo.generateMac();
Mac mac = Mac.getInstance("HmacSHA256"); mac.init(key); String msg = "新庄杨渡10#"; byte[] result = mac.doFinal(msg.getBytes("UTF-8")); BASE64Encoder encoder = new BASE64Encoder(); System.out.println(encoder.encode(result));

MAC优于数据摘要的地方在于：MAC双方要共享一个密钥，因此其也有互相认证的功能，可有效防止数据摘要中明文和数据摘要被同时替换而没法发现的问题。

四. 密钥协商
密钥协商就是在通信多方间不直接交换通信密钥的状况下而选择一个你们达成一致的密钥(session key)，这个session key是对称密钥。
1. 密钥协商能够经过2种途径实现：
——————————————————————————————–
a. 经过KeyAgreement组件完成，经常使用算法包括DH（Diffie-Hellman），ECDH（Elliptic Curve Diffie-Hellman），ECMQV（Elliptic Curve Menezes-Qu-Vanstone）等。
b. 经过数字信封完成，经常使用算法包括RSA等。

2. 经过KeyAgreement使用DH算法协商密钥
a. DH算法由PKCS#3定义，DH算法需在多方间交换公钥，大素数p，私钥的基数g，和私钥的长度l。设协商密钥的双方为Alice和Bob，则协商共涉及5个阶段:
——————————————————————————————–
i. Alice生成DH公私密钥对
ii. Alice将公钥和算法参数p，g和l发送给Bob
iii. Bob根据算法参数生成本身的公私密钥对，并将公钥发送给Alice
iv. Alice使用本身的私钥和Bob的公钥经过KeyAgreement获得通信密钥
v. Bob使用本身的私钥和Alice的公钥经过KeyAgreement获得与Alice相同的通信密钥

b. 下面的代码演示了使用DH算法实现密钥协商，设通信一方为Alice，另外一方为Bob，分别由两个线程模拟，实际数据交换由共享内存模拟：

/* * @(#)KeyAgreementDemo.java 1.0 2012-4-24 * * Copyright 2010 Richard Chen(utopia_rabbi@sse.buaa.edu.cn) All Rights Reserved. * PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package charpter.security.keyagreement; import java.math.BigInteger; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import javax.crypto.Cipher; import javax.crypto.KeyAgreement; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory; import javax.crypto.interfaces.DHPublicKey; import javax.crypto.spec.DESKeySpec; import javax.crypto.spec.DHParameterSpec; /** * 演示Deffie-Hellman密钥交换组件的用法. * * 密钥交换就是在通信多方间不直接交换通信密钥的状况下而选择一个你们达成一致的密钥. * * @author Rich, 2012-4-24. * @version 1.0 * @since 1.0 */ public class KeyAgreementDemo implements Runnable { /** bob和alice的公钥内容. */ byte bob[], alice[]; /** alice侧是交换的发起方, 是否已启动. */ boolean doneAlice = false; /** 使用计算出来的交换密钥加密过的报文. */ byte[] ciphertext; /** DH算法涉及的算法参数, alice侧的大素数p, alice侧的私钥基数g. */ BigInteger aliceP, aliceG; /** DH算法涉及的算法参数, alice的私钥长度l. */ int aliceL; public synchronized void run() { if (!doneAlice) { doAlice(); doneAlice = true; } else doBob(); } public synchronized void doAlice() { try { // Step 1: Alice generates a key pair KeyPairGenerator kpg = KeyPairGenerator.getInstance("DH"); kpg.initialize(1024); KeyPair kp = kpg.generateKeyPair(); // Step 2: Alice sends the public key and the // Diffie-Hellman key parameters to Bob Class dhClass = Class.forName("javax.crypto.spec.DHParameterSpec"); DHParameterSpec dhSpec = ((DHPublicKey) kp.getPublic()).getParams(); aliceG = dhSpec.getG(); aliceP = dhSpec.getP(); aliceL = dhSpec.getL(); alice = kp.getPublic().getEncoded(); notify(); // Step 4 part 1: Alice performs the first phase of the // protocol with her private key KeyAgreement ka = KeyAgreement.getInstance("DH"); ka.init(kp.getPrivate()); // Step 4 part 2: Alice performs the second phase of the // protocol with Bob's public key while (bob == null) { wait(); } KeyFactory kf = KeyFactory.getInstance("DH"); X509EncodedKeySpec x509Spec = new X509EncodedKeySpec(bob); PublicKey pk = kf.generatePublic(x509Spec); ka.doPhase(pk, true); // Step 4 part 3: Alice can generate the secret key byte secret[] = ka.generateSecret(); // Step 6: Alice converts a secret key SecretKeyFactory skf = SecretKeyFactory.getInstance("DES"); DESKeySpec desSpec = new DESKeySpec(secret); SecretKey key = skf.generateSecret(desSpec); // Step 7: Alice encrypts data with the key and sends // the encrypted data to Bob Cipher c = Cipher.getInstance("DES/ECB/PKCS5Padding"); c.init(Cipher.ENCRYPT_MODE, key); ciphertext = c.doFinal("Stand and unfold yourself".getBytes()); notify(); } catch (Exception e) { e.printStackTrace(); } } public synchronized void doBob() { try { // Step 3: Bob uses the parameters supplied by Alice // to generate a key pair and sends the public key while (alice == null) { wait(); } KeyPairGenerator kpg = KeyPairGenerator.getInstance("DH"); DHParameterSpec dhSpec = new DHParameterSpec(aliceP, aliceG, aliceL); kpg.initialize(dhSpec); KeyPair kp = kpg.generateKeyPair(); bob = kp.getPublic().getEncoded(); notify(); // Step 5 part 1: Bob uses his private key to perform the // first phase of the protocol KeyAgreement ka = KeyAgreement.getInstance("DH"); ka.init(kp.getPrivate()); // Step 5 part 2: Bob uses Alice's public key to perform // the second phase of the protocol. KeyFactory kf = KeyFactory.getInstance("DH"); X509EncodedKeySpec x509Spec = new X509EncodedKeySpec(alice); PublicKey pk = kf.generatePublic(x509Spec); ka.doPhase(pk, true); // Step 5 part 3: Bob generates the secret key byte secret[] = ka.generateSecret(); // Step 6: Bob generates a DES key SecretKeyFactory skf = SecretKeyFactory.getInstance("DES"); DESKeySpec desSpec = new DESKeySpec(secret); SecretKey key = skf.generateSecret(desSpec); // Step 8: Bob receives the encrypted text and decrypts it Cipher c = Cipher.getInstance("DES/ECB/PKCS5Padding"); c.init(Cipher.DECRYPT_MODE, key); while (ciphertext == null) { wait(); } byte plaintext[] = c.doFinal(ciphertext); System.out.println("Bob got the string " + new String(plaintext)); } catch (Exception e) { e.printStackTrace(); } } public static void main(String args[]) { KeyAgreementDemo test = new KeyAgreementDemo(); new Thread(test).start(); // Starts Alice new Thread(test).start(); // Starts Bob } }

以上代码参考了Java Cryptography Extension (JCE) Reference Guide(JDK5.0)中Appendix F的例子。

3. 经过数字信封使用RSA算法协商密钥
数字信封的原理就是利用通信对方的公钥加密目标密钥（session key，对称密钥），使用目标密钥对报文进行加密，而后将密钥密文与报文密文一块儿发送给接收方。接收方首先使用本身的私钥对密钥报文进行解密，这样就获得了协商后的密钥，再使用解密后的密钥解密报文，这样就获得了业务数据。过程图示以下：

数字信封的原理

代码示例以下，密钥协商双方由两个线程模拟：

/* * @(#)DigitalEnvelopeDemo.java 1.0 2012-6-14 * * Copyright 2010 Richard Chen(utopia_rabbi@sse.buaa.edu.cn) All Rights Reserved. * PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package charpter.security.keyagreement; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.Key; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; import java.security.spec.InvalidKeySpecException; import java.security.spec.KeySpec; import java.util.HashMap; import java.util.Map; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import charpter.security.key.KeyGeneratorDemo; /** * 演示使用Digital envelope技术进行密钥交换. *

* 服务器端与客户端分别由两个独立的线程模拟, 双方指间的通信由共享内存实现. * * @author Rich, 2012-6-14. * @version 1.0 * @since 1.0 */ public final class DigitalEnvelopeDemo { /** * @param args */ public static void main(String[] args) { KeyPair pair = generatorKeyPair(); Thread client = new Client(pair); Thread server = new Server(pair.getPublic()); server.start(); client.start(); } /** * 生成RSA算法的公私密钥对. * * @return 生成RSA算法的公私密钥对. */ public static final KeyPair generatorKeyPair() { KeyPairGenerator keyGen = null; try { keyGen = KeyPairGenerator.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { throw new RuntimeException(e); } SecureRandom random = null; try { random = SecureRandom.getInstance("SHA1PRNG"); } catch (Exception e) { throw new RuntimeException(e); } random.setSeed(53); keyGen.initialize(1024, random); KeyPair pair = keyGen.generateKeyPair(); return pair; } /** * 模拟密钥交换的服务器端, 服务器端与客户端经过共享内存来交换Digital Envelope. * * @author Rich, 2012-6-14. * @version 1.0 * @since 1.0 */ static class Server extends Thread { /** * 实际中有多是客户端在请求服务器端时上送了本身的公钥, 也有多是在注册 * 时就在服务器端登记了公钥. * * @param clientPublicKey 客户端的公钥. */ public Server(PublicKey clientPublicKey) { this.clientPublicKey = clientPublicKey; } /* (non-Javadoc) * @see java.lang.Thread#run() */ @Override public void run() { try { String msg = "Legend of AK47"; Key sessionKey = KeyGeneratorDemo.generatePlainDES(); Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, sessionKey); byte[] p = msg.getBytes("UTF-8"); byte[] msgCipher = cipher.doFinal(p); cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, clientPublicKey); byte[] keyCipher = cipher.doFinal(sessionKey.getEncoded()); Mapresult = new HashMap(); result.put("msg", msgCipher); result.put("key", keyCipher); CHANNEL.offer(result); } catch (KeyException e) { // TODO Exception handling... } } /** 客户端的公钥. */ private final PublicKey clientPublicKey; } /** * 模拟密钥交换的客户端, 服务器端与客户端经过共享内存来交换Digital Envelope. * * @author Rich, 2012-6-14. * @version 1.0 * @since 1.0 */ static class Client extends Thread { /** * 密钥对应该在客户端内部产生, 而后客户端在请求服务器端时上送了本身的公钥, 也有多是在注册时就在服务器端登记了公钥. * * @param keyPair 客户端的公私密钥对. */ public Client(KeyPair keyPair) { this.keyPair = keyPair; } /* * (non-Javadoc) * * @see java.lang.Thread#run() */ @Override public void run() { try { Mapreceived = CHANNEL.take(); byte[] msgCipher = received.get("msg"); byte[] keyCipher = received.get("key"); PrivateKey privateKey = keyPair.getPrivate(); Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] encoded = cipher.doFinal(keyCipher); KeySpec keySpec = new DESKeySpec(encoded); SecretKeyFactory fac = SecretKeyFactory.getInstance("DES"); Key key = fac.generateSecret(keySpec); cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); cipher.init(Cipher.DECRYPT_MODE, key); byte[] msg = cipher.doFinal(msgCipher); String plainText = new String(msg, "UTF-8"); System.out.println(plainText); } catch (Exception e) { // TODO Exception handling... } } /** 客户端的公私密钥对. */ private final KeyPair keyPair; } /** Client端与Server端交换数据的队列, 模拟二者之间通信的通道, 现实中二者多是经过Socket通信的. */ private static final BlockingQueue> CHANNEL = new LinkedBlockingQueue>(1); }

KeyAgreement的DH与数字信封的RSA比较：
——————————————————————————————–
a. DH仅限于交换共享密钥，而没法对交换双方的身份进行认证，易受中间人攻击
b. RSA能够用于交换共享密钥也能够用于身份认证
c. 建议：在双方都有数字证书时，使用RSA，一方或两方都没有数字证书则使用Diffie-Hellman，SSL3.0就是采用的此策略

五. 总结
JCE中最经常使用和最核心的功能就是加解密，此功能由Cipher组件提供，在使用Cipher前需对加密算法及参数先作出选择：
1. 算法选择
对称算法通常速度较快，非对称算法速度较慢；对称算法的密钥管理比较困难，非对称算法密钥管理简单；非对称算法通常用于认证和加密会话密钥，通信双方大部分也就是在开启会话时使用一次，对称算法通常用来加密双方之间的报文/交换的数据，使用频度较高。

2. 块/流模式选择
块（Block）模式加密以块为基本单位，适用于明文长度已知的情形；流（Stream）模式以bit或byte为加解密单位, 适用于明文长度未知、内容较大的情形，如加密一个套接字管道或文件读写流等，通常仅适用于硬件实现。块模式下不一样算法的块大小可能不同，通常都是2的次方数，大部分长度为64bits，整个明文长度不是块长度整倍数时，需在最后一个Block进行补长（Padding）

3. 反馈模式选择
使用块算法加密，若是明文有大量重复的内容，则对块加密后获得的密文也会存在大量的重复，这对密文分析、破解提供了极大的便利，为消除这方面的威胁，有个思路就是对不一样块密文再进行运算，这样就极大去除了块密文与块明文几间的特征关联，这种作法称为块反馈模式。常见的反馈模式有：ECB、CBC、CFB、OFB等。对于第1个block，因没有其它块密文可供运算，有的模式引入了初始矢量（Initialization Vector，IV，由用户指定）做为第1个block内容，这样就进一步解决了第1个block密文的脆弱性。注意：尽可能不要使用ECB模式。

4. 补长方案选择
下面是一些常见的补长（Padding）方案，以DES算法加密明文for为例，因for不足8bytes，因此需补长5bytes（for ?? ?? ?? ?? ??），则这5bytes可能选择（16进制）:
——————————————————————————————–
i. 全部Padding以长度为值：66 6F 72 05 05 05 05 05
ii. Padding以0×80开始后面所有为0×00：66 6F 72 80 00 00 00 00
iii. 最后一个字节为Padding长度, 其它为0×00：66 6f 72 00 00 00 00 05
iv. 所有Padding为0×00：66 6f 72 00 00 00 00 00
v. 所有Padding为0×20（空格）：66 6f 72 20 20 20 20 20

JCE中支持的补长方案包括：NoPadding、PKCS5Padding、ISO10126Padding、OAEPWithAndPadding和SSL3Padding，NoPadding即不补长，其中最经常使用的就是PKCS5Padding和ISO10126Padding。

PKCS5Padding，具体规范请参考RSA实验室的文档：PKCS #5 Password-Based Encryption Standard，Version 1.5。简单的说PKCS5Padding就2个规则：
——————————————————————————————–
i. 补长的内容为待补长字节数
ii. 补长的字节数为：8 – 明文长度 % 8，即补长长度在1至8bytes之间
如前述的明文for将补长为：66 6F 72 05 05 05 05 05

ISO10126Padding，具体规范请参考ISO 10126。简单的说ISO10126Padding就是补长的长度做为补长内容的最后一个byte，以前的补长内容为随机数。如前述的明文for可能补长为：66 6F 72 2A 75 EF F8 05

7. 密钥的选择
密钥可使用KeyGenerator/KeyPairGenerator生成，也能够由外部导入，还能够有密钥参数构造KeySpec再转换为Key。

6. 密钥长度选择
对于对称加密算法，128bits的密钥足够安全，条件许可请选择256bits，注意密钥长度大于128bits需单独下载并安装jurisdiction policy files；对于非对称加密算法，1024bits的密钥足够安全。

最后，如选用基于口令的算法或在用户输入密码时，请避免使用String来引用，使用char[]，用完马上置空char[]，避免内存攻击，如heap dump分析等。

参考连接：http://www.ithao123.cn/content-10346659.html