sctloc.c

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

		SCTparam(&ptr, RQP1.kid, RQP2.acp);

		SCTplength(&ptr, ldata);

		SCTssc(&ptr, p_elem);


		if ((RQP2.acp == PIN_USER) || (RQP2.acp == PUK_CHECK)) {
			SCTbinval(&ptr, class);
			*flag = TRUE;
		}
		break;


		/*---------------------------------------------------------*/
		/* create S_GET_TRANSPORT_KEY                              */
		/* this command will always be send in plaintext           */
		/*---------------------------------------------------------*/
	case S_GET_TRANSPORT_KEY:
		ldata = 0;
		no_secure_cmd = TRUE;

		if ((s_apdu = SCTalloc(ldata, &p_elem->secure_messaging,
				       lapdu)) == NULL)
			return (NULL);

		ptr = s_apdu + 2;
		*ptr++ = S_NOTUSED;
		*ptr++ = RQP2.algid;
		*ptr = ldata;
		if (p_elem->secure_messaging.command != SEC_NORMAL)
			*lapdu = *lapdu - 1;
		break;

		/*----------------------------*/
		/* create S_GEN_SESSION_KEY  */
		/*---------------------------*/
	case S_GEN_SESSION_KEY:
		no_secure_cmd = TRUE;

		if ((RQDATSESS == SESSNULL) ||
		    (RQDATSESS->session_key == BYTENULL) ||
		    (RQDATSESS->session_key->nbytes == 0) ||
		    (RQDATSESS->session_key->bytes == NULL)) {
			sct_errno = EPARMISSED;
			sct_errmsg = sct_error[sct_errno].msg;
			return (NULL);
		};


		ldata = 3 + RQDATSESS->session_key->nbytes;

		if ((s_apdu = SCTalloc(ldata, &p_elem->secure_messaging,
				       lapdu)) == NULL)
			return (NULL);


		ptr = s_apdu + 2;

		SCTparam(&ptr, S_NOTUSED, RQP2.algid);

		SCTplength(&ptr, ldata);

		SCTsessionkey(&ptr, RQDATSESS);

		if (p_elem->secure_messaging.command != SEC_NORMAL)
			*lapdu = *lapdu - 1;
		break;

		/*----------------------------*/
		/* create S_WRITE_KEYCARD    */
		/*---------------------------*/
	case S_WRITE_KEYCARD:

/* old implementation */

#ifdef OLDIMPL

		if ((RQDATWRITE == WRITENULL) ||
		    (RQDATWRITE->pin_record == BYTENULL) ||
		    (RQDATWRITE->pin_record->nbytes == 0) ||
		    (RQDATWRITE->pin_record->bytes == NULL)) {
			sct_errno = EPARMISSED;
			sct_errmsg = sct_error[sct_errno].msg;
			return (NULL);
		};


		ldata = LofKeycard(RQDATWRITE);

		if ((s_apdu = SCTalloc(ldata, &p_elem->secure_messaging,
				       lapdu)) == NULL)
			return (NULL);
		ptr = s_apdu + 2;

		if (RQP2.status == DEV_OWN) {
			purpose = SCTpurpose(&RQP1.dev_inst_key->pval.purpose);
			SCTparam(&ptr, purpose, RQP2.status);
		} else
			SCTparam(&ptr, RQP1.dev_inst_key->pval.kid, RQP2.status);

		SCTplength(&ptr, ldata);

		SCTssc(&ptr, p_elem);

		SCTwritekeycard(&ptr, RQDATWRITE, RQP2.status);
#endif

		if (RQDATWRITE == WRITENULL) {
			sct_errno = EPARMISSED;
			sct_errmsg = sct_error[sct_errno].msg;
			return (NULL);
		};
		ldata = 0;
		if (RQDATWRITE->auth_keyid != 0x00)
			ldata++;
		if (RQDATWRITE->sec_auth_keyid != 0x00)
			ldata++;
		if (RQDATWRITE->sec_con_keyid != 0x00)
			ldata++;
		if (ldata == 0) {
			sct_errno = EPARMISSED;
			sct_errmsg = sct_error[sct_errno].msg;
			return (NULL);
		};




		if ((s_apdu = SCTalloc(ldata, &p_elem->secure_messaging,
				       lapdu)) == NULL)
			return (NULL);
		ptr = s_apdu + 2;
		SCTparam(&ptr, 0x00, RQP2.status);


		SCTplength(&ptr, ldata);

		SCTssc(&ptr, p_elem);


		if (RQDATWRITE->auth_keyid != 0x00)
			SCTplength(&ptr, RQDATWRITE->auth_keyid & 0xFF);

		if (RQDATWRITE->sec_auth_keyid != 0x00)
			SCTplength(&ptr, RQDATWRITE->sec_auth_keyid & 0xFF);

		if (RQDATWRITE->sec_con_keyid != 0x00)
			SCTplength(&ptr, RQDATWRITE->sec_con_keyid & 0xFF);

		break;

		/*----------------------------*/
		/* create S_READ_KEYCARD      */
		/*----------------------------*/
	case S_READ_KEYCARD:
		s_apdu = SCTnodata(p_elem, S_NOTUSED, RQP2.status, lapdu);
		break;




		/*----------------------------*/
		/* DEFAULT                    */
		/*----------------------------*/
	default:
		sct_errno = EINVINS;
		sct_errmsg = sct_error[sct_errno].msg;
		return (NULL);
		break;
	};

	if (s_apdu == NULL)
		return (NULL);


	/*------------------------------------*/
	/* create CLASS / INS       in s_apdu */
	/*------------------------------------*/
	if (no_secure_cmd == TRUE)
		class = NON_INTER;
	else
		class = SCTclass(&p_elem->secure_messaging);
	*s_apdu = class;
	*(s_apdu + 1) = command;

	/*------------------------------------*/
	/* print s_apdu                       */
	/*------------------------------------*/

#ifdef STREAM
	sta_aux_sct_apdu(sct_trfp, s_apdu, *lapdu);
#endif


	/*------------------------------------*/
	/* Execute Secure Messaging           */
	/*------------------------------------*/
	if (no_secure_cmd == FALSE) {
		if (p_elem->secure_messaging.command == CONCEALED) {
			in_apdu.nbytes = *lapdu;
			in_apdu.bytes = s_apdu;
			sec_key.nbits = p_elem->session_key.subjectkey.nbits;
			sec_key.bits = p_elem->session_key.subjectkey.bits;
			out_apdu.nbytes = 0;
			out_apdu.bytes = NULL;
			rc = SCTenc(&sec_key, &in_apdu, &out_apdu, DES);
			free(s_apdu);
			if (rc < 0)
				return (NULL);

			s_apdu = out_apdu.bytes;
			*lapdu = out_apdu.nbytes;
		}
	}
	return (s_apdu);

}

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


/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTerr              VERSION   2.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/*  Error - handling                                      */
/*  Search in sct_error - list sw1 / sw2;                 */
/*  return index in sct_errno                             */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*   sw1                       SW1                        */
/*                                                        */
/*   sw2                       SW2                        */
/*                                                        */
/* OUT                                                    */
/*                                                        */
/*                                                        */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   -1                       error                       */
/*--------------------------------------------------------*/
int
SCTerr(sw1, sw2)
	unsigned int    sw1;
	unsigned int    sw2;
{


	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	unsigned int    index = 0;
	unsigned int    listlen = 0;

	/*----------------------------------------------------------*/
	/* Statements                                             */
	/*----------------------------------------------------------*/
	listlen = sizeof(sct_error) / sizeof(SCTerror);
	for (index = 0; index < listlen; index++) {

		if ((sct_error[index].sw1 == sw1) && (sct_error[index].sw2 == sw2)) {
			sct_errno = index;
			sct_errmsg = sct_error[sct_errno].msg;
			return (S_ERR);
		}
	}
	/* sw1 + sw2 not found */
	sct_errno = index - 1;	/* last element in error-list */
	sct_errmsg = sct_error[sct_errno].msg;
	return (S_ERR);

}

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


/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTstatus           VERSION   2.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/*  Send   S_STATUS-command, until SW1 / SW2 <> 0x40/0x41 */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*  lastcmd                   last command                */
/*                                                        */
/*  p_elem                    pointer of portparam struct.*/
/*                                                        */
/*                                                        */
/* OUT                                                    */
/*  response.bytes            pointer of response.bytes   */
/*                                                        */
/*                                                        */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   0                         o.k.                       */
/*                                                        */
/*   -1                        error                      */
/*                             EPARMISSED                 */
/*                             EINVPAR                    */
/*                             EINVINS                    */
/*			       EMEMAVAIL                  */
/*                             ETOOLONG                   */
/*                             sw1/sw2 from SCT response  */
/*                             T1 - ERROR                 */
/*                                                        */
/* CALLED FUNCTIONS                                       */
/*   SCTcreate                                            */
/*   COMtrans                                             */
/*   SCTresponse                                          */
/*   sta_aux_bytestr_free                                 */
/*                                                        */
/*                                                        */
/*                                                        */
/*--------------------------------------------------------*/
int
SCTstatus(lastcmd, p_elem, resp)
	unsigned int    lastcmd;
	struct s_portparam *p_elem;
	Bytestring     *resp;
{
	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	char           *s_apdu;
	unsigned int    lapdu;
	unsigned int    sw1;
	unsigned int    sw2;
	int             i;
	BOOL            flag = FALSE;	/* FLAG, if S_STATUS must be send */
	Request         request;

#ifdef DOS
	long            time1;
	long            time2;

#else
#if defined(MAC) || defined(__HP__)
   time_t time1, time2;
#else 
	struct itimerval value;
	struct itimerval ovalue;
#endif /* MAC */
#endif

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

	/*------------------------------------*/
	/* Initialisation                     */
	/*------------------------------------*/


	/*------------------------------------*/
	/* Create s_apdu                      */
	/*------------------------------------*/
	if ((s_apdu = SCTcreate(p_elem, S_STATUS, &request, &lapdu, &flag)) == NULL)
		return (S_ERR);

	if (lapdu > p_elem->apdusize) {	/* test apdusize */
		sct_errno = ETOOLONG;
		sct_errmsg = sct_error[sct_errno].msg;
		free(s_apdu);
		return (S_ERR);
	};




	/*------------------------------------*/
	/* allocate response-buffer           */
	/*------------------------------------*/