mars.cpp

mars的加密算法

    return m & 0xfffffffc;
}
#endif
}	// end of anonymous namespace

char *mars::name(void)
{
    return "mars";
}

void mars::set_key(const u1byte in_key[], const u4byte key_bits)
{   
	u4byte  i, j, m; 

	m = key_bits / 32;

	if(m < 4 || m > 14)

		return;

    for(i = 0; i < m; ++i)

		t_key[i] = u4byte_in(in_key + 4 * i);

	t_key[m] = m;

	for(i = m + 1; i < 15; ++i)

		t_key[i] = 0;

	for(i = 0; i < 4; ++i)
	{
		for(j = 0; j < 15; ++j)

			t_key[j] ^= rotl(t_key[im7[j]] ^ t_key[im2[j]], 3) ^ (4 * j + i);

		for(m = 0; m < 4; ++m)

			for(j = 0; j < 15; ++j)
				
				t_key[j] = rotl(t_key[j] + s_box[t_key[im1[j]] & 511], 9);

		for(j = 0; j < 10; ++j)

			l_key[10 * i + j] = t_key[i4m[j]];
	}

    for(i = 5; i < 37; i += 2)
    {
        j = l_key[i] | 3; 

	    m = (~j ^ (j >> 1)) & 0x7fffffff;

	    m &= (m >> 1) & (m >> 2); m &= (m >> 3) & (m >> 6); 
    
		if(m)
		{
		    m <<= 1; m |= (m << 1); m |= (m << 2); m |= (m << 4);

			m &= 0xfffffffc;

			j ^= (rotl(b_tab[l_key[i] & 3], l_key[i - 1]) & m);
		}

        l_key[i] = j;
    }

    return;
}

void mars::encrypt(const u1byte in_blk[16], u1byte out_blk[16])
{   
	u4byte  a, b, c, d, l, m, r;

    a = u4byte_in(in_blk    ) + l_key[0]; b = u4byte_in(in_blk +  4) + l_key[1];
    c = u4byte_in(in_blk + 8) + l_key[2]; d = u4byte_in(in_blk + 12) + l_key[3];

    f_mix(a,b,c,d); a += d;
    f_mix(b,c,d,a); b += c;
    f_mix(c,d,a,b);
    f_mix(d,a,b,c);
    f_mix(a,b,c,d); a += d;
    f_mix(b,c,d,a); b += c;
    f_mix(c,d,a,b);
    f_mix(d,a,b,c);

    f_ktr(a,b,c,d, 4); f_ktr(b,c,d,a, 6); f_ktr(c,d,a,b, 8); f_ktr(d,a,b,c,10); 
    f_ktr(a,b,c,d,12); f_ktr(b,c,d,a,14); f_ktr(c,d,a,b,16); f_ktr(d,a,b,c,18); 
    f_ktr(a,d,c,b,20); f_ktr(b,a,d,c,22); f_ktr(c,b,a,d,24); f_ktr(d,c,b,a,26); 
    f_ktr(a,d,c,b,28); f_ktr(b,a,d,c,30); f_ktr(c,b,a,d,32); f_ktr(d,c,b,a,34); 

    b_mix(a,b,c,d);
    b_mix(b,c,d,a); c -= b;
    b_mix(c,d,a,b); d -= a;
    b_mix(d,a,b,c);
    b_mix(a,b,c,d);
    b_mix(b,c,d,a); c -= b;
    b_mix(c,d,a,b); d -= a;
    b_mix(d,a,b,c);

    u4byte_out(out_blk,     a - l_key[36]); u4byte_out(out_blk +  4, b - l_key[37]);
    u4byte_out(out_blk + 8, c - l_key[38]); u4byte_out(out_blk + 12, d - l_key[39]);
}

void mars::decrypt(const u1byte in_blk[16], u1byte out_blk[16])
{   u4byte  a, b, c, d, l, m, r;
    
    d = u4byte_in(in_blk    ) + l_key[36]; c = u4byte_in(in_blk +  4) + l_key[37];
    b = u4byte_in(in_blk + 8) + l_key[38]; a = u4byte_in(in_blk + 12) + l_key[39];

    f_mix(a,b,c,d); a += d;
    f_mix(b,c,d,a); b += c;
    f_mix(c,d,a,b); 
    f_mix(d,a,b,c);
    f_mix(a,b,c,d); a += d;
    f_mix(b,c,d,a); b += c;
    f_mix(c,d,a,b);
    f_mix(d,a,b,c);

    r_ktr(a,b,c,d,34); r_ktr(b,c,d,a,32); r_ktr(c,d,a,b,30); r_ktr(d,a,b,c,28);
    r_ktr(a,b,c,d,26); r_ktr(b,c,d,a,24); r_ktr(c,d,a,b,22); r_ktr(d,a,b,c,20);
    r_ktr(a,d,c,b,18); r_ktr(b,a,d,c,16); r_ktr(c,b,a,d,14); r_ktr(d,c,b,a,12);
    r_ktr(a,d,c,b,10); r_ktr(b,a,d,c, 8); r_ktr(c,b,a,d, 6); r_ktr(d,c,b,a, 4);

    b_mix(a,b,c,d);
    b_mix(b,c,d,a); c -= b;
    b_mix(c,d,a,b); d -= a;
    b_mix(d,a,b,c);
    b_mix(a,b,c,d);
    b_mix(b,c,d,a); c -= b;
    b_mix(c,d,a,b); d -= a;
    b_mix(d,a,b,c);

    u4byte_out(out_blk,     d - l_key[0]); u4byte_out(out_blk +  4, c - l_key[1]);
    u4byte_out(out_blk + 8, b - l_key[2]); u4byte_out(out_blk + 12, a - l_key[3]);
}

string mars::encrypt16(string str, bool ed)
{
	//因用字符串保存转换时容易出错，所以采用数字方式保存
	char cstr[255] = "";
	unsigned char educstr[255] = "";

	unsigned char ckey[] = "RW7SCKTT5COSDC4AX3HS810MIA1037PMTVLA4A4UQTSMT2TG4DB3IG5FOFP9UL6V7510VSGBOAPQ9RA9XI7932DVR9CZ10XC6B3TUBQ9ARIAAXTZSPVFA9T4QQHJ8BKPI813UMGHZH53TE86AI4U9RRCMHALQ8PF9K1S510109XBPT5C10QG2W7ZKZZSS6WF1J7JT310T9R9KQCW9414PN27MZFT3KJCIKLLTPMEDUP101WR32C3NTFD96U57FBV";
	set_key(ckey,sizeof(ckey)/sizeof(unsigned char));
	
	if(ed)
	{
		//encrypt
		string enstr;
		strcpy(cstr,str.c_str());
		encrypt(reinterpret_cast<unsigned char*>(cstr),educstr);
		for(int i=0;i<16;i++)
		{
			//=============================================================
			//以逗号分割
			//if(i!=0)
			//	enstr += ",";

			//char oct[] = "00000000";
			//itoa(educstr[i],oct,16);
			//enstr += oct;
			//=============================================================
			//不用逗号分割
			char oct[] = "00000000";
			string temp;
			itoa(educstr[i],oct,16);
			if(educstr[i]<16)
			{
				temp = "0";
				temp += oct;
			}
			else
			{
				temp = oct;
			}
			enstr += temp;
			//=============================================================
		}
		return enstr.c_str();
	}
	else
	{
		//decrypt
		//=================================================================
		//以逗号分割
		//int npos = 0, npos1 = 0, j = 0;
		//char *stopstring;
		//do{
		//	npos1 = str.find(",",npos);
		//	if(npos1<0)
		//	{
		//		cstr[j] = strtoul(str.substr(npos).c_str(),&stopstring,16);
		//	}
		//	else
		//	{
		//		cstr[j] = strtoul(str.substr(npos,npos1-npos).c_str(),&stopstring,16);
		//	}
		//	npos = npos1+1;
		//	j++;
		//}while(npos1>0);
		//=================================================================
		//不用逗号分割
		int j;
		char *stopstring;
		for(j=0;j<16;j++)
		{
			cstr[j] = strtoul(str.substr(j*2,2).c_str(),&stopstring,16);
		}
		//=================================================================

		decrypt(reinterpret_cast<unsigned char*>(cstr),educstr);
		return reinterpret_cast<char*>(educstr);
	}
}

string mars::encrypt(string str, bool ed)
{
	string enstr,tstr;
	if(ed)
	{
		int nLen = str.length();
		int part = (nLen+15)/16;
		
		for(int i=0;i<part;i++)
		{
			//================================================================
			//以逗号分割
			//if(i!=0)
			//	enstr += ",";
			//tstr = str.substr(i*16,16);
			//tstr = encrypt16(tstr);
			//enstr += tstr;
			//================================================================
			//不用逗号分割
			tstr = str.substr(i*16,16);
			tstr = encrypt16(tstr);
			enstr += tstr;
			//================================================================
		}
	}
	else
	{
		//================================================================
		//以逗号分割
		//int pos1 = 0, pos2 = 0, pos3 = 0, j = 0;
		//do{
		//	pos2 = str.find(",",pos1);
		//	j++;
		//	if(j%16==0)
		//	{
		//		if(pos2>0)
		//			tstr = str.substr(pos3,pos2-pos3);
		//		else
		//			tstr = str.substr(pos3);
		//		tstr = encrypt16(tstr,false);
		//		enstr += tstr;
		//		pos3 = pos2 + 1;
		//	}
		//	pos1 = pos2+1;
		//}while(pos2>0);
		//================================================================
		//不用逗号分割
		int nLen = str.length();
		int part = nLen/32;
		for(int i=0; i<part; i++)
		{
			tstr = str.substr(i*32,32);
			tstr = encrypt16(tstr,false);
			enstr += tstr;
		}
		//================================================================
	}

	return enstr;
}