用 Kerberos 为 J2ME 应用程序上锁（2）

核心提示：利用用户密码生成密钥Kerberos 定义了一种对用户密码进行处理以生成一个 密钥 的算法，在获得 TGT 的过程中 Kerberos 客户机将用这个密钥进行解密对这个基于 J2ME 的 Kerberos 客户机，用 Kerberos 为 J2ME 应用程序上锁（2），我将只支持一种加密算法，即 CBC（密码分组链接

　　利用用户密码生成密钥
　　Kerberos 定义了一种对用户密码进行处理以生成一个 密钥 的算法。在获得 TGT 的过程中 Kerberos 客户机将用这个密钥进行解密
　　
　　对这个基于 J2ME 的 Kerberos 客户机，我将只支持一种加密算法，即 CBC（密码分组链接 cipher block chaining）模式下的 DES（数据加密标准）。DES 是一个 FIPS（联邦信息处理标准 Federal Information PRocessing Standards）发表，它描述了一种将要加密的数据（纯文本）和密钥作为输入传递给加密过程的加密算法。根据 DES 算法对密钥和纯文本统一处理以生成一个加密的（密文）形式的纯文本数据。（有关 DES 的更多信息请参阅 参考资料 ）。
　　
　　CBC 是一种加密操作模式，其中纯文本数据分为同样大小的数据块。例如，在 64 位 DES-CBC 加密中，数据会分为 8 字节的块。假如纯文数据中的字节数不是您希望每一个块所具有的字节数的整数倍，就要在最后一块中加上适当的数量的字节以使它的大小与其他的块相同。
　　
　　然后创建一个与您的块具有同样大小的字节数组。这个字节数组称为 初始矢量 (IV)。Kerveros 规范定义了所有基于 Kerberos 的应用程序的初始矢量（类似地，其他使用 DES-CBC 的规范定义了它们使用的 IV 值）。之后，取这个 IV、纯文数据的第一块以及密钥并根据 DES 算法对它们共同进行处理，以构成对应于纯文本数据第一个数据块的密文。然后取第一个数据块的密文形式作为第二个块的初始矢量并进行同样的 DES 加密过程以生成第二个纯文本数据块的密文形式。以这种方式继续一块接一块地生成每一个块的密文形式。最后，串接所有密文块以得到全部纯文本数据的密文形式。
　　
　　因为我只打算在这个 Kerberos 客户机中支持 DES-CBC，所以我将只讨论 DES-CBC 所使用的密钥的生成过程，如下所示：
　　
　　将用户密码、KDC 域名和用户的用户名串接到一起以构成一个字符串。Kerberos 利用这个串接的字符串而不仅仅是密码生成密钥。为什么要在密钥生成中加入域名和用户名呢？许多用户会在不同的服务器上使用同样的密码。假如我只使用密码生成密钥，那么一个给定的密码在所有 Kerberos 服务器上总是会生成同样的密钥。因而，假如一个黑客可以取得用户在一台 Kerberos 服务器上的密钥，那么，他就可以在所有 Kerberos 服务器上使用同一个密钥。另一方面，假如我加入了域名和用户名，那么一个受到这种攻击的密钥将只会侵害特定的域。
　　
　　得到第 1 步中串接的字符串的字节数组表达。
　　
　　统计第 2 步中字节数组中的字节数。在这个字节串的后面附加适当数量的零字节以使它成为 8 的整数倍。例如，假如这个字节数组包含 53 个字节，那么就在这个字节数组的最后附加三个字节使它具有 56 个字节。
　　
　　将第 3 步中附加了字节后的字节数组分为大小相同的块，每一块有 8 个字节。
　　
　　每隔一个块倒转块的位顺序。换句话说，第一块保持不变，第二块的位顺序应该倒转，第三块应保持不变，第中块的位顺序应倒转，以此类推。
　　
　　取第一个（未改变的）块并与第二个（倒转的）块进行每一位的 exclusive OR。然后将第一次 exclusive OR 操作得到的结果与第三个（未改变的）块进行另一次 exclusive OR 操作。继续 exclusive OR 操作直到完成了所有块。所有 exclusive OR 操作的最后结果是一个 8 字节长的块。
　　
　　修正在第 6 步中得到的 8 字节块的奇偶性。每一块的最低有效位保留为奇偶位。统计 8 字节块中每字节中的 1 的个数，假如 1 的个数为偶数，那么就设置最低位为 1 使它成为奇数。例如，假如一个字节的值为 00000000，那么就要将它改为 00000001。假如一个字节中 1 的个数已经为奇数，那么就将它的最低位设置为零。例如，假如一个字节为 00000010，那么就不需要为修正其奇偶性做任何改变。
　　
　　DES 定义了一些弱的、因而不适合用于加密的密钥。我们的密钥生成过程的第八步是要检查奇偶修正后的字节数组是否是一个弱的密钥。假如是的话，就要用 0xf0（11110000）与奇偶修正过的 8 字节块进行 exclusive OR。假如奇偶修正得到的不是弱密钥，那么就不需要进行这种 exclusive OR 操作。经过这种弱密钥处理的字节数组是一个临时密钥。
　　
　　现在我要使用这个临时密钥以 DES-CBC 算法加密第 3 步中得到的附加后的字节数组。这个临时密钥同时作为密钥的值和 DES-CBC 加密的初始矢量的值。回想在前面的讨论中说过，CBC 要求密文块链接。第 9 步的结果是最后 8 字节块的加密结果（放弃所以以前的密文块）。因此，这一步的结果是另一个 8 字节块。
　　
　　现在我修正第 9 步产生的 8 字节块中的每一个字节的奇偶性。在上面第 7 步中我解释了奇偶性修正。
　　
　　现在再次检查第 10 步得到的经过奇偶修正的 8 字节块是不是弱密钥（就像在第 8 步中所做的那样）。
　　第 11 步的结果是一个 Kerveros 客户机可以用来与 Kerberos 服务器进行通信的密钥。
　　
　　现在看一下清单 11 中的 KerberosKey 类。这个类的 generateKey() 方法实现了上面描述的 11 步密钥生成算法。
　　
　　清单 11. KerberosKey 类
　　
　　import org.bouncycastle.crypto.params.ParametersWithRandom;
　　import org.bouncycastle.crypto.modes.CBCBlockCipher;
　　import org.bouncycastle.crypto.generators.DESKeyGenerator;
　　import org.bouncycastle.crypto.params.DESParameters;
　　import org.bouncycastle.crypto.engines.DESEngine;
　　import org.bouncycastle.crypto.params.KeyParameter;
　　import org.bouncycastle.crypto.params.ParametersWithIV;
　　
　　public class KerberosKey
　　{
　　　　private CBCBlockCipher cipher;
　　　　private KeyParameter kp;
　　　　private ParametersWithIV iv;
　　　　private byte kerberosKey[];
　　　　private ASN1DataTypes asn1;
　　　　private String principalID;
　　
　　　　public KerberosKey(String userName, String passWord, String realmName)
　　　　{
　　　　　　kerberosKey = new byte[8];
　　　　　　kerberosKey = generateKey (password, realmName, userName);
　　　　}//KerberosKey
　　
　　　　public byte[] generateKey (String password, String realmName, String userName)
　　　　{
　　　　　　//Step 1:
　　　　　　String str = new String (password + realmName + userName);
　　　　　　byte secretKey [] = new byte[8];
　　
　　　　　　//Step 2:
　　　　　　byte encodedByteArray[] = encodeString(str);
　　
　　　　　　//Step 3:
　　　　　　byte paddedByteArray[] = padString(encodedByteArray);
　　
　　　　　　//Step 4:
　　　　　　int i = paddedByteArray.length / 8;
　　
　　　　　　//Step 5:
　　　　　　for(int x=0; x<i; x++)
　　　　　　{
　　　　　　　　byte blockValue1[] = new byte [8];
　　　　　　　　System.arraycopy (paddedByteArray, x*8, blockValue1, 0, 8);
　　
　　　　　　　　if(x % 2 == 1)
　　　　　　　　{
　　　　　　　　　　byte tempbyte1 = 0;
　　　　　　　　　　byte tempbyte2 = 0;
　　　　　　　　　　byte blockValue2[] = new byte [8];
　　
　　　　　　　　　　for (int y=0; y<8; y++)
　　　　　　　　　　{
　　　　　　　　　　　　tempbyte2 = 0;
　　　　　　　　　　　　for (int z=0; z<4; z++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　tempbyte2 = (byte) ((1<<(7-z)) & 0xff);
　　　　　　　　　　　　　　tempbyte1 = (blockValue1[y] & tempbyte2) >>> (7-2*z);
　　　　　　　　　　　　　　tempbyte2 = 0;
　　　　　　　　　　　　}
　　　　　　　　　　　　for (int z=4; z<8; z++)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　tempbyte2 = (byte) ((1<<(7-z)) & 0xff);
　　　　　　　　　　　　　　tempbyte1 = (blockValue1[y] & tempbyte2) << (2*z-7);
　　　　　　　　　　　　　　tempbyte2 = 0;
　　　　　　　　　　　　}
　　　　　　　　　　　　blockValue2 [7-y] = tempbyte1;
　　　　　　　　　　　　tempbyte1 = 0;
　　　　　　　　　　}//outer for
　　
　　　　　　　　　　for (int a = 0; a <8; a ++)
　　　　　　　　　　　　blockValue2[a] = (byte) ((((byte)blockValue2[a] & 0xff) >>> 1) & 0xff);
　　
　　　　　　　　　　System.arraycopy(blockValue2, 0, blockValue1, 0, blockValue2.length);
　　　　　　　　}//if(x % 2 == 1)
　　
　　　　　　　　for (int a = 0; a <8; a ++)
　　　　　　　　　　blockValue1[a] = (byte) ((((byte)blockValue1[a] & 0xff) << 1) & 0xff);
　　
　　　　　　　　//Step 6:
　　　　　　　　for (int b = 0; b <8; b ++)
　　　　　　　　　　secretKey[b] ^= blockValue1[b];
　　　　　　}// for
　　
　　　　　　//Step 7:
　　　　　　secretKey= setParity(secretKey);
　　
　　　　　　//Step 8:
　　　　　　if (isWeakKey(secretKey))
　　　　　　　　secretKey = getStrongKey(secretKey);
　　
　　　　　　//Step 9:
　　　　　　secretKey = getFinalKey(paddedByteArray, secretKe