simueep.c

一个免费的SMART CARD OS系统。

/* ============================================================================
   Project Name : jayaCard
   Module Name  : proto/hal/simu/simueep.c
   Version : $Id: simueep.c,v 1.24 2004/03/07 10:43:23 dgil Exp $

	Description: EEPROM read/write of buffer from/into binary file

    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
   072102 dgil	wrote it from scratch
   ============================================================================
*/

#include "precomp.h"

/* =========================================================================
	Header of current eeprom file
   ========================================================================= */

EEPROM_FILE_HEADER	gHdrEEPROM;

/* =========================================================================
	check EEPROM against current COS configuration
   ========================================================================= */

jbool	__check_eeprom_version()
{
	LOG5("EEPROM","HdrVersion=%d Endianess=%x COSVersion=%d.%d.%d",
			gHdrEEPROM.byHdrVersion,
			gHdrEEPROM.wEndianess,
			gHdrEEPROM.byCOSVersion,
			gHdrEEPROM.byCOSSubversion,
			gHdrEEPROM.wCOSBuild
			);

	if (gHdrEEPROM.byHdrVersion<EEPROM_FILE_HEADER_HDR_VERSION) {
		fprintf(stderr,"__check_eeprom_version(): eeprom file is older than the current COS version requirement !\n");
		return jfalse;
	}
	if (gHdrEEPROM.byHdrVersion>EEPROM_FILE_HEADER_HDR_VERSION) {
		fprintf(stderr,"__check_eeprom_version(): eeprom file is newer than the current COS version requirement !?!\n");
		return jfalse;
	}
	#ifdef PLATFORM_LITTLE_ENDIAN
	if (gHdrEEPROM.wEndianess != EEPROM_PLATFORM_LITTLE_ENDIAN) {
		fprintf(stderr,"__check_eeprom_version(): eeprom file must be little endian ! \n");
		return jfalse;
	}
	#else
	if (gHdrEEPROM.wEndianess != EEPROM_PLATFORM_BIG_ENDIAN) {
		fprintf(stderr,"__check_eeprom_version(): eeprom file must be big endian ! \n");
		return jfalse;
	}
	#endif

	return jtrue;
}

/* =========================================================================
	__simu_blank_area()

	description
		blank the EEPROM content
		erase the OTP content
		store the manufacturing datas
		store the chip uuid

		our default manufacturing data is :
 		0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 		i  i  i  i  S  S  S  S  b  b  b  b  b  W  X  Y
 		k  k  K  K  K  K  K  K  K  K  K  K  K  K  K  K
 		K  K  A  M  t  t 00 00  V  V  V  V 00 00 00 00
 		R  R  R  R  R  R  R  R  R  R  R  R  R  R  R  R

 		where
  			K	master key
			k	master key CRC
			A	master key attempt counter
			t	Time stamp - BCD - 2 bytes
			i	die number - binary - 1 to 4 bytes
			S	serial number - binary - 1 to 4 bytes
  			b	batch number - BCD - 3 to 5 bytes
			W	wafer number - binary - 1 byte
			X	X-coordinate - binary - 1 byte
			Y	Y-ccordinate - binary - 1 byte
			R	random byte - binary
			M	manufacturer - binary - 1 byte
	  		V   mask version - binary - 4 bytes (Version.SubVersion.Build)
   ========================================================================= */

jbyte gCHIP_UUID[] = {
	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08
};

jbyte gMANUFACTURING_DATA[] = {
	0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x01,
	0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x70,0x60,0x50,0x40,0x30,0x20,0x10,				/* default MSK */
	0x55,0xAA,0x03,0x01,0x00,0x01,0x00,0x00,VERSION,SUBVERSION,0x00,BUILDNUM,0x00,0x00,0x00,0x00
};

jbool __simu_blank_eeprom(void)
{
	FILE*	f;
	jword	n;
	jword	adr;

	/* default content of the whole array */
	memset(gEEPROM,0xAA,sizeof(gEEPROM));

	/* blank eeprom */
	for (adr=BASE_EEPROM;adr<=END_EEPROM;adr++) {
		gEEPROM[adr] = DEFAULT_CELL_VALUE;
	}

	/* existing MANUFACTURING DATA file ? => update Manufacturing Data with its content */
	f = fopen("mdata.bin","rb");
	if (f!=NULL) {
		adr = 0;
		while ( (!feof(f)) && (adr<0x30) ) {
			n = fread(&gMANUFACTURING_DATA[adr],1,1,f);
			if (n!=1) {
				fprintf(stderr,"__simu_blank_eeprom(): can't read from the 'mdata.bin' file !\n");
				fclose(f);
				return jfalse;
			}
			adr++;
		}

		fclose(f);
		LOG("EEPROM","Info: 'mdata.bin' file has been loaded in MANUFACTURING DATA !");
	}

	/* existing MSK file ? => update Manufacturing Data with its content */
	f = fopen("msk.bin","rb");
	if (f!=NULL) {
		n = fread(&gMANUFACTURING_DATA[16+2],1,16,f);
		if (n!=16) {
			fprintf(stderr,"__simu_blank_eeprom(): can't read from the 'msk.bin' file !\n");
			fclose(f);
			return jfalse;
		}

		fclose(f);
		LOG("EEPROM","Info: 'msk.bin' key file has been loaded in MANUFACTURING DATA !");
	}

	/* calculate the MSK CRC */
	HAL_CRC_INIT();
	for (n=0;n<16;n++) {
		HAL_CRC_COMPUTE(gMANUFACTURING_DATA[16+n+2]);
		/* printf("~%.2X",gMANUFACTURING_DATA[16+n+2]); */
	}
	gMANUFACTURING_DATA[16] = HAL_CRC_LO();
	/* printf("~%.2X",gMANUFACTURING_DATA[16]); */
	gMANUFACTURING_DATA[17] = HAL_CRC_HI();
	/* printf("~%.2X",gMANUFACTURING_DATA[17]); */

	/* store manufacturing data */
	for (adr=BASE_MANUFACTURING_DATA;adr<END_MANUFACTURING_DATA;adr++) {
		gEEPROM[adr] = gMANUFACTURING_DATA[adr-BASE_MANUFACTURING_DATA];
	}

	/* fill random area */
	for (adr=ADDR_RANDOM;adr<(ADDR_RANDOM+SIZE_RANDOM);adr++) {
		/* fill with random */
		gEEPROM[adr] = HAL_RANDOM_BYTE();
	}

	/* erase OTP area */
	for (adr=BASE_OTP;adr<=END_OTP;adr++) {
		gEEPROM[adr] = 0x00;
	}

	/* existing UUID file ? => update CHIP_UUID with its content */
	f = fopen("uuid.bin","rb");
	if (f!=NULL) {
		n = fread(&gCHIP_UUID[0],1,8,f);
		if (n!=8) {
			fprintf(stderr,"__simu_blank_eeprom(): can't read from the 'uuid.bin' file !\n");
			fclose(f);
			return jfalse;
		}

		fclose(f);
		LOG("EEPROM","Info: 'uuid.bin' file has been loaded in EEPROM !");
	}

	/* store chip uuid */
	for (adr=ADDR_CHIP_UUID;adr<(ADDR_CHIP_UUID+0x08);adr++) {
		gEEPROM[adr] = gCHIP_UUID[adr-ADDR_CHIP_UUID];
	}

	LOG("EEPROM","Info: EEPROM has been erased / OTP erased / Manufacturing Data generated !");
	return jtrue;
}

/* =========================================================================
	__simu_load_eeprom()

	Load an existing eeprom<XXX>.bin binary file with the content of the
 	EEPROM.
   ========================================================================= */

jbool __simu_load_eeprom(int life)
{
	FILE*	f;
	jint32	n;
	char	szFilename[80];

	if (life==EEPROM_FILE_LIVE) {
		strcpy(szFilename,"eeprom.bin");
	} else {
		sprintf(szFilename,"eeprom%.3d.bin",life);
	}

	f = fopen(szFilename,"rb");
	if (f==NULL) {
		/* fprintf(stderr,"__simu_load_eeprom(): can't open the '%s' file to
		 * read from !\n",szFilename); */
		return jfalse;
	}

	/* read file header */
	n = fread(&gHdrEEPROM,1,sizeof(EEPROM_FILE_HEADER),f);
	if (n!=sizeof(EEPROM_FILE_HEADER)) {
		fprintf(stderr,"__simu_load_eeprom(): can't read header from the '%s' file !\n",szFilename);
		fclose(f);
		return jfalse;
	}

	/* check versioning of the eeprom file */
	if (!__check_eeprom_version()) return jfalse;

	/* read eeprom content */
	n = fread(&gEEPROM[0],1,sizeof(gEEPROM),f);
	if (n!=sizeof(gEEPROM)) {
		fprintf(stderr,"__simu_load_eeprom(): can't read content from the '%s' file !\n",szFilename);
		fclose(f);
		return jfalse;
	}

	fclose(f);
	LOG1("EEPROM","Info: '%s' file has been loaded !",szFilename);
	return jtrue;

}

/* =========================================================================
	__simu_save_eeprom()

	Write the content of the EEPROM to the binary file.
   ========================================================================= */

jbool __simu_save_eeprom(int life)
{
	FILE*	f;
	jint32	n;
	char	szFilename[80];

	if (life==EEPROM_FILE_LIVE) {
		strcpy(szFilename,"eeprom.bin");
	} else {
		sprintf(szFilename,"eeprom%.3d.bin",life);
	}

	f = fopen(szFilename,"wb");
	if (f==NULL) {
		fprintf(stderr,"__simu_save_eeprom(): can't open the '%s' file to write to !\n",szFilename);
		return jfalse;
	}

	/* prepare header */
	#ifdef PLATFORM_LITTLE_ENDIAN
	gHdrEEPROM.wEndianess = EEPROM_PLATFORM_LITTLE_ENDIAN;
	#else
	gHdrEEPROM.wEndianess = EEPROM_PLATFORM_BIG_ENDIAN;
	#endif

	/* version of the COS which has generated the file (information only) */
	gHdrEEPROM.byCOSVersion = VERSION;
	gHdrEEPROM.byCOSSubversion = SUBVERSION;
	gHdrEEPROM.wCOSBuild = BUILDNUM;

	/* version of the Eeprom File Structure (compatibility checking) */
	gHdrEEPROM.byHdrVersion = EEPROM_FILE_HEADER_HDR_VERSION;

	/* default value for reserved field is 0x00 (to ease future evolution) */
	memset(gHdrEEPROM.reserved,0x00,sizeof(gHdrEEPROM.reserved)/sizeof(jbyte));

	/* write file header */
	n = fwrite(&gHdrEEPROM,1,sizeof(EEPROM_FILE_HEADER),f);
	if (n!=sizeof(EEPROM_FILE_HEADER)) {
		fprintf(stderr,"__simu_save_eeprom(): can't write header to the '%s' file !\n",szFilename);
		fclose(f);
		return jfalse;
	}

	/* write eeprom content */
	n = fwrite(&gEEPROM[0],1,sizeof(gEEPROM),f);
	if (n!=sizeof(gEEPROM)) {
		fprintf(stderr,"__simu_save_eeprom(): can't write content to the '%s' file !\n",szFilename);
		fclose(f);
		return jfalse;
	}

	fclose(f);
	LOG1("EEPROM","Info: '%s' file has been created !",szFilename);
	return jtrue;
}

/* =========================================================================
	That's all folks !
   ========================================================================= */