des.cpp

奇趣公司比较新的qt/emd版本

	static const int PC1_Cbits[] = {
		6, 13, 20, 27, 34, 41, 48, 55, 5, 12, 19, 26, 33, 40,
		47, 54, 4, 11, 18, 25, 32, 39, 46, 53, 3, 10, 17, 24
	};
	static const int PC1_Dbits[] = {
		0, 7, 14, 21, 28, 35, 42, 49, 1, 8, 15, 22, 29, 36,
		43, 50, 2, 9, 16, 23, 30, 37, 44, 51, 31, 38, 45, 52
	};
	/*
	 * The bit numbers in the two lists below don't correspond to
	 * the ones in the above description of PC2, because in the
	 * above description C and D are concatenated so `bit 28' means
	 * bit 0 of C. In this implementation we're using the standard
	 * `bitsel' function above and C is in the second word, so bit
	 * 0 of C is addressed by writing `32' here.
	 */
	static const int PC2_0246[] = {
		49, 36, 59, 55, -1, -1, 37, 41, 48, 56, 34, 52, -1, -1, 15, 4,
		25, 19, 9, 1, -1, -1, 12, 7, 17, 0, 22, 3, -1, -1, 46, 43
	};
	static const int PC2_1357[] = {
		-1, -1, 57, 32, 45, 54, 39, 50, -1, -1, 44, 53, 33, 40, 47, 58,
		-1, -1, 26, 16, 5, 11, 23, 8, -1, -1, 10, 14, 6, 20, 27, 24
	};
	static const int leftshifts[] =	{
		1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
	};

	quint32 C, D;
	quint32 buf[2];
	int i;

	buf[0] = key_lsw;
	buf[1] = key_msw;

	C = bitsel(buf, PC1_Cbits, 28);
	D = bitsel(buf, PC1_Dbits, 28);

	for (i = 0; i < 16; i++) {
		C = rotl28(C, leftshifts[i]);
		D = rotl28(D, leftshifts[i]);
		buf[0] = D;
		buf[1] = C;
		sched->k0246[i] = bitsel(buf, PC2_0246, 32);
		sched->k1357[i] = bitsel(buf, PC2_1357, 32);
	}
}

static const quint32 SPboxes[8][64] = {
	{0x01010400, 0x00000000, 0x00010000, 0x01010404,
	 0x01010004, 0x00010404, 0x00000004, 0x00010000,
	 0x00000400, 0x01010400, 0x01010404, 0x00000400,
	 0x01000404, 0x01010004, 0x01000000, 0x00000004,
	 0x00000404, 0x01000400, 0x01000400, 0x00010400,
	 0x00010400, 0x01010000, 0x01010000, 0x01000404,
	 0x00010004, 0x01000004, 0x01000004, 0x00010004,
	 0x00000000, 0x00000404, 0x00010404, 0x01000000,
	 0x00010000, 0x01010404, 0x00000004, 0x01010000,
	 0x01010400, 0x01000000, 0x01000000, 0x00000400,
	 0x01010004, 0x00010000, 0x00010400, 0x01000004,
	 0x00000400, 0x00000004, 0x01000404, 0x00010404,
	 0x01010404, 0x00010004, 0x01010000, 0x01000404,
	 0x01000004, 0x00000404, 0x00010404, 0x01010400,
	 0x00000404, 0x01000400, 0x01000400, 0x00000000,
	 0x00010004, 0x00010400, 0x00000000, 0x01010004},

	{0x80108020, 0x80008000, 0x00008000, 0x00108020,
	 0x00100000, 0x00000020, 0x80100020, 0x80008020,
	 0x80000020, 0x80108020, 0x80108000, 0x80000000,
	 0x80008000, 0x00100000, 0x00000020, 0x80100020,
	 0x00108000, 0x00100020, 0x80008020, 0x00000000,
	 0x80000000, 0x00008000, 0x00108020, 0x80100000,
	 0x00100020, 0x80000020, 0x00000000, 0x00108000,
	 0x00008020, 0x80108000, 0x80100000, 0x00008020,
	 0x00000000, 0x00108020, 0x80100020, 0x00100000,
	 0x80008020, 0x80100000, 0x80108000, 0x00008000,
	 0x80100000, 0x80008000, 0x00000020, 0x80108020,
	 0x00108020, 0x00000020, 0x00008000, 0x80000000,
	 0x00008020, 0x80108000, 0x00100000, 0x80000020,
	 0x00100020, 0x80008020, 0x80000020, 0x00100020,
	 0x00108000, 0x00000000, 0x80008000, 0x00008020,
	 0x80000000, 0x80100020, 0x80108020, 0x00108000},

	{0x00000208, 0x08020200, 0x00000000, 0x08020008,
	 0x08000200, 0x00000000, 0x00020208, 0x08000200,
	 0x00020008, 0x08000008, 0x08000008, 0x00020000,
	 0x08020208, 0x00020008, 0x08020000, 0x00000208,
	 0x08000000, 0x00000008, 0x08020200, 0x00000200,
	 0x00020200, 0x08020000, 0x08020008, 0x00020208,
	 0x08000208, 0x00020200, 0x00020000, 0x08000208,
	 0x00000008, 0x08020208, 0x00000200, 0x08000000,
	 0x08020200, 0x08000000, 0x00020008, 0x00000208,
	 0x00020000, 0x08020200, 0x08000200, 0x00000000,
	 0x00000200, 0x00020008, 0x08020208, 0x08000200,
	 0x08000008, 0x00000200, 0x00000000, 0x08020008,
	 0x08000208, 0x00020000, 0x08000000, 0x08020208,
	 0x00000008, 0x00020208, 0x00020200, 0x08000008,
	 0x08020000, 0x08000208, 0x00000208, 0x08020000,
	 0x00020208, 0x00000008, 0x08020008, 0x00020200},

	{0x00802001, 0x00002081, 0x00002081, 0x00000080,
	 0x00802080, 0x00800081, 0x00800001, 0x00002001,
	 0x00000000, 0x00802000, 0x00802000, 0x00802081,
	 0x00000081, 0x00000000, 0x00800080, 0x00800001,
	 0x00000001, 0x00002000, 0x00800000, 0x00802001,
	 0x00000080, 0x00800000, 0x00002001, 0x00002080,
	 0x00800081, 0x00000001, 0x00002080, 0x00800080,
	 0x00002000, 0x00802080, 0x00802081, 0x00000081,
	 0x00800080, 0x00800001, 0x00802000, 0x00802081,
	 0x00000081, 0x00000000, 0x00000000, 0x00802000,
	 0x00002080, 0x00800080, 0x00800081, 0x00000001,
	 0x00802001, 0x00002081, 0x00002081, 0x00000080,
	 0x00802081, 0x00000081, 0x00000001, 0x00002000,
	 0x00800001, 0x00002001, 0x00802080, 0x00800081,
	 0x00002001, 0x00002080, 0x00800000, 0x00802001,
	 0x00000080, 0x00800000, 0x00002000, 0x00802080},

	{0x00000100, 0x02080100, 0x02080000, 0x42000100,
	 0x00080000, 0x00000100, 0x40000000, 0x02080000,
	 0x40080100, 0x00080000, 0x02000100, 0x40080100,
	 0x42000100, 0x42080000, 0x00080100, 0x40000000,
	 0x02000000, 0x40080000, 0x40080000, 0x00000000,
	 0x40000100, 0x42080100, 0x42080100, 0x02000100,
	 0x42080000, 0x40000100, 0x00000000, 0x42000000,
	 0x02080100, 0x02000000, 0x42000000, 0x00080100,
	 0x00080000, 0x42000100, 0x00000100, 0x02000000,
	 0x40000000, 0x02080000, 0x42000100, 0x40080100,
	 0x02000100, 0x40000000, 0x42080000, 0x02080100,
	 0x40080100, 0x00000100, 0x02000000, 0x42080000,
	 0x42080100, 0x00080100, 0x42000000, 0x42080100,
	 0x02080000, 0x00000000, 0x40080000, 0x42000000,
	 0x00080100, 0x02000100, 0x40000100, 0x00080000,
	 0x00000000, 0x40080000, 0x02080100, 0x40000100},

	{0x20000010, 0x20400000, 0x00004000, 0x20404010,
	 0x20400000, 0x00000010, 0x20404010, 0x00400000,
	 0x20004000, 0x00404010, 0x00400000, 0x20000010,
	 0x00400010, 0x20004000, 0x20000000, 0x00004010,
	 0x00000000, 0x00400010, 0x20004010, 0x00004000,
	 0x00404000, 0x20004010, 0x00000010, 0x20400010,
	 0x20400010, 0x00000000, 0x00404010, 0x20404000,
	 0x00004010, 0x00404000, 0x20404000, 0x20000000,
	 0x20004000, 0x00000010, 0x20400010, 0x00404000,
	 0x20404010, 0x00400000, 0x00004010, 0x20000010,
	 0x00400000, 0x20004000, 0x20000000, 0x00004010,
	 0x20000010, 0x20404010, 0x00404000, 0x20400000,
	 0x00404010, 0x20404000, 0x00000000, 0x20400010,
	 0x00000010, 0x00004000, 0x20400000, 0x00404010,
	 0x00004000, 0x00400010, 0x20004010, 0x00000000,
	 0x20404000, 0x20000000, 0x00400010, 0x20004010},

	{0x00200000, 0x04200002, 0x04000802, 0x00000000,
	 0x00000800, 0x04000802, 0x00200802, 0x04200800,
	 0x04200802, 0x00200000, 0x00000000, 0x04000002,
	 0x00000002, 0x04000000, 0x04200002, 0x00000802,
	 0x04000800, 0x00200802, 0x00200002, 0x04000800,
	 0x04000002, 0x04200000, 0x04200800, 0x00200002,
	 0x04200000, 0x00000800, 0x00000802, 0x04200802,
	 0x00200800, 0x00000002, 0x04000000, 0x00200800,
	 0x04000000, 0x00200800, 0x00200000, 0x04000802,
	 0x04000802, 0x04200002, 0x04200002, 0x00000002,
	 0x00200002, 0x04000000, 0x04000800, 0x00200000,
	 0x04200800, 0x00000802, 0x00200802, 0x04200800,
	 0x00000802, 0x04000002, 0x04200802, 0x04200000,
	 0x00200800, 0x00000000, 0x00000002, 0x04200802,
	 0x00000000, 0x00200802, 0x04200000, 0x00000800,
	 0x04000002, 0x04000800, 0x00000800, 0x00200002},

	{0x10001040, 0x00001000, 0x00040000, 0x10041040,
	 0x10000000, 0x10001040, 0x00000040, 0x10000000,
	 0x00040040, 0x10040000, 0x10041040, 0x00041000,
	 0x10041000, 0x00041040, 0x00001000, 0x00000040,
	 0x10040000, 0x10000040, 0x10001000, 0x00001040,
	 0x00041000, 0x00040040, 0x10040040, 0x10041000,
	 0x00001040, 0x00000000, 0x00000000, 0x10040040,
	 0x10000040, 0x10001000, 0x00041040, 0x00040000,
	 0x00041040, 0x00040000, 0x10041000, 0x00001000,
	 0x00000040, 0x10040040, 0x00001000, 0x00041040,
	 0x10001000, 0x00000040, 0x10000040, 0x10040000,
	 0x10040040, 0x10000000, 0x00040000, 0x10001040,
	 0x00000000, 0x10041040, 0x00040040, 0x10000040,
	 0x10040000, 0x10001000, 0x10001040, 0x00000000,
	 0x10041040, 0x00041000, 0x00041000, 0x00001040,
	 0x00001040, 0x00040040, 0x10000000, 0x10041000}
};

#define f(R, K0246, K1357) (\
	s0246 = R ^ K0246, \
	s1357 = R ^ K1357, \
	s0246 = rotl(s0246, 28), \
	SPboxes[0] [(s0246 >> 24) & 0x3F] | \
	SPboxes[1] [(s1357 >> 24) & 0x3F] | \
	SPboxes[2] [(s0246 >> 16) & 0x3F] | \
	SPboxes[3] [(s1357 >> 16) & 0x3F] | \
	SPboxes[4] [(s0246 >>  8) & 0x3F] | \
	SPboxes[5] [(s1357 >>  8) & 0x3F] | \
	SPboxes[6] [(s0246      ) & 0x3F] | \
	SPboxes[7] [(s1357      ) & 0x3F])

#define bitswap(L, R, n, mask) (\
	swap = mask & ( (R >> n) ^ L ), \
	R ^= swap << n, \
	L ^= swap)

/* Initial permutation */
#define IP(L, R) (\
	bitswap(R, L,  4, 0x0F0F0F0F), \
	bitswap(R, L, 16, 0x0000FFFF), \
	bitswap(L, R,  2, 0x33333333), \
	bitswap(L, R,  8, 0x00FF00FF), \
	bitswap(R, L,  1, 0x55555555))

/* Final permutation */
#define FP(L, R) (\
	bitswap(R, L,  1, 0x55555555), \
	bitswap(L, R,  8, 0x00FF00FF), \
	bitswap(L, R,  2, 0x33333333), \
	bitswap(R, L, 16, 0x0000FFFF), \
	bitswap(R, L,  4, 0x0F0F0F0F))

static void
des_encipher(quint32 *output, quint32 L, quint32 R,
	     struct des_context *sched)
{
	quint32 swap, s0246, s1357;

	IP(L, R);

	L = rotl(L, 1);
	R = rotl(R, 1);

	L ^= f(R, sched->k0246[0], sched->k1357[0]);
	R ^= f(L, sched->k0246[1], sched->k1357[1]);
	L ^= f(R, sched->k0246[2], sched->k1357[2]);
	R ^= f(L, sched->k0246[3], sched->k1357[3]);
	L ^= f(R, sched->k0246[4], sched->k1357[4]);
	R ^= f(L, sched->k0246[5], sched->k1357[5]);
	L ^= f(R, sched->k0246[6], sched->k1357[6]);
	R ^= f(L, sched->k0246[7], sched->k1357[7]);
	L ^= f(R, sched->k0246[8], sched->k1357[8]);
	R ^= f(L, sched->k0246[9], sched->k1357[9]);
	L ^= f(R, sched->k0246[10], sched->k1357[10]);
	R ^= f(L, sched->k0246[11], sched->k1357[11]);
	L ^= f(R, sched->k0246[12], sched->k1357[12]);
	R ^= f(L, sched->k0246[13], sched->k1357[13]);
	L ^= f(R, sched->k0246[14], sched->k1357[14]);
	R ^= f(L, sched->k0246[15], sched->k1357[15]);

	L = rotl(L, 31);
	R = rotl(R, 31);

	swap = L;
	L = R;
	R = swap;

	FP(L, R);

	output[0] = L;
	output[1] = R;
}

#define GET_32BIT_MSB_FIRST(cp) \
	(((unsigned long)(unsigned char)(cp)[3]) | \
	((unsigned long)(unsigned char)(cp)[2] << 8) | \
	((unsigned long)(unsigned char)(cp)[1] << 16) | \
	((unsigned long)(unsigned char)(cp)[0] << 24))

#define PUT_32BIT_MSB_FIRST(cp, value) do { \
	(cp)[3] = (value); \
	(cp)[2] = (value) >> 8; \
	(cp)[1] = (value) >> 16; \
	(cp)[0] = (value) >> 24; } while (0)

static inline void
des_cbc_encrypt(unsigned char *dest, const unsigned char *src,
		struct des_context *sched)
{
	quint32 out[2], L, R;

	L = GET_32BIT_MSB_FIRST(src);
	R = GET_32BIT_MSB_FIRST(src + 4);
	des_encipher(out, L, R, sched);
	PUT_32BIT_MSB_FIRST(dest, out[0]);
	PUT_32BIT_MSB_FIRST(dest + 4, out[1]);
}


static unsigned char *
deshash(unsigned char *dst, const unsigned char *key,
	const unsigned char *src)
{
	struct des_context ctx;

	des_key_setup(GET_32BIT_MSB_FIRST(key) >> 8,
		      GET_32BIT_MSB_FIRST(key + 3), &ctx);

	des_cbc_encrypt(dst, src, &ctx);

	return dst;
}