/* ============================================================================   Project Name : jayaCard   Module Name  : proto/bios/crypto/crypto.c   Version : $Id: crypto.c,v 1.31 2004/01/11 09:56:30 dgil Exp $	Description: Crypto BIOS    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) 2002-2004 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   ============================================================================*/#include "precomp.h"/* =========================================================================	__bios_cipher_init()	algo:		init the IV if required		reset the hardware		prepare information if needed	secure: use global semaphore   ========================================================================= */void __bios_cipher_init(void){	LOG2("CRYPTO","BIOS_CIPHER_INIT: refdata_algo=0x%.2X refdata_pad=0x%.2X",refdata_algo,refdata_pad);    if (BIOS_CALL_OPCODE(OPCODE_INIT_CIPHER)!=JSEC_OK) {        #ifdef JAYACFG_IV_ZERO        if ((refdata_algo&CIPHER_ALGO_CBC_MODE)==CIPHER_ALGO_CBC_MODE) {            HAL_ERASE_XRAM(&u.bBlock[0],sizeof(CRYPTO_BUFFER));            LOG8("CRYPTO","BIOS_CIPHER_INIT: CBC / IV= %.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X",                u.bBlock[JAYA_BCRYPTO_INPUT0+0],                u.bBlock[JAYA_BCRYPTO_INPUT0+1],                u.bBlock[JAYA_BCRYPTO_INPUT0+2],                u.bBlock[JAYA_BCRYPTO_INPUT0+3],                u.bBlock[JAYA_BCRYPTO_INPUT0+4],                u.bBlock[JAYA_BCRYPTO_INPUT0+5],                u.bBlock[JAYA_BCRYPTO_INPUT0+6],                u.bBlock[JAYA_BCRYPTO_INPUT0+7]                );        }        #else        gGlobalSem++;        if ((refdata_algo&CIPHER_ALGO_CBC_MODE)==CIPHER_ALGO_CBC_MODE) {            LOCAL(jbyte,i);            /* init IV with random */            for (i=0; i<(sizeof(CRYPTO_BUFFER)/sizeof(jdword));) {                gGlobalSem--;                BIOS_RANDOM();                u.dwBlock[i++] = u.dwBlock[0];                u.dwBlock[i++] = u.dwBlock[1];                gGlobalSem--;            }            gGlobalSem++;            LOG8("CRYPTO","BIOS_CIPHER_INIT: CBC / IV= %.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X",                u.bBlock[JAYA_BCRYPTO_INPUT0+0],                u.bBlock[JAYA_BCRYPTO_INPUT0+1],                u.bBlock[JAYA_BCRYPTO_INPUT0+2],                u.bBlock[JAYA_BCRYPTO_INPUT0+3],                u.bBlock[JAYA_BCRYPTO_INPUT0+4],                u.bBlock[JAYA_BCRYPTO_INPUT0+5],                u.bBlock[JAYA_BCRYPTO_INPUT0+6],                u.bBlock[JAYA_BCRYPTO_INPUT0+7]                );        } else {            /* devnote: don't touch INPUT in EBC mode, please */            gGlobalSem++;        }        #endif        /* more initialization required by specific algorithm ? */        switch (refdata_algo&(~CIPHER_ALGO_CBC_MODE)) {            #ifdef JAYA_DES            case CIPHER_ALGO_ECB_DES: {                HAL_HARDWARE(HARDWARE_DES);            } break;            #endif            #ifdef JAYA_3DES            case CIPHER_ALGO_ECB_3DES2: {                LOCAL(jbyte,i);                /* keyC <- keyA */                for (i=0;i<8;i++) {                    r.bBlock[JAYA_BCRYPTO_KEYC+i] = r.bBlock[JAYA_BCRYPTO_KEYA+i];                }                HAL_HARDWARE(HARDWARE_DES);            } break;            case CIPHER_ALGO_ECB_3DES3: {                HAL_HARDWARE(HARDWARE_DES);            } break;            #endif            #ifdef JAYA_AES            case CIPHER_ALGO_ECB_AES: {                HAL_HARDWARE(HARDWARE_AES);            } break;            #endif            #ifdef JAYA_DESX            case CIPHER_ALGO_ECB_DESX: {                /* compute pre/post whitening keys */                /* IMPLEMENTME */            } break;            #endif            default:                break;        }    }	#ifdef PARANO_JITTER	/* __x add some jitter with the co-processor working */	#endif}/* =========================================================================	__bios_cipher_block()	Cipher operation just on a block   ========================================================================= */void __bios_cipher_block(jbool mode){	switch (refdata_algo&(~CIPHER_ALGO_CBC_MODE)) {		#ifdef JAYA_DES		case CIPHER_ALGO_ECB_DES:			HAL_DES(mode);			break;		#endif		#ifdef JAYA_DESX		case CIPHER_ALGO_ECB_DESX:			HAL_DESX(mode);			break;		#endif		#ifdef JAYA_3DES		case CIPHER_ALGO_ECB_3DES2:		case CIPHER_ALGO_ECB_3DES3:			HAL_3DES(mode);			break;		#endif		#ifdef JAYA_AES 		case CIPHER_ALGO_ECB_AES:			HAL_AES(mode);			break;		#endif		default:			LOG2("CRYPTO","Hummm. Unknown cipher %d algorithm %d !",mode,refdata_algo);			BIOS_SETERR(ERR_INVALID_ALGO);			HAL_HALT();			break;	}}/* =========================================================================	__bios_pad()	Note: this version supports only CHUNK sized to 8 bytes   ========================================================================= */void __bios_pad(jbyte xdata* buf,jbyte len){	LOCAL(jbyte,i);	switch (refdata_pad) {		case REFDATA_PAD_SPACE:		{			LOG1("CRYPTO","__bios_pad() - pad with space len=%d",len);			for (i=len ; i<8 ; i++) buf[i] = 0x20;		} break;		case REFDATA_PAD_ZERONUM:		{			LOG1("CRYPTO","__bios_pad() - pad with 000..00N len=%d",len);			for (i=len ; i<7 ; i++) buf[i] = 0x00;			buf[7] = 8-len;		} break;		case REFDATA_PAD_PKCS5:		{			LOG1("CRYPTO","__bios_pad() - pad with pkcs5 NNN...NN len=%d",len);			for (i=len ; i<8 ; i++) buf[i] = 8-len;		} break;		case REFDATA_PAD_EMV:		{			LOG1("CRYPTO","__bios_pad() - pad with emv 8000..00 len=%d",len);			buf[len]=0x80;			for (i=len+1 ; i<8 ; i++) buf[i] = 0x00;		} break;		default:			LOG1("CRYPTO","__bios_pad() - unknown padding method %d",refdata_pad);			/* fall-through */		case REFDATA_PAD_ZERO:		{			LOG1("CRYPTO","__bios_pad() - pad with 000...000 len=%d",len);			for (i=len ; i<8 ; i++) buf[i] = 0x00;		} break;	}	LOG8("CRYPTO","padded buffer = %.2X %.2X %.2X %.2X %.2X %.2X %.2X %.2X",			buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]			);}/* =========================================================================	__bios_cipher()	Note: this version supports only CHUNK sized to 8 bytes   ========================================================================= */jbyte __bios_cipher(jbyte xdata* buf,jbyte len,jbool mode){	LOCAL(jbyte,i);	LOCAL(jbool,bExit);	LOCAL(jbyte,rlen);    /* codop for cipher ? */    if (BIOS_CALL_OPCODE(OPCODE_CIPHER)==JSEC_OK) return len;	bExit = jfalse;	rlen = len;	while (len>=8) {loop:		/* need to XOR the previous output ? */		if ((refdata_algo&CIPHER_ALGO_CBC_MODE)==CIPHER_ALGO_CBC_MODE) {			for (i=0;i<8;i++) {				u.bBlock[JAYA_BCRYPTO_INPUT0+i] = buf[i] ^ u.bBlock[JAYA_BCRYPTO_OUTPUT0+i];			}		} else {			for (i=0;i<8;i++) {				u.bBlock[JAYA_BCRYPTO_INPUT0+i] = buf[i];			}		}		/* call block cipher function */		BIOS_CIPHER_BLOCK(mode);		/* update the output buffer */		for (i=0;i<8;i++) {			buf[i] = u.bBlock[JAYA_BCRYPTO_OUTPUT0+i];		}		/* was the last block */		if (bExit) return rlen;		/* next chunk */		buf = buf + 8;		len = len - 8;	}	/* padding the latest chunk to encipher */    if ((mode==ENCIPHER) && ((refdata_pad != REFDATA_PAD_NOPAD) || (len>0)) ) {		/* one more block ? */		rlen = ((rlen/8)+1)*8;		/* call block pad function */        BIOS_PAD(buf,len);		/* one more block to encipher */		bExit = jtrue;		goto loop;	}	return rlen;}/* =========================================================================	__bios_crypto_cleanup()	secure: use global semaphore   ========================================================================= */void __bios_crypto_cleanup(void){	LOG("CRYPTO","BIOS_CRYPTO_CLEANUP");	/* cleanup the key area and temporary buffers */	HAL_ERASE_XRAM(&u.bBlock[0],sizeof(CRYPTO_BUFFER));	gGlobalSem--;	HAL_ERASE_IRAM(&r.bBlock[0],sizeof(CRYPTO_REGISTERS));	gGlobalSem--;	#ifdef PARANO_JITTER	/* __x add some jitter with the co-processor working */	#endif	/* stop the crypto components */	HAL_HARDWARE(HARDWARE_NONE);	/* gGlobalSem should be == JSEC_SEM-1 */}/* =========================================================================	That's all folks !   ========================================================================= */