des.c

开发源代码的CPU卡的COS源程序。

/* ============================================================================
   Project Name : jayaCard
   Module Name  : proto/hal/crypto/des.c
   Version : $Id: des.c,v 1.14 2003/10/31 23:12:52 dgil Exp $

	Description: DES, DESX, 3DES

    The Original Code is jayaCard code.

    The Initial Developer of the Original Code is Gilles Dumortier.

	Portions created by the Initial Developer are Copyright (C) 2000-2003 the
    Initial Developer. All Rights Reserved.

    Contributor(s):

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; see http://www.gnu.org/licenses/gpl.html

   History Rev	Description
   020903 dgil	Wrote it from scratch
   042503 dgil	Revamp it
   ============================================================================
*/

#include "precomp.h"

#ifdef JAYACFG_DES_KER

/* =========================================================================
	ROMized
   ========================================================================= */

/* initial permutation IP */
extern jbyte code ip[64];

/* final permutation IP^-1 */
extern jbyte code fp[64];

/* permuted choice table (key) */
extern jbyte code pc1[64];
extern jbyte code pc2[64];

/* expansion operation matrix */
extern jbyte code ei[48];

/* The (in)famous S-boxes */
extern jdword code sbox[64];

/* =========================================================================
	u.dwBlock[index]
   ========================================================================= */

#define INPUT0		JAYA_DWCRYPTO_INPUT0
#define INPUT1		JAYA_DWCRYPTO_INPUT1
#define KEYTEMP0	2
#define KEYTEMP1	3
#define OUTPUT0		JAYA_DWCRYPTO_OUTPUT0
#define OUTPUT1		JAYA_DWCRYPTO_OUTPUT1
#define RESTEMP0	6
#define RESTEMP1	7
#define KEYI0		8
#define KEYI1		9
#define EXT0		10
#define EXT1		11
#define KEY0		12
#define KEY1		13
#define TEMP0		14
#define TEMP1		15

/* =========================================================================
	__hal_des_ker()
   ========================================================================= */

void __hal_des_ker(jbool mode)
{
	LOCAL(signed char,i);
	LOCAL(signed char,j);

	/* init */
	u.dwBlock[RESTEMP0] = 0;
	u.dwBlock[RESTEMP1] = 0;
	u.dwBlock[TEMP0] = 0;
	u.dwBlock[TEMP1] = 0;

	/* ip */
	for( i=63 ; i>31 ; i--) {
		u.dwBlock[RESTEMP1] ^= (((u.dwBlock[INPUT0 + (ip[i] >> 5)] << (ip[i] & 0x1F)) & 0x80000000L) >> (i & 0x1F));
	}

	for( i=31 ; i>=0 ; i--) {
		u.dwBlock[RESTEMP0] ^= (((u.dwBlock[INPUT0 + (ip[i] >> 5)] << (ip[i] & 0x1F)) & 0x80000000L) >> i);
	}

	/* pc1 */
	for( i=55; i>31 ; i--) {
		u.dwBlock[TEMP1] ^= (((u.dwBlock[KEY0 + (pc1[i] >> 5)] << (pc1[i] & 0x1F)) & 0x80000000L) >> (i & 0x1F));
	}
	for( i=31; i>=0 ; i--) {
		u.dwBlock[TEMP0] ^= (((u.dwBlock[KEY0 + (pc1[i] >> 5)] << (pc1[i] & 0x1F)) & 0x80000000L) >> i);
	}

	/* KEYTEMP split */
	u.dwBlock[KEYTEMP0] = u.dwBlock[TEMP0] & 0xFFFFFFF0L;
	u.dwBlock[KEYTEMP1] = (u.dwBlock[TEMP0] << 28) ^ (u.dwBlock[TEMP1] >> 4);

	/* 16 rounds of the internal DES */
	for (i=0 ; i<16 ; i++) {

		/* Extension */
		u.dwBlock[EXT1] = (u.dwBlock[RESTEMP1] >> 15) & 0x10000 ;
		u.dwBlock[EXT0] = (u.dwBlock[RESTEMP1] >> 11) & 1;

		for(j=46 ; j>31 ; j--)
			u.dwBlock[EXT1] ^= (((u.dwBlock[RESTEMP1] << ei[j]) & 0x80000000L) >> (j & 0x1F));
		for(j=30 ; j>=0 ; j--)
			u.dwBlock[EXT0] ^= (((u.dwBlock[RESTEMP1] << ei[j]) & 0x80000000L) >> j);

		/* Key j */
		if((i==0) || (i==1) || (i==8) || (i==15)) {
			j = 1;
		} else {
			j = 2;
		}

		/* Cipher (K1 -> K16) or decipher (K16 -> K1) */
		if (mode==ENCIPHER) {
			u.dwBlock[KEYTEMP0] = ((u.dwBlock[KEYTEMP0] << j) ^ (u.dwBlock[KEYTEMP0] >> (28-j))) & 0xFFFFFFF0L;
			u.dwBlock[KEYTEMP1] = ((u.dwBlock[KEYTEMP1] << j) ^ (u.dwBlock[KEYTEMP1] >> (28-j))) & 0xFFFFFFF0L;
		} else {
			if (i) {
				u.dwBlock[KEYTEMP0] = ((u.dwBlock[KEYTEMP0] << (28-j)) ^ (u.dwBlock[KEYTEMP0] >> j)) & 0xFFFFFFF0L;
				u.dwBlock[KEYTEMP1] = ((u.dwBlock[KEYTEMP1] << (28-j)) ^ (u.dwBlock[KEYTEMP1] >> j)) & 0xFFFFFFF0L;
			}
		}

		/* pc2 */
		u.dwBlock[KEYI1] = (u.dwBlock[KEYTEMP1] >> 12) & 0x10000;
		u.dwBlock[KEYI0] = (u.dwBlock[KEYTEMP1] >> 20) & 1;

		for( j=46 ; j>31 ; j--) {
			u.dwBlock[KEYI1] ^= (((u.dwBlock[KEYTEMP0 + (pc2[j] >> 5)] << (pc2[j] & 0x1F)) & 0x80000000L) >> (j & 0x1F));
		}
		for( j=30 ; j>=0 ; j--) {
			u.dwBlock[KEYI0] ^= (((u.dwBlock[KEYTEMP0 + (pc2[j] >> 5)] << (pc2[j] & 0x1F)) & 0x80000000L) >> j);
		}

		/* xor E(A) + Ki */
		u.dwBlock[EXT0] ^= u.dwBlock[KEYI0];
		u.dwBlock[EXT1] ^= u.dwBlock[KEYI1];

		/* sbox + P */
		u.dwBlock[TEMP1] = (u.dwBlock[EXT1] >> 16) & 0x3F;
		u.dwBlock[TEMP0] = (sbox[u.dwBlock[TEMP1]] & 0x08020820);
		u.dwBlock[TEMP1] = (u.dwBlock[EXT1] >> 22) & 0x3F;
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x02100401);
		u.dwBlock[TEMP1] = ((u.dwBlock[EXT0] & 3) << 4) ^ (u.dwBlock[EXT1] >> 28);
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x10202008);
		u.dwBlock[TEMP1] = (u.dwBlock[EXT0] >> 2) & 0x3F;
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x21040080);
		u.dwBlock[TEMP1] = (u.dwBlock[EXT0] >> 8) & 0x3F;
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x80401040);
		u.dwBlock[TEMP1] = (u.dwBlock[EXT0] >> 14) & 0x3F;
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x04010104);
		u.dwBlock[TEMP1] = (u.dwBlock[EXT0] >> 20) & 0x3F;
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x40084010);
		u.dwBlock[TEMP1] = u.dwBlock[EXT0] >> 26;
		u.dwBlock[TEMP0] ^= (sbox[u.dwBlock[TEMP1]] & 0x00808202);

		/* xor L(j-1) + f(R(j-1), Ki) */
		u.dwBlock[TEMP0] ^= u.dwBlock[RESTEMP0];

		/* copy the result to RESTEMP */
		u.dwBlock[RESTEMP0] = u.dwBlock[RESTEMP1];
		u.dwBlock[RESTEMP1] = u.dwBlock[TEMP0];
	}

	/* swap RESTEMP values */
	u.dwBlock[TEMP0]    = u.dwBlock[RESTEMP0];
	u.dwBlock[RESTEMP0] = u.dwBlock[RESTEMP1];
	u.dwBlock[RESTEMP1] = u.dwBlock[TEMP0];

	/* fp */
	u.dwBlock[OUTPUT0] = 0;
	u.dwBlock[OUTPUT1] = 0;

	for(i=63 ; i>31 ; i--) {
		u.dwBlock[OUTPUT1] ^= (((u.dwBlock[RESTEMP0 + (fp[i] >> 5)] << (fp[i] & 0x1F)) & 0x80000000L) >> (i & 0x1F));
	}
	for(i=31 ; i>=0 ; i--) {
		u.dwBlock[OUTPUT0] ^= (((u.dwBlock[RESTEMP0 + (fp[i] >> 5)] << (fp[i] & 0x1F)) & 0x80000000L) >> i);
	}
}

/* =========================================================================
	__hal_des()
   ========================================================================= */

#ifdef JAYACFG_SOFTWARE_DES

void __hal_des(jbool mode)
{
	/* transfert endianess */
	blk0(INPUT0); blk0(INPUT1);

	u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+3]);
	u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+7]);

	__hal_des_ker(mode);

	/* transfert endianess */
	blk0(OUTPUT0); blk0(OUTPUT1);
}

#endif
/* JAYACFG_SOFTWARE_DES */

/* =========================================================================
	__hal_desx()

	Implementations MUST ignore (i.e. not check) the parity bits of the
 	single-DES key. KeyGenerators for DESX SHOULD generate entirely random
 	keys (possibly avoiding DES weak keys). In the case of a 16-byte key,
 	the input to the "hash procedure" which generates K2 is the original
 	user key, without any adjustment to parity.
 ========================================================================= */

#ifdef JAYACFG_SOFTWARE_DESX

void __hal_desx(jbool mode)
{
	/* transfert endianess */
	blk0(INPUT0); blk0(INPUT1);

	u.dwBlock[INPUT0] ^= (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+3]);
	u.dwBlock[INPUT1] ^= (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+7]);

	u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+3]);
	u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+7]);

	__hal_des_ker(mode);

	/* transfert endianess */
	blk0(OUTPUT0); blk0(OUTPUT1);
}

#endif

/* =========================================================================
	__hal_3des()
   ========================================================================= */

#ifdef JAYACFG_SOFTWARE_3DES

void __hal_3des(jbool mode)
{
	/* transfert endianess */
	blk0(INPUT0); blk0(INPUT1);

	if (mode==ENCIPHER) {
		u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+3]);
		u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+7]);
	} else {
		u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+3]);
		u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+7]);
	}

	__hal_des_ker(mode);

	u.dwBlock[INPUT0] = u.dwBlock[OUTPUT0];
	u.dwBlock[INPUT1] = u.dwBlock[OUTPUT1];

	u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+3]);
	u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYB+7]);

	__hal_des_ker(!mode);

	u.dwBlock[INPUT0] = u.dwBlock[OUTPUT0];
	u.dwBlock[INPUT1] = u.dwBlock[OUTPUT1];

	if (mode==ENCIPHER) {
		u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+3]);
		u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYC+7]);
	} else {
		u.dwBlock[KEY0] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+0])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+1])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+2])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+3]);
		u.dwBlock[KEY1] = (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+4])<<24) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+5])<<16) | (((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+6])<<8) | ((jdword)r.bBlock[JAYA_BCRYPTO_KEYA+7]);
	}

	__hal_des_ker(mode);

	/* transfert endianess */
	blk0(OUTPUT0); blk0(OUTPUT1);
}

#endif

/* =========================================================================
	That's all folks !
   ========================================================================= */
#endif
/* JAYACFG_DES_KER */