1 實驗内容 掌握分組密碼算法DES方法,能用進階語言實作分組密碼算法DES。DES算法為密碼體制中的對稱密碼體制，又被成為美國資料加密标準，是1972年美國IBM公司研制的對稱密碼體制加密算法。 明文按64位進行分組, 密鑰長64位，密鑰事實上是56位參與DES運算（第8、16、24、32、40、48、56、64位是校驗位， 使得每個密鑰都有奇數個1）分組後的明文組和56位的密鑰按位替代或交換的方法形成密文組的加密方法。 2 分組密碼算法DES算法的基本原理 其入口參數有三個:key、data、mode。 key為加密解密使用的密鑰，data為加密 des算法結構解密的資料，mode為其工作模式。當模式為加密模式時，明文按照64位進行分組，形成明文組，key用于對資料加密，當模式為解密模式時，key用于對資料解密。實際運用中，密鑰隻用到了64位中的56位，這樣才具有高的安全性 2.1 分組密碼算法DES算法概述 2.2 分組密碼算法DES算法流程 DES算法把64位的明文輸入塊變為64位的密文輸出塊，它所使用的密鑰也是64位，整個算法 des算法流程圖的主流程圖如下
全部源代碼下載下傳：
http://down.51cto.com/data/433704
部分源代碼：
//密鑰
- public class GetSubKey {
- private String inKey;
- private StringBuffer keyBuf;
- private byte[] key = new byte[64]; // 儲存密鑰的64位二進制表示
- private byte[] kwork = new byte[56];
- private static byte[] shift = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2,
- 2, 1 };
- protected byte[] k1 = new byte[48];
- protected byte[] k2 = new byte[48];
- protected byte[] k3 = new byte[48];
- protected byte[] k4 = new byte[48];
- protected byte[] k5 = new byte[48];
- protected byte[] k6 = new byte[48];
- protected byte[] k7 = new byte[48];
- protected byte[] k8 = new byte[48];
- protected byte[] k9 = new byte[48];
- protected byte[] k10 = new byte[48];
- protected byte[] k11 = new byte[48];
- protected byte[] k12 = new byte[48];
- protected byte[] k13 = new byte[48];
- protected byte[] k14 = new byte[48];
- protected byte[] k15 = new byte[48];
- protected byte[] k16 = new byte[48];
- protected byte[] kn = new byte[48];
- public GetSubKey(String inKey) {
- byte j;
- this.inKey = inKey;
- int len = inKey.length();
- keyBuf = new StringBuffer(inKey);
- if (len < 8) { // 密鑰必須是8位，若小于8位不夠的補空格 ，大于8位取前8位
- for (int i = 1; i <= 8 - len; i++)
- keyBuf.append("?");
- }
- inKey = keyBuf.toString();
- // 将8個字元的密鑰轉換成64位二進制表示
- for (int i = 0; i < 8; i++) {
- j = (byte) (inKey.charAt(i));
- key[8 * i] = (byte) ((j / 128) % 2);
- key[8 * i + 1] = (byte) ((j / 64) % 2);
- key[8 * i + 2] = (byte) ((j / 32) % 2);
- key[8 * i + 3] = (byte) ((j / 16) % 2);
- key[8 * i + 4] = (byte) ((j / 8) % 2);
- key[8 * i + 5] = (byte) ((j / 4) % 2);
- key[8 * i + 6] = (byte) ((j / 2) % 2);
- key[8 * i + 7] = (byte) (j % 2);
- }
- // 初始化鍵的排列順序
- kwork[0] = key[56];
- kwork[1] = key[48];
- kwork[2] = key[40];
- kwork[3] = key[32];
- kwork[4] = key[24];
- kwork[5] = key[16];
- kwork[6] = key[8];
- kwork[7] = key[0];
- kwork[8] = key[57];
- kwork[9] = key[49];
- kwork[10] = key[41];
- kwork[11] = key[33];
- kwork[12] = key[25];
- kwork[13] = key[17];
- kwork[14] = key[9];
- kwork[15] = key[1];
- kwork[16] = key[58];
- kwork[17] = key[50];
- kwork[18] = key[42];
- kwork[19] = key[34];
- kwork[20] = key[26];
- kwork[21] = key[18];
- kwork[22] = key[10];
- kwork[23] = key[2];
- kwork[24] = key[59];
- kwork[25] = key[51];
- kwork[26] = key[43];
- kwork[27] = key[35];
- kwork[28] = key[62];
- kwork[29] = key[54];
- kwork[30] = key[46];
- kwork[31] = key[38];
- kwork[32] = key[30];
- kwork[33] = key[22];
- kwork[34] = key[14];
- kwork[35] = key[6];
- kwork[36] = key[61];
- kwork[37] = key[53];
- kwork[38] = key[45];
- kwork[39] = key[37];
- kwork[40] = key[29];
- kwork[41] = key[21];
- kwork[42] = key[13];
- kwork[43] = key[5];
- kwork[44] = key[60];
- kwork[45] = key[52];
- kwork[46] = key[44];
- kwork[47] = key[36];
- kwork[48] = key[28];
- kwork[49] = key[20];
- kwork[50] = key[12];
- kwork[51] = key[4];
- kwork[52] = key[27];
- kwork[53] = key[19];
- kwork[54] = key[11];
- kwork[55] = key[3];
- /* 開始計算子鍵 */
- byte nbrofshift;
- byte temp1, temp2;
- for (int iter = 0; iter < 16; iter++) {
- nbrofshift = shift[iter];
- for (int i = 0; i < (int) nbrofshift; i++) {
- temp1 = kwork[0];
- temp2 = kwork[28];
- for (int k = 0; k < 27; k++) {
- kwork[k] = kwork[k + 1];
- kwork[k + 28] = kwork[k + 29];
- }
- kwork[27] = temp1;
- kwork[55] = temp2;
- }
- /* Permute kwork - PC2 */
- kn[0] = kwork[13];
- kn[1] = kwork[16];
- kn[2] = kwork[10];
- kn[3] = kwork[23];
- kn[4] = kwork[0];
- kn[5] = kwork[4];
- kn[6] = kwork[2];
- kn[7] = kwork[27];
- kn[8] = kwork[14];
- kn[9] = kwork[5];
- kn[10] = kwork[20];
- kn[11] = kwork[9];
- kn[12] = kwork[22];
- kn[13] = kwork[18];
- kn[14] = kwork[11];
- kn[15] = kwork[3];
- kn[16] = kwork[25];
- kn[17] = kwork[7];
- kn[18] = kwork[15];
- kn[19] = kwork[6];
- kn[20] = kwork[26];
- kn[21] = kwork[19];
- kn[22] = kwork[12];
- kn[23] = kwork[1];
- kn[24] = kwork[40];
- kn[25] = kwork[51];
- kn[26] = kwork[30];
- kn[27] = kwork[36];
- kn[28] = kwork[46];
- kn[29] = kwork[54];
- kn[30] = kwork[29];
- kn[31] = kwork[39];
- kn[32] = kwork[50];
- kn[33] = kwork[44];
- kn[34] = kwork[32];
- kn[35] = kwork[47];
- kn[36] = kwork[43];
- kn[37] = kwork[48];
- kn[38] = kwork[38];
- kn[39] = kwork[55];
- kn[40] = kwork[33];
- kn[41] = kwork[52];
- kn[42] = kwork[45];
- kn[43] = kwork[41];
- kn[44] = kwork[49];
- kn[45] = kwork[35];
- kn[46] = kwork[28];
- kn[47] = kwork[31];
- switch (iter) {
- case 0:
- for (int k = 0; k < 48; k++) {
- k1[k] = kn[k];
- }
- break;
- case 1:
- for (int k = 0; k < 48; k++) {
- k2[k] = kn[k];
- }
- break;
- case 2:
- for (int k = 0; k < 48; k++) {
- k3[k] = kn[k];
- }
- break;
- case 3:
- for (int k = 0; k < 48; k++) {
- k4[k] = kn[k];
- }
- break;
- case 4:
- for (int k = 0; k < 48; k++) {
- k5[k] = kn[k];
- }
- break;
- case 5:
- for (int k = 0; k < 48; k++) {
- k6[k] = kn[k];
- }
- break;
- case 6:
- for (int k = 0; k < 48; k++) {
- k7[k] = kn[k];
- }
- break;
- case 7:
- for (int k = 0; k < 48; k++) {
- k8[k] = kn[k];
- }
- break;
- case 8:
- for (int k = 0; k < 48; k++) {
- k9[k] = kn[k];
- }
- break;
- case 9:
- for (int k = 0; k < 48; k++) {
- k10[k] = kn[k];
- }
- break;
- case 10:
- for (int k = 0; k < 48; k++) {
- k11[k] = kn[k];
- }
- break;
- case 11:
- for (int k = 0; k < 48; k++) {
- k12[k] = kn[k];
- }
- break;
- case 12:
- for (int k = 0; k < 48; k++) {
- k13[k] = kn[k];
- }
- break;
- case 13:
- for (int k = 0; k < 48; k++) {
- k14[k] = kn[k];
- }
- break;
- case 14:
- for (int k = 0; k < 48; k++) {
- k15[k] = kn[k];
- }
- break;
- case 15:
- for (int k = 0; k < 48; k++) {
- k16[k] = kn[k];
- }
- break;
- }
- }
- }
- }