题目
[实验任务一]：加密算法
目前常用的加密算法有DES（Data Encryption Standard）和IDEA（International Data Encryption Algorithm）国际数据加密算法等，请用工厂方法实现加密算法系统。
类图
Java
方法抽象类
package com.gazikel;
public interface Method {
public abstract void work(String str, String password);
}
方法工厂抽象类
package com.gazikel;
public interface MethodFactory {
public Method produceMethod();
}
方法实现
DES
package com.gazikel;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
public class DES implements Method {
public void work(String str, String password) {
// String codeStringBegin = "信1905-2 20194077 郭智昊"; // 要加密的明文
String codeStringEnd = null; // 加密后的密文
String decodeString = null; // 密文解密后得到的明文
System.out.println("要加密的明文:" + str);
String cipherType = "DESede"; // 加密算法类型，可设置为DES、DESede、AES等字符串
try {
// 获取密钥生成器
KeyGenerator keyGen = KeyGenerator.getInstance(cipherType);
// 初始化密钥生成器，不同的加密算法其密钥长度可能不同
keyGen.init(112);
// 生成密钥
SecretKey key = keyGen.generateKey();
// 得到密钥字节码
byte[] keyByte = key.getEncoded();
// 输出密钥的字节码
System.out.println("密钥是：");
for (int i = 0; i < keyByte.length; i++) {
System.out.print(keyByte[i] + ",");
}
System.out.println("");
// 创建密码器
Cipher cp = Cipher.getInstance(cipherType);
// 初始化密码器
cp.init(Cipher.ENCRYPT_MODE, key);
System.out.println("要加密的字符串是：" + str);
byte[] codeStringByte = str.getBytes("UTF8");
System.out.println("要加密的字符串对应的字节码是：");
for (int i = 0; i < codeStringByte.length; i++) {
System.out.print(codeStringByte[i] + ",");
}
System.out.println("");
// 开始加密
byte[] codeStringByteEnd = cp.doFinal(codeStringByte);
System.out.println("加密后的字符串对应的字节码是：");
for (int i = 0; i < codeStringByteEnd.length; i++) {
System.out.print(codeStringByteEnd[i] + ",");
}
System.out.println("");
codeStringEnd = new String(codeStringByteEnd);
System.out.println("加密后的字符串是：" + codeStringEnd);
System.out.println("");
// 重新初始化密码器
cp.init(Cipher.DECRYPT_MODE, key);
// 开始解密
byte[] decodeStringByteEnd = cp.doFinal(codeStringByteEnd);
System.out.println("解密后的字符串对应的字节码是：");
for (int i = 0; i < decodeStringByteEnd.length; i++) {
System.out.print(decodeStringByteEnd[i] + ",");
}
System.out.println("");
decodeString = new String(decodeStringByteEnd);
System.out.println("解密后的字符串是：" + decodeString);
System.out.println("");
} catch (Exception e) {
e.printStackTrace();
}
}
}
IDEA
package com.gazikel;
import com.gazikel.Method;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.Security;
public class IDEA implements Method {
public static final String KEY_ALGORITHM = "IDEA";
public static final String CIPHER_ALGORITHM = "IDEA/ECB/ISO10126Padding";
public static byte[] initkey() throws Exception {
// 加入bouncyCastle支持
Security.addProvider(new BouncyCastleProvider());
// 实例化密钥生成器
KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
// 初始化密钥生成器，IDEA要求密钥长度为128位
kg.init(128);
// 生成密钥
SecretKey secretKey = kg.generateKey();
// 获取二进制密钥编码形式
return secretKey.getEncoded();
}
/**
* 转换密钥
*
* @param key
* 二进制密钥
* @return Key 密钥
*/
private static Key toKey(byte[] key) throws Exception {
// 实例化DES密钥
// 生成密钥
SecretKey secretKey = new SecretKeySpec(key, KEY_ALGORITHM);
return secretKey;
}
/**
* 加密数据
*
* @param data
* 待加密数据
* @param key
* 密钥
* @return byte[] 加密后的数据
*/
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
// 加入bouncyCastle支持
Security.addProvider(new BouncyCastleProvider());
// 还原密钥
Key k = toKey(key);
// 实例化
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
// 初始化，设置为加密模式
cipher.init(Cipher.ENCRYPT_MODE, k);
// 执行操作
return cipher.doFinal(data);
}
/**
* 解密数据
*
* @param data
* 待解密数据
* @param key
* 密钥
* @return byte[] 解密后的数据
*/
private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
// 加入bouncyCastle支持
Security.addProvider(new BouncyCastleProvider());
// 还原密钥
Key k = toKey(key);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
// 初始化，设置为解密模式
cipher.init(Cipher.DECRYPT_MODE, k);
// 执行操作
return cipher.doFinal(data);
}
public static String getKey() {
String result = null;
try {
result = Base64.encodeBase64String(initkey());
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public static String ideaEncrypt(String data, String key) {
String result = null;
try {
byte[] data_en = encrypt(data.getBytes(), Base64.decodeBase64(key));
result = Base64.encodeBase64String(data_en);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public static String ideaDecrypt(String data, String key) {
String result = null;
try {
byte[] data_de = decrypt(Base64.decodeBase64(data), Base64.decodeBase64(key));
;
result = new String(data_de);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public void work(String str, String password) {
String key = getKey();
System.out.println("要加密的原文：" + str);
System.out.println("密钥：" + key);
String data_en = ideaEncrypt(str, key);
System.out.println("密文：" + data_en);
String data_de = ideaDecrypt(data_en, key);
System.out.println("原文：" + data_de);
}
}
工厂实现
DESFactory
package com.gazikel;
public class DesFactory implements MethodFactory {
@Override
public DES produceMethod() {
System.out.println("使用DES算法");
return new DES();
}
}
IDEAFactory
package com.gazikel;
public class IdeaFactory implements MethodFactory {
@Override
public IDEA produceMethod() {
System.out.println("使用IDEA算法");
return new IDEA();
}
}
Test
package com.gazikel;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
DES des = new DES();
IDEA idea = new IDEA();
try {
int n = 0;
Scanner in = new Scanner(System.in);
while (n != 3) {
System.out.println("请选择要使用的加密算法 1.DES加密算法 2.IDEA加密算法");
System.out.println("3.退出");
System.out.println("请选择：");
if (in.hasNextInt()) {
n = in.nextInt();
} else {
System.out.println("输入的不是整数，请重新输入：");
continue;
}
switch (n) {
case 1: {
des.work("信1905-2 20194077 郭智昊", "0E329232EA6D0D73");
break;
}
case 2: {
idea.work("信1905-2 20194077 郭智昊", "0E329232EA6D0D73");
break;
}
}
}
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
C++
main.cpp
#include<iostream>
#include<bitset>
#include<string>
#include<fstream>
using namespace std;
class Method {
public:
virtual void work() = 0;
};
class DES :public Method {
private:
bitset<64> key; // 64位密钥
bitset<48> subKey[16]; // 存放16轮子密钥
// 初始置换表
int IP[64] = { 58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7 };
// 结尾置换表
int IP_1[64] = { 40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25 };
/*------------------下面是生成密钥所用表-----------------*/
// 密钥置换表，将64位密钥变成56位
int PC_1[56] = { 57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4 };
// 压缩置换，将56位密钥压缩成48位子密钥
int PC_2[48] = { 14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32 };
// 每轮左移的位数
int shiftBits[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
/*------------------下面是密码函数 f 所用表-----------------*/
// 扩展置换表，将 32位 扩展至 48位
int E[48] = { 32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1 };
// S盒，每个S盒是4x16的置换表，6位 -> 4位
int S_BOX[8][4][16] = {
{
{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}
},
{
{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}
},
{
{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}
},
{
{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}
},
{
{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}
},
{
{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}
},
{
{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}
},
{
{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}
}
};
// P置换，32位 -> 32位
int P[32] = {16,7,20,21,
29,12,28,17,
1,15,23,26,
5,18,31,10,
2,8,24,14,
32,27,3,9,
19,13,30,6,
22,11,4,25};
public:
/**
* 密码函数f，接收32位数据和48位子密钥，产生一个32位的输出
*/
bitset<32> f(bitset<32> R, bitset<48> k)
{
bitset<48> expandR;
// 第一步：扩展置换，32 -> 48
for (int i = 0; i < 48; ++i)
expandR[47 - i] = R[32 - E[i]];
// 第二步：异或
expandR = expandR ^ k;
// 第三步：查找S_BOX置换表
bitset<32> output;
int x = 0;
for (int i = 0; i < 48; i = i + 6)
{
int row = expandR[47 - i] * 2 + expandR[47 - i - 5];
int col = expandR[47 - i - 1] * 8 + expandR[47 - i - 2] * 4 + expandR[47 - i - 3] * 2 + expandR[47 - i - 4];
int num = S_BOX[i / 6][row][col];
bitset<4> binary(num);
output[31 - x] = binary[3];
output[31 - x - 1] = binary[2];
output[31 - x - 2] = binary[1];
output[31 - x - 3] = binary[0];
x += 4;
}
// 第四步：P-置换，32 -> 32
bitset<32> tmp = output;
for (int i = 0; i < 32; ++i)
output[31 - i] = tmp[32 - P[i]];
return output;
}
/**
* 对56位密钥的前后部分进行左移
*/
bitset<28> leftShift(bitset<28> k, int shift)
{
bitset<28> tmp = k;
for (int i = 27; i >= 0; --i)
{
if (i - shift < 0)
k[i] = tmp[i - shift + 28];
else
k[i] = tmp[i - shift];
}
return k;
}
/**
* 生成16个48位的子密钥
*/
void generateKeys()
{
bitset<56> realKey;
bitset<28> left;
bitset<28> right;
bitset<48> compressKey;
// 去掉奇偶标记位，将64位密钥变成56位
for (int i = 0; i < 56; ++i)
realKey[55 - i] = key[64 - PC_1[i]];
// 生成子密钥，保存在 subKeys[16] 中
for (int round = 0; round < 16; ++round)
{
// 前28位与后28位
for (int i = 28; i < 56; ++i)
left[i - 28] = realKey[i];
for (int i = 0; i < 28; ++i)
right[i] = realKey[i];
// 左移
left = leftShift(left, shiftBits[round]);
right = leftShift(right, shiftBits[round]);
// 压缩置换，由56位得到48位子密钥
for (int i = 28; i < 56; ++i)
realKey[i] = left[i - 28];
for (int i = 0; i < 28; ++i)
realKey[i] = right[i];
for (int i = 0; i < 48; ++i)
compressKey[47 - i] = realKey[56 - PC_2[i]];
subKey[round] = compressKey;
}
}
/**
* 工具函数：将char字符数组转为二进制
*/
bitset<64> charToBitset(const char s[8])
{
bitset<64> bits;
for (int i = 0; i < 8; ++i)
for (int j = 0; j < 8; ++j)
bits[i * 8 + j] = ((s[i] >> j) & 1);
return bits;
}
/**
* DES加密
*/
bitset<64> encrypt(bitset<64>& plain)
{
bitset<64> cipher;
bitset<64> currentBits;
bitset<32> left;
bitset<32> right;
bitset<32> newLeft;
// 第一步：初始置换IP
for (int i = 0; i < 64; ++i)
currentBits[63 - i] = plain[64 - IP[i]];
// 第二步：获取 Li 和 Ri
for (int i = 32; i < 64; ++i)
left[i - 32] = currentBits[i];
for (int i = 0; i < 32; ++i)
right[i] = currentBits[i];
// 第三步：共16轮迭代
for (int round = 0; round < 16; ++round)
{
newLeft = right;
right = left ^ f(right, subKey[round]);
left = newLeft;
}
// 第四步：合并L16和R16，注意合并为 R16L16
for (int i = 0; i < 32; ++i)
cipher[i] = left[i];
for (int i = 32; i < 64; ++i)
cipher[i] = right[i - 32];
// 第五步：结尾置换IP-1
currentBits = cipher;
for (int i = 0; i < 64; ++i)
cipher[63 - i] = currentBits[64 - IP_1[i]];
// 返回密文
return cipher;
}
/**
* DES解密
*/
bitset<64> decrypt(bitset<64>& cipher)
{
bitset<64> plain;
bitset<64> currentBits;
bitset<32> left;
bitset<32> right;
bitset<32> newLeft;
// 第一步：初始置换IP
for (int i = 0; i < 64; ++i)
currentBits[63 - i] = cipher[64 - IP[i]];
// 第二步：获取 Li 和 Ri
for (int i = 32; i < 64; ++i)
left[i - 32] = currentBits[i];
for (int i = 0; i < 32; ++i)
right[i] = currentBits[i];
// 第三步：共16轮迭代（子密钥逆序应用）
for (int round = 0; round < 16; ++round)
{
newLeft = right;
right = left ^ f(right, subKey[15 - round]);
left = newLeft;
}
// 第四步：合并L16和R16，注意合并为 R16L16
for (int i = 0; i < 32; ++i)
plain[i] = left[i];
for (int i = 32; i < 64; ++i)
plain[i] = right[i - 32];
// 第五步：结尾置换IP-1
currentBits = plain;
for (int i = 0; i < 64; ++i)
plain[63 - i] = currentBits[64 - IP_1[i]];
// 返回明文
return plain;
}
virtual void work() {
cout << "------------------des算法----------------" << endl;
string s = "信1905-2 20194077 郭智昊";
string k = "12345678";
bitset<64> plain = charToBitset(s.c_str());
key = charToBitset(k.c_str());
// 生成16个子密钥
generateKeys();
cout << s << "加密=>";
bitset<64> cipher = encrypt(plain);
cout << cipher << endl;
bitset<64> temp_plain = decrypt(cipher);
cout << "解密=>" << temp_plain << endl;
cout << "加密结果已写入文件" << endl;
fstream file1;
file1.open("D:\\des.txt", ios::binary | ios::out);
file1.write((char*)&cipher, sizeof(cipher));
file1.close();
}
};
class IDEA :public Method {
private:
typedef bitset<16> code; //16位
typedef bitset<128> key; //128位秘钥
bitset<16> sub_key[52]; //52个子秘钥
bitset<16> inv_sub_key[52];//52个逆子秘钥
bitset<64> plaint_txt;
public:
//异或运算
code XOR(code code_1, code code_2)
{
return code_1 ^ code_2;
}
//加法运算
code Plus(code code_1, code code_2)
{
int tmp = 0;
code result;
for (int i = 0; i < 16; i++) //二进制转换成十进制
{
tmp += code_1[i] * pow(2, i) + code_2[i] * pow(2, i);
}
tmp %= 65536;
bitset<16>binary(tmp); //转换成二进制
for (int i = 0; i < 16; i++)
result[i] = binary[i];
return result;
}
//逆加法
code invPlus(code code_in)
{
int tmp = 0;
code result;
for (int i = 0; i < 16; i++) //二进制转换成十进制
tmp += code_in[i] * pow(2, i);
tmp = 65536 - tmp;
bitset<16>binary(tmp); //转换成二进制
for (int i = 0; i < 16; i++)
result[i] = binary[i];
return result;
}
//乘法运算
code Times(code code_1, code code_2)
{
code result;
long long tmp;
long long tmp_1 = 0, tmp_2 = 0;
for (int i = 0; i < 16; i++) //二进制转换成十进制
{
tmp_1 += code_1[i] * pow(2, i);
tmp_2 += code_2[i] * pow(2, i);
}
if (code_1 == 0)
tmp_1 = 65536;
if (code_2 == 0)
tmp_2 = 65536;
tmp = (tmp_1 * tmp_2) % 65537;
if (tmp == 65536) //如果得到最大值即等价于0x0000
result = 0x0000;
else
{
bitset<16>binary(tmp); //转换成二进制
for (int i = 0; i < 16; i++)
result[i] = binary[i];
}
return result;
}
void Exgcd(int a, int b, int& x, int& y) //欧几里得扩展算法
{
if (!b)
x = 1, y = 0;
else
Exgcd(b, a % b, y, x), y -= a / b * x;
}
//利用欧几里得扩展算法求乘法的逆
code invTimes(code code_in)
{
code result;
int tmp = 0;
for (int i = 0; i < 16; i++) //首先转换成十进制
tmp += code_in[i] * pow(2, i);
int x, y;
int p = 65537;
Exgcd(tmp, p, x, y);
x = (x % p + p) % p; //x即为tmp在 (mod65537) 的乘法逆
bitset<16>binary(x); //转换成二进制
for (int j = 0; j < 16; j++)
result[j] = binary[j];
return result;
}
//子秘钥生成
void subkeys_get(code keys_input[8])//输入8个16bit组
{
key keys;
for (int i = 0; i < 8; i++) //转化成128位
{
for (int j = 0; j < 16; j++)
{
keys[j + 16 * i] = keys_input[7 - i][j];
}
}
for (int i = 0; i < 8; i++) //前8个子秘钥（不移动）
{
for (int j = 0; j < 16; j++)
sub_key[i][15 - j] = keys[127 - (j + 16 * i)];
}
for (int i = 0; i < 5; i++) //中间40个子秘钥（）每次循环左移25位
{
key tmp_keys = keys >> 103;
keys = (keys << 25) | (tmp_keys);
for (int j = (8 + 8 * i); j < (8 * (i + 2)); j++)
{
for (int k = 0; k < 16; k++)
sub_key[j][15 - k] = keys[127 - (k + 16 * (j - 8 - 8 * i))];
}
}
key tmp_keys = keys >> 103; //最后一次循环左移取前四个
keys = (keys << 25) | (tmp_keys);
for (int i = 48; i < 52; i++)
{
for (int j = 0; j < 16; j++)
sub_key[i][15 - j] = keys[127 - (j + 16 * (i - 48))];
}
}
void inv_subkeys_get(code sub_key[52]) //将52个子秘钥调用
{
//生成逆子秘钥
for (int i = 6; i < 48; i = i + 6) //U_1, U_2, U_3, U_4 (2 <= i <= 8)
{
inv_sub_key[i] = invTimes(sub_key[48 - i]);
inv_sub_key[i + 1] = invPlus(sub_key[50 - i]);
inv_sub_key[i + 2] = invPlus(sub_key[49 - i]);
inv_sub_key[i + 3] = invTimes(sub_key[51 - i]);
}
for (int i = 0; i < 48; i = i + 6) //U_5, U_6 (1 <= i <= 8)
{
inv_sub_key[i + 4] = sub_key[46 - i];
inv_sub_key[i + 5] = sub_key[47 - i];
}
//U_1, U_2, U_3, U_4 (i = 1, 9)
inv_sub_key[0] = invTimes(sub_key[48]);
inv_sub_key[1] = invPlus(sub_key[49]);
inv_sub_key[2] = invPlus(sub_key[50]);
inv_sub_key[3] = invTimes(sub_key[51]);
inv_sub_key[48] = invTimes(sub_key[0]);
inv_sub_key[49] = invPlus(sub_key[1]);
inv_sub_key[50] = invPlus(sub_key[2]);
inv_sub_key[51] = invTimes(sub_key[3]);
}
//加密
bitset<64> encrypt(bitset<64> plaint)
{
bitset<16> I_1, I_2, I_3, I_4;
bitset<64> cipher;
for (int i = 0; i < 16; i++) //明文分成4个16位(I_1, I_2, I_3, I_4)
{
I_1[15 - i] = plaint[63 - i];
I_2[15 - i] = plaint[47 - i];
I_3[15 - i] = plaint[31 - i];
I_4[15 - i] = plaint[15 - i];
}
for (int i = 0; i < 48; i = i + 6) //轮结构运算
{
bitset<16> tmp_1 = Times(sub_key[i], I_1);
bitset<16> tmp_2 = Plus(sub_key[i + 1], I_2);
bitset<16> tmp_3 = Plus(sub_key[i + 2], I_3);
bitset<16> tmp_4 = Times(sub_key[i + 3], I_4);
bitset<16> tmp_5 = XOR(tmp_1, tmp_3);
bitset<16> tmp_6 = XOR(tmp_2, tmp_4);
bitset<16> tmp_7 = Times(sub_key[i + 4], tmp_5);
bitset<16> tmp_8 = Plus(tmp_6, tmp_7);
bitset<16> tmp_9 = Times(tmp_8, sub_key[i + 5]);
bitset<16> tmp_10 = Plus(tmp_7, tmp_9);
I_1 = XOR(tmp_1, tmp_9);
I_2 = XOR(tmp_3, tmp_9);
I_3 = XOR(tmp_2, tmp_10);
I_4 = XOR(tmp_4, tmp_10);
}
//输出变换
bitset<16> Y_1 = Times(I_1, sub_key[48]);
bitset<16> Y_2 = Plus(I_3, sub_key[49]);
bitset<16> Y_3 = Plus(I_2, sub_key[50]);
bitset<16> Y_4 = Times(I_4, sub_key[51]);
for (int i = 0; i < 16; i++) //整合4个输出成密文
{
cipher[i] = Y_4[i];
cipher[i + 16] = Y_3[i];
cipher[i + 32] = Y_2[i];
cipher[i + 48] = Y_1[i];
}
return cipher;
}
//解密（过程与加密一致，子秘钥变成逆子秘钥）
bitset<64> dencrypt(bitset<64> cipher)
{
//解密
bitset<16> I_1, I_2, I_3, I_4;
bitset<64> plaint;
for (int i = 0; i < 16; i++)
{
I_1[15 - i] = cipher[63 - i];
I_2[15 - i] = cipher[47 - i];
I_3[15 - i] = cipher[31 - i];
I_4[i] = cipher[i];
}
for (int i = 0; i < 48; i = i + 6)
{
bitset<16> tmp_1 = Times(inv_sub_key[i], I_1);
bitset<16> tmp_2 = Plus(inv_sub_key[i + 1], I_2);
bitset<16> tmp_3 = Plus(inv_sub_key[i + 2], I_3);
bitset<16> tmp_4 = Times(inv_sub_key[i + 3], I_4);
bitset<16> tmp_5 = XOR(tmp_1, tmp_3);
bitset<16> tmp_6 = XOR(tmp_2, tmp_4);
bitset<16> tmp_7 = Times(inv_sub_key[i + 4], tmp_5);
bitset<16> tmp_8 = Plus(tmp_6, tmp_7);
bitset<16> tmp_9 = Times(tmp_8, inv_sub_key[i + 5]);
bitset<16> tmp_10 = Plus(tmp_7, tmp_9);
I_1 = XOR(tmp_1, tmp_9);
I_2 = XOR(tmp_3, tmp_9);
I_3 = XOR(tmp_2, tmp_10);
I_4 = XOR(tmp_4, tmp_10);
}
bitset<16> Y_1 = Times(I_1, inv_sub_key[48]);
bitset<16> Y_2 = Plus(I_3, inv_sub_key[49]);
bitset<16> Y_3 = Plus(I_2, inv_sub_key[50]);
bitset<16> Y_4 = Times(I_4, inv_sub_key[51]);
for (int i = 0; i < 16; i++)
{
plaint[i] = Y_4[i];
plaint[i + 16] = Y_3[i];
plaint[i + 32] = Y_2[i];
plaint[i + 48] = Y_1[i];
}
return plaint;
}
virtual void work() {
cout << "------------------idea算法----------------" << endl;
plaint_txt = 0xa6224adf2f28df73;//64位明文
cout << "明文：" << endl << plaint_txt << endl;
code keys_input[8] = { 0x151a, 0x048b, 0x71a1, 0xf9c7, 0x5266, 0xbfd6, 0x24a2, 0xdff1 };//128位秘钥
subkeys_get(keys_input); //生成子秘钥
inv_subkeys_get(sub_key);//生成逆子秘钥
bitset<64> cipher = encrypt(plaint_txt); //加密得到密文cipher
cout << "加密得到的密文为：" << cipher << endl;
fstream file;
file.open("D:\\idea.txt", ios::binary | ios::out);
file.write((char*)&cipher, sizeof(cipher));
file.close();
bitset<64> plaint = dencrypt(cipher); //解密得到明文plaint
cout << "解密得到：" << plaint << endl;
}
};
class MethodFactory {
public:
virtual Method* ProduceMethod() = 0;
};
class DesFactory : public MethodFactory {
public:
virtual Method* ProduceMethod() {
return new DES;
}
};
class IdeaFactory :public MethodFactory {
public:
virtual Method* ProduceMethod() {
return new IDEA;
}
};
int main(void) {
MethodFactory * factory = NULL;
Method *method = NULL;
factory = new DesFactory;
method = factory->ProduceMethod();
method->work();
delete method;
delete factory;
factory = new IdeaFactory;
method = factory->ProduceMethod();
method->work();
}
