crypto.c

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

/* ============================================================================
   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 !
   ========================================================================= */