newhash.cpp

aes的原代码

#include "StdAfx.h"
#include ".\newhash.h"
/**
 * 散列构造器，有机器码
 * 本类可根据 机器码，用户名，口令或只用用户名，口令散列出指定位的序列
 * 参数：
 *  pcstr 机器码
 *  username 用户名
 *  psw 用户口令
 *  len1 pcstr有效长度
 *  len2 username有效长度
 *  len3 psw有效长度
 *  keyLen 须散列后序列的位数，缺省为 128位
 */
NewHash::NewHash(unsigned char *pcstr, unsigned char *username, unsigned char *psw, int len1, int len2, int len3, int keyLen)
{
	if(keyLen!=128 && keyLen!=192 && keyLen!=256) throw exception("密钥长度无效");	//密钥长度无效异常
																					//密钥长度必须是128或192或256位
	try{
		genKey = new GenKey(pcstr,username,psw,len1,len2,len3);
		buffer = new unsigned char[len1+len2+len3];
		unsigned char *tp = buffer;
		memcpy(tp,pcstr,len1);
		tp+=len1;
		memcpy(tp,username,len2);
		tp+=len2;
		memcpy(tp,psw,len3);
		count=len1+len2+len3;
		this->keyLen=keyLen;
		initial();						//基本数据初始化
		flg=false;
	}catch(exception& ex)
	{
		delete (genKey);
		delete[] buffer;
		throw ex;
	}
}
/**
 * 散列构造器，无机器码
 * 参数：
 *  pcstr 机器码
 *  username 用户名
 *  len1 pcstr有效长度
 *  len2 username有效长度
 *  keyLen 须散列后序列的位数，缺省为 128位
 */
NewHash::NewHash(unsigned char *pcstr, unsigned char *username, int len1, int len2, int keyLen)
{
	if(keyLen!=128 && keyLen!=192 && keyLen!=256) throw exception("密钥长度无效");
	try{
		genKey = new GenKey(pcstr,username,len1,len2);
		buffer = new unsigned char[len1+len2];
		unsigned char *tp = buffer;
		memcpy(tp,pcstr,len1);
		tp+=len1;
		memcpy(tp,username,len2);
		count=len1+len2;
		this->keyLen=keyLen;
		initial();
		flg=false;
	}catch(exception& ex)
	{
		delete (genKey);
		delete[] buffer;
		throw ex;
	}
}
/**
 * 取的散列后指定位数的序列，进行此方法调用时必须进行iniKey方法的调用初始化，否则函数体内将抛出异常
 * 参数：
 *  finkey 存储最终散列序列，要求大小务必大于等于keyLen
 * 返回：finkey 存储最终散列序列指针
 */
unsigned char *NewHash::getKey(unsigned char *finkey)
{
	if(!flg) throw exception("从未初始化的序列！");
	if(strlen((char*)((void*)finkey))<(size_t)keyLen/8) throw exception("密钥参数数组越界！");
	unsigned char *reh; 
	switch(keyLen)							//根据指定的不同的散列序列位数进行处理
	{
	case 128: //finkey= new unsigned char[SL];
		if(ha[SL-1]%2) memcpy(finkey,ha,SL);
		else memcpy(finkey,hb,SL);
		return finkey;
	case 192:
		//finkey= new unsigned char[SL+8];
		reh=finkey;
		memcpy(reh,ha,16);
		reh+=16;
		memcpy(reh,hb,8);
		return finkey;
	case 256:
		//finkey= new unsigned char[2*SL];
		reh=finkey;
		memcpy(reh,ha,16);
		reh+=16;
		memcpy(reh,hb,16);
		return finkey;
	default: throw exception("密钥长度无效");
	}
}
/**
 * 进行基本数据结构及数据的初始化，在构造函数里调用
 */
void NewHash::initial()
{
	unsigned char *tp,*tk;
	int n;
	mecnt=0;
	tp=buffer;
	genKey->getKey(key);
	memset(m,0,sizeof(m));
	memset(me,0,sizeof(me));
	for(int i=0; i<count; i+=16,tp+=16)					//初始化me（由m经过aes加密得）
	{
		n =( count -i > 16 ) ? 16 : ( count - i );
		memcpy(m[mecnt],tp,n);
		AesCrypt::rijCrypt(m[mecnt],me[mecnt],key,16);
		mecnt++;
	}
	tk=key;
	memcpy(k1,tk,SUBKL);
	tk+=SUBKL;
	memcpy(k2,tk,SUBKL);
	//printf("-=%d=-\n",mecnt);
	/*for(int i=0; i<mecnt; i++)
	{
		for(int j=0; j<16; j++) printf("%x-",me[i][j]);
		printf("\n");
	}*/
}
/**
 * 散列的核心，进行散列的基本过程，调用getKey方法前必须先调用此方法
 */
void NewHash::iniKey()
{
	flg=true;
	unsigned char tmp[SL];
	memset(ha,0,sizeof(ha));
	memset(hb,0,sizeof(hb));
	memcpy(ha,k1,SUBKL);
	memcpy(hb,k2,SUBKL);
	for(int i=0; i<mecnt; i++)
	{
		xor(tmp,ha,me[i],SL);
		AesCrypt::rijCrypt(m[i],r,tmp,16);		//对称加密，使其更随机
		xor(r,r,me[i],SL);

		xor(tmp,hb,m[i],SL);
		xor(tmp,tmp,r,SL);
		AesCrypt::rijCrypt(me[i],re,tmp,16);	//对称加密，使其更随机
		xor(re,re,m[i],SL);
		
		memcpy(tmp,ha,SL);
		xor(ha,ha,hb,SL);
		xor(ha,ha,re,SL);
		xor(ha,ha,r,SL);
		
		xor(hb,tmp,hb,SL);
		xor(hb,hb,r,SL);

		//memcpy(tmp,ha,SL);
		//ha^=me[i];
		//AesCrypt::rijCrypt(m[i],r,ha,16);
		//r^=me[i];

		//memcpy(tmp1,hb,SL);
		//hb^=m[i];
		//hb^=r;
		//AesCrypt::rijCrypt(me[i],re,hb,16);
		//re^=m[i];

		//memcpy(ha,tmp,SL);
		//ha^=hb;
		//ha^=re;
		//ha^=r;

		//memcpy(hb,tmp1,SL);
		//hb^=tmp, hb^=r;
	}
}
/**
 * 进行两个序列的异或运算
 */
void NewHash::xor(unsigned char *buf, unsigned char *a, unsigned char *b, int l)
{
	for(int i=0; i<l; i++)
	{
		buf[i]=a[i]^b[i];			//逐个元素异或
	}
}

NewHash::~NewHash(void)
{
	delete (genKey);
	delete[] buffer;
}