sctloc.c

SecuDe是一个由安全应用程序接口组成,对验证机制、证件处理、PEM、X.400报文处理和密钥管理提供支持。SecuDe提供DES、 RSA杂凑函数、密钥生成以及数字签名的生成和核实等多种密码机制。

/*   -1                        Error                      */
/*				EMEMAVAIL		  */
/*				EDESENC  		  */
/*				EALGO    		  */
/*						          */
/* CALLED FUNCTIONS					  */
/*   des_encrypt                                          */
/*   aux_fxdump                                       */
/*   aux_free2_BitString                                  */
/*							  */
/* Bemerkung:						  */
/* Derzeit wird nur der DES-CBC-Mode unterstuetzt.        */
/* Der DES-3-CBC-Mode noch nicht.			  */
/*--------------------------------------------------------*/
int
SCTenc(sec_key, in_apdu, out_apdu, algenc)
	BitString      *sec_key;/* secure messaging key */
	Bytestring     *in_apdu;/* SCT-APDU		 */
	Bytestring     *out_apdu;	/* SCT-SEC-APDU		 */
	AlgEnc         algenc;	/* encryption method		 */
{
	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	OctetString     in_octets;
	char           *ptr;
	int             i;
	int             memolen;
	BitString       out_bits;
	KeyInfo         key_info;
	More            more;


	/*----------------------------------------------------------*/
	/* Statements                                             */
	/*----------------------------------------------------------*/
	out_apdu->nbytes = 0;
	out_apdu->bytes = NULL;
	in_octets.noctets = in_apdu->nbytes;
	in_octets.octets = in_apdu->bytes;

	/*---------------------------------------------------------*/
	/* encrypt data (INS,P1,P2,L,SSC,DATA)                     */
	/* with Secure Messaging Key                               */
	/*---------------------------------------------------------*/
	in_octets.noctets -= 1;
	in_octets.octets++;

#ifdef STREAM
	fprintf(sct_trfp, "TRACE in SCTenc\n");
	fprintf(sct_trfp, "   sec_key.nbits     = %d\n", sec_key->nbits);
	fprintf(sct_trfp, "   sec_key.bits      = \n");
	aux_fxdump(sct_trfp, sec_key->bits, sec_key->nbits / 8, 0);
	fprintf(sct_trfp, "   in_octets.noctets = %d\n", in_octets.noctets);
	fprintf(sct_trfp, "   in_octets.octets  = \n");
	aux_fxdump(sct_trfp, in_octets.octets, in_octets.noctets, 0);
#endif

	key_info.subjectkey.nbits = sec_key->nbits;
	key_info.subjectkey.bits = sec_key->bits;
	switch (algenc) {
	case DES:
		key_info.subjectAI = desCBC;
		break;
	default:
		sct_errno = EALGO;
		sct_errmsg = sct_error[sct_errno].msg;
		return (-1);
		break;
	}
	more = END;
	/* allocate memory for out_bits  */
	/* the memory must be a multiple of 8 Bytes */
	if ((in_octets.noctets % 8) != 0)
		memolen = (in_octets.noctets - (in_octets.noctets % 8)) + 8;
	else
		memolen = in_octets.noctets;

	out_bits.nbits = 0;

#ifdef STREAM
	fprintf(sct_trfp, "   allocate out_bits = %d\n", memolen);
#endif

#ifdef MALLOC
	out_bits.bits = malloc(memolen);	/* will be set free in this
						 * proc. */
	if (out_bits.bits == NULL) {
		sct_errno = EMEMAVAIL;
		sct_errmsg = sct_error[sct_errno].msg;
		return (-1);
	}
#endif



	memolen = des_encrypt(&in_octets, &out_bits, more, &key_info);
	if (memolen == -1) {
		sct_errno = EDESENC;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_BitString(&out_bits);
		return (-1);
	}
#ifdef STREAM
	fprintf(sct_trfp, "   out_bits.nbits    = %d\n", out_bits.nbits);
	fprintf(sct_trfp, "   out_bits.bits     = \n");
	aux_fxdump(sct_trfp, out_bits.bits, out_bits.nbits / 8, 0);
#endif


	memolen = (out_bits.nbits / 8) + 1;

#ifdef MALLOC
	out_apdu->bytes = malloc(memolen);	/* if no error => return	  */
	/* else will gbe set free in this proc. */
	if (out_apdu->bytes == NULL) {
		sct_errno = EMEMAVAIL;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_BitString(&out_bits);
		return (-1);
	}
#endif

	out_apdu->nbytes = memolen;
	ptr = out_apdu->bytes;
	*ptr = *in_apdu->bytes;	/* transfer CLA-Byte */
	ptr++;
	for (i = 0; i < (out_bits.nbits / 8); i++) {
		*ptr = *(out_bits.bits + i);
		ptr++;
	};
	aux_free2_BitString(&out_bits);

#ifdef STREAM
	fprintf(sct_trfp, "   out_apdu->nbytes  = %d\n", out_apdu->nbytes);
	fprintf(sct_trfp, "   out_apdu->bytes   = \n");
	aux_fxdump(sct_trfp, out_apdu->bytes, out_apdu->nbytes, 0);
	fprintf(sct_trfp, "TRACE-END in SCTenc\n");
#endif


	return (0);


}

/*-------------------------------------------------------------*/
/* E N D   O F   P R O C E D U R E      SCTenc                 */
/*-------------------------------------------------------------*/




/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTdec              VERSION   2.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/*  Decrypt SEC-RESPONSE-APDU                             */
/*  This procedure can be called in case of               */
/*  secure messaging = CONCEALED.                         */
/*                                                        */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*   sec_key		       Secure Messaging key	  */
/*							  */
/*   ssc		       Send Sequence Counter      */
/*							  */
/*   in_apdu		       Pointer of SEC-APDU        */
/*			       The SEC-APDU have the      */
/*			       structure	          */
/*		               _________________          */
/*			      | ENCRYPTED DATA  |         */
/*		               _________________          */
/*			       or			  */
/*		                _________________         */
/*			       | L = 0,SW1,SW2   |        */
/*		                _________________         */
/*   algenc		       Encryption method	  */
/*							  */
/*							  */
/* OUT                                                    */
/*   out_apdu                  Pointer of SC-APDU         */
/*			       out_apdu->bytes will be    */
/*			       allocated by the called    */
/*			       program			  */
/*			       and must be set free by the*/
/*			       calling program            */
/*			       The APDU has the structure:*/
/*		                _________________         */
/*			       | L,DATA,SW1,SW2  |        */
/*		                _________________         */
/*                                                        */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   0                         o.k                        */
/*   -1                        Error                      */
/*				EMEMAVAIL		  */
/*				EDESDEC  		  */
/*				ESSC			  */
/*				EALGO			  */
/*						          */
/* CALLED FUNCTIONS					  */
/*   des_decrypt                                          */
/*   aux_fxdump                                       */
/*   sta_aux_bytestr_free			          */
/*   aux_free2_OctetString				  */
/* Bemerkung:						  */
/* Derzeit wird nur der DES-CBC-Mode unterstuetzt.        */
/* Der DES-3-CBC-Mode noch nicht.			  */
/*--------------------------------------------------------*/
int
SCTdec(sec_key, ssc, in_apdu, out_apdu, algenc)
	BitString      *sec_key;/* secure messaging key */
	int             ssc;	/* Send sequence Counter */
	Bytestring     *in_apdu;/* SEC-APDU		 */
	Bytestring     *out_apdu;	/* SC-APDU		 */
	AlgEnc         algenc;	/* encryption method		 */
{
	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	OctetString     out_octets;
	char           *ptr, *apdu_ptr;
	int             i;
	int             memolen;
	BitString       in_bits;
	KeyInfo         key_info;
	More            more;
	int             rec_ssc, data_len;

	/*----------------------------------------------------------*/
	/* Statements                                             */
	/*----------------------------------------------------------*/

#ifdef STREAM
	fprintf(sct_trfp, "TRACE in SCTdec\n");
	fprintf(sct_trfp, "   sec_key.nbits     = %d\n", sec_key->nbits);
	fprintf(sct_trfp, "   sec_key.bits      = \n");
	aux_fxdump(sct_trfp, sec_key->bits, sec_key->nbits / 8, 0);
	fprintf(sct_trfp, "   in_apdu->nbytes   = %d\n", in_apdu->nbytes);
	fprintf(sct_trfp, "   in_apdu->bytes    = \n");
	aux_fxdump(sct_trfp, in_apdu->bytes, in_apdu->nbytes, 0);
#endif

	/*---------------------------------------------------------*/
	/* decrypt data                                            */
	/* with Secure Messaging Key                               */
	/*---------------------------------------------------------*/
	/* allocate memory for out_octets  */
	out_octets.noctets = 0;

#ifdef MALLOC
	out_octets.octets = malloc(in_apdu->nbytes);	/* will be set free in
							 * this proc. */
	if (out_octets.octets == NULL) {
		sct_errno = EMEMAVAIL;
		sct_errmsg = sct_error[sct_errno].msg;
		return (-1);
	}
#endif

	key_info.subjectkey.nbits = sec_key->nbits;
	key_info.subjectkey.bits = sec_key->bits;
	switch (algenc) {
	case DES:
		key_info.subjectAI = desCBC;
		break;
	default:
		aux_free2_OctetString(&out_octets);
		sct_errno = EALGO;
		sct_errmsg = sct_error[sct_errno].msg;
		return (-1);
		break;
	}
	more = END;

	in_bits.nbits = in_apdu->nbytes * 8;
	in_bits.bits = in_apdu->bytes;
	more = END;
	memolen = des_decrypt(&in_bits, &out_octets, more, &key_info);

	if (memolen == -1) {
		sct_errno = EDESDEC;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_OctetString(&out_octets);
		return (-1);
	}
#ifdef STREAM
	fprintf(sct_trfp, "   out_octets.noctets= %d\n", out_octets.noctets);
	fprintf(sct_trfp, "   out_octets.octets = \n");
	aux_fxdump(sct_trfp, out_octets.octets, out_octets.noctets, 0);
#endif

	/* CONCEALED-Mode -> Test SSC; return L,DATA,SW1,SW2 */
	/* allocate out_data->bytes */
	out_apdu->nbytes = *out_octets.octets + 3;	/* 4 = L,DATA,SW1,SW2 */

#ifdef MALLOC
	out_apdu->bytes = malloc(out_apdu->nbytes);	/* if no error => return */
	/* else will be set free in this proc. */
	if (out_apdu->bytes == NULL) {
		sct_errno = EMEMAVAIL;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_OctetString(&out_octets);
		return (-1);
	}
#endif

	/* copy L,DATA,SW1,SW2 from out_octets.octets into out_apdu->bytes */
	ptr = out_apdu->bytes;
	apdu_ptr = out_octets.octets;
	*ptr = *apdu_ptr++;	/* Length-field */
	data_len = *ptr;
	ptr++;
	rec_ssc = *apdu_ptr++ & 0xFF;	/* SSC		 */

#ifdef STREAM
	fprintf(sct_trfp, "   rec_ssc           = %x\n", (rec_ssc & 0xFF));
	fprintf(sct_trfp, "   akt_ssc           = %x\n", (ssc & 0xFF));
#endif

	/* check SSC	 */
	if (rec_ssc != (ssc & 0xFF)) {
		sct_errno = ESCT_SSC;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_OctetString(&out_octets);
		sta_aux_bytestr_free(out_apdu);
		return (-1);
	}
	for (i = 0; i < data_len + 2; i++) {	/* Data, SW1, SW2 */
		*ptr = *apdu_ptr++;
		ptr++;
	}

	aux_free2_OctetString(&out_octets);

#ifdef STREAM
	fprintf(sct_trfp, "   out_apdu->nbytes  = %d\n", out_apdu->nbytes);
	fprintf(sct_trfp, "   out_apdu->bytes   = \n");
	aux_fxdump(sct_trfp, out_apdu->bytes, out_apdu->nbytes, 0);
	fprintf(sct_trfp, "TRACE-END in SCTdec\n");
#endif

	return (0);



}

/*-------------------------------------------------------------*/
/* E N D   O F   P R O C E D U R E      SCTdec                 */
/*-------------------------------------------------------------*/





/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTalloc            VERSION   2.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/*  Allocate buffer                                       */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*   datalen                   length of datafield        */
/*                                                        */
/*   secure                    secure messaging           */
/*                                                        */
/* OUT                                                    */
/*   pdulen                     length of s_apdu          */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   pointer                   o.k.                       */
/*                                                        */
/*   NULL                      error                      */
/*                              EMEMAVAIL;                */
/*--------------------------------------------------------*/
static char    *
SCTalloc(datalen, secure, pdulen)
	unsigned int    datalen;
	SecMess        *