一种128位高效文本加密算法的实现

1 效果图

2 论文出处:

< A FAST AND SECURE ENCRYPTION ALGORITHM  FOR MESSAGE COMMUNICATION > (ICTES 2007)

主要优点是快 

我自己的测试加密吞吐率为67618Bytes/sec, Inter T6600 2.2GHZ下,远高于DES BlowFish

缺点是 只支持 ASCII码32-126位,其中很明显的是回车加密后解密是乱码.

基本原理:

3 加密的类

#pragma once
#include <string>
#include <cstring>
using namespace std;

class Matrix_encreption
{
	char asc_matrix[16][95]; //ascii码矩阵
	bool is_setkey; //密钥是否设置
	char key[16]; //密钥128位
	char plain_text[16];//处理的明文块128位
	char lever_one_cipher[16];//一级密文
	char cipher_text[16];//处理的密文块 128位
public:
	Matrix_encreption(void);
	~Matrix_encreption(void);
	
	void set_key(const char*); //key必须是128位 即16字节字符串
	void show_key() const;

	void init_matrix() throw (const char *); //初始化矩阵,必须在设置了密钥之后调用
	void show_matrix() const;
	
	//void set_plain(); //设置明文
	void set_plain(const char *);
	const char* get_plain();

	//void set_cipher(); //设置密文
	void set_cipher(const char *);
	const char* get_cipher();

	//void init_buf(); //清空buf 明文和密文

	void substitution_mapping(); //替换映射
	void translation(int); //翻译
	void transposing(int); //转置
	void encreption();

	void de_substitution_mapping(); //替换映射
	void de_translation(int); //翻译
	void de_transposing(int); //转置
	void decreption();
	
	void right_round_shift(char *p,int size,int n); //循环右移  参数:  目标数组 数组容量 移位次数
	void left_round_shift(char *p,int size,int n);  //循环左移

};

#include "StdAfx.h"
#include "Matrix_encreption.h"
#include <iostream>
#include <cstring>
#include <string>
#include <sstream>

using namespace std;


Matrix_encreption::Matrix_encreption(void)
{
	is_setkey = false;
}

Matrix_encreption::~Matrix_encreption(void)
{
}


void  Matrix_encreption::set_key(const char* str) 
{
	memcpy(key,str,16);
	is_setkey = true;
	init_matrix();
}


void Matrix_encreption::show_key() const
{
	if(!is_setkey)
	{
		cout << "key is not set" << endl;
		return;
	}
	cout << "key is:";
	for(int i = 0;i<16;i++)
	{
		cout << key[i];
	}
	cout << endl;
}

void Matrix_encreption::init_matrix() throw (const char *)
{
	if(!is_setkey) 
	{
		throw "please set key first";
	}

	//使用ascii码填充
	for(int i =0;i<16;i++)
	{
		for(int j = 0; j< 95;j++)
		{
			asc_matrix[i][j] = 32+j+'\0';
		}
	}

	//进行移位
	for(int i=0;i<15;i++)
	{
		right_round_shift(asc_matrix[i],95,key[i]+key[i+1]);
	}
	right_round_shift(asc_matrix[15],95,key[0]+key[15]);

}

void  Matrix_encreption::show_matrix() const
{
	for(int i =0;i<16;i++)
	{
		for(int j = 0; j< 95;j++)
		{
			cout << asc_matrix[i][j];
		}
		cout << endl;
	}

}
/*

void Matrix_encreption::set_plain()
{
	cout << "请输入明文:" << endl;
	cin >> plain_buf;
	
}
*/

void Matrix_encreption::set_plain(const char * str)
{
	//cout << "正在输入明文:" << str << endl;
	memcpy(plain_text,str,16);
}

const char * Matrix_encreption::get_plain()
{
	return lever_one_cipher;
}


void Matrix_encreption::set_cipher(const char *str)
{
	//cout << "正在输入密文" << str << endl;
	memcpy(cipher_text,str,16);
}

const char* Matrix_encreption::get_cipher()
{
	return lever_one_cipher;
}


void Matrix_encreption::substitution_mapping() //替换映射
{
	char temp[16];

	for(int i=0;i<16;i++)
	{	
		temp[i] = asc_matrix[i][plain_text[i]-32];
	}
	memcpy(lever_one_cipher,temp,16);
}


void Matrix_encreption::translation(int round) //转化 round 0~7
{
	string temp_str(asc_matrix[round]);
	string k_ts_n = temp_str.substr(0,16);
		
	for(int i = 0;i < 16 ; i++)
	{
		
		lever_one_cipher[i] ^= k_ts_n[i]; //异或
	}
}

void Matrix_encreption::transposing(int round) //移位
{
	char left[8]; //左8  a2
	char right[8]; //右8 a3
	char all[16];	//全部的
	char k_tp_n0 = asc_matrix[round][0];
	char k_tp_n1 = asc_matrix[round][1];
	char k_tp_n2 = asc_matrix[round][2];
	char k_tp_n3 = asc_matrix[round][3];

	memcpy(all,lever_one_cipher,16);
	right_round_shift(all,16,k_tp_n0);//右移
	memcpy(left,all,8);
	memcpy(right,all+8,8);
	right_round_shift(left,8,k_tp_n1); //左半右移
	left_round_shift(right,8,k_tp_n2); //右半左移
	memcpy(all,left,8);
	memcpy(all+8,right,8);
	right_round_shift(all,16,k_tp_n3);	//结合在一起右移
	memcpy(lever_one_cipher,all,16);

}



void Matrix_encreption::encreption() //对128位加密
{
	//映射
	substitution_mapping();
	//翻译和转置
	for(int round = 0; round <8; ++round)
	{
		translation(round);
		transposing(round);
	}
}

void Matrix_encreption::de_substitution_mapping() //反替换映射
{

	for(int i=0;i<16;i++)
	{	
		char c = lever_one_cipher[i];
		for(int j=0;j<95;j++)
		{
			if(asc_matrix[i][j] == c)
			{
				lever_one_cipher[i] = j+32+'\0';
				break;
			}
		}

	}
}

void Matrix_encreption::de_transposing(int round)//反转置 step1
{
	char left[8]; //左8  a2
	char right[8]; //右8 a3
	char all[16];	//全部的
	char k_tp_n0 = asc_matrix[round][0];
	char k_tp_n1 = asc_matrix[round][1];
	char k_tp_n2 = asc_matrix[round][2];
	char k_tp_n3 = asc_matrix[round][3];

	memcpy(all,lever_one_cipher,16);
	left_round_shift(all,16,k_tp_n3);
	memcpy(left,all,8);
	memcpy(right,all+8,8);

	left_round_shift(left,8,k_tp_n1); 
	right_round_shift(right,8,k_tp_n2); 

	memcpy(all,left,8);
	memcpy(all+8,right,8);
	left_round_shift(all,16,k_tp_n0);

	memcpy(lever_one_cipher,all,16);
}

/*
void Matrix_encreption::de_translation(int round) //反翻译 好像是一样的 
{ 
	string temp_str(asc_matrix[round]);
	string k_ts_n = temp_str.substr(0,16); //前0~15
	for(int i = 0;i < 16 ; i++)
	{
		lever_one_cipher[i] ^= k_ts_n[i]; //异或
	}
}
*/

void Matrix_encreption::decreption()
{
		memcpy(lever_one_cipher,cipher_text,16);
		for(int round  = 7; round >-1; --round)
		{
			de_transposing(round);
			translation(round); //没变化
		}
		de_substitution_mapping();
}


void Matrix_encreption::right_round_shift(char *p,int size,int n) //循环右移  参数:  目标数组 数组容量 移位次数
{
	int k = n%size; //有效移位次数
	char *temp = new char[size];
	for(int i=0;i< size;i++)
	{
		if(i+k < size)
		{
			temp[i+k] = p[i];
		}
		else
		{
			temp[i+k-size] = p[i];
		}
	}
	for(int i=0;i< size;i++)
	{
		p[i] = temp[i];
		//cout << p[i];
	}
	//cout << endl;
	delete temp;
}
	
void Matrix_encreption::left_round_shift(char *p,int size,int n)  //循环左移
{
	int k = n%size;
	right_round_shift(p,size,size-k);
}

/*
void Matrix_encreption::init_buf()
{
//	cout << "清空内存中的明文密文" << endl;
//	plain_buf = "";
//	cipher_buf ="";
}

*/

使用加密

#include "stdafx.h"
#include "Matrix_encreption.h"
#include <iostream>
#include <fstream>
#include<time.h>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	/*计时模块*/
	clock_t start,finish;
	double totaltime;
	start=clock();

	/*开始程序*/
	Matrix_encreption m;
	m.set_key("123ujhgfbvfdcxsa"); //必须是16位
	

	ifstream f1("plain.txt",ios::binary | ios::in);
	if(!f1)
	{
		cout << "打开plain.txt失败" << endl;
		system("pause");
		return 1;
	}

	ofstream f2("cipher.txt",ios::binary |ios::out);
	if(!f2)
	{
		cout << "打开cipher.txt失败" << endl;
		system("pause");
		return 1;
	}



	char buf1[16];
	while(f1)
	{
		memset(buf1,' ',16); //不足16以空格补齐
		f1.read(buf1,16);
		if(f1.gcount() == 0) break;
		m.set_plain(buf1);
		m.encreption();
		f2.write(m.get_cipher(),16);
	}

	f1.close();
	f2.close();


	ifstream f3("cipher.txt",ios::binary |ios::in);
	if(!f3)
	{
		cout << "打开cipher.txt失败" << endl; 
		system("pause");
		return 1;
	}

	ofstream f4("plain_out.txt",ios::binary |ios::out);
	if(!f4)
	{
		cout << "打开plain_out.txt失败" << endl;
		system("pause");
		return 1;
	}
	
	char buf2[16];
	while(f3)
	{
		memset(buf2,' ',16); //不足16以空格补齐
		f3.read(buf2,16);
		int a = f3.gcount();
		if(f3.gcount() == 0) break;
		m.set_cipher(buf2);
		m.decreption();
		f4.write(m.get_plain(),16);
	}

	f3.close();
	f4.close();
	
	/*计时模块*/
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	cout<<"\n此程序的运行时间为"<<totaltime<<"秒！"<<endl;
	system("pause");

 	return 0;
}