sctloc.c

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

#ifdef MALLOC
	resp->bytes = malloc(p_elem->apdusize);
#endif

	if (resp->bytes == NULL) {
		sct_errno = EMEMAVAIL;
		sct_errmsg = sct_error[sct_errno].msg;
		free(s_apdu);
		return (S_ERR);
	};

	do {
		/*------------------------------------*/
		/* wait 1 sec, till next S_STATUS     */
		/* will be send                       */
		/*------------------------------------*/

#ifdef DOS
		time(&time1);
		do {
			time(&time2);
		} while ((time2 - time1) < 4);
#else
#if defined(MAC) || defined(__HP__)
      time(&time1);
      do
         time(&time2);
      while ((time2 - time1) < 1);
#else

      signal(SIGALRM,time_int);
      getitimer(ITIMER_REAL,&value);
      value.it_value.tv_sec = 1;    /* geaendert: 2.7.91 5 nach 1 */
      setitimer(ITIMER_REAL,&value,&ovalue);
      pause();
#endif /* !MAC */
#endif
		/*---------------------------------------*/
		/* repeat, until SW1 / SW2 <> SCT waiting */
		/*---------------------------------------*/
		resp->nbytes = 0;
		for (i = 0; i < p_elem->apdusize; i++)
			*(resp->bytes + i) = 0x00;


		/*------------------------------------*/
		/* call transmission-procedure        */
		/*------------------------------------*/

		if (COMtrans(p_elem, s_apdu, lapdu, resp->bytes, &resp->nbytes) == -1) {
			free(s_apdu);
			sta_aux_bytestr_free(resp);
			return (SCTerr(0, tp1_err));
		}
		/*------------------------------------*/
		/* analyse response                   */
		/*------------------------------------*/

		if (SCTresponse(p_elem, S_STATUS, resp, &sw1, &sw2) == -1) {

			free(s_apdu);
			return (S_ERR);
		}
		/*------------------------------------*/
		/* Create s_apdu,if command=concealed */
		/*------------------------------------*/
		if (sw1 == OKSCT && sw2 == SCTWAIT) {
			if (p_elem->secure_messaging.command != SEC_NORMAL) {
				free(s_apdu);
				if ((s_apdu = SCTcreate(p_elem, S_STATUS, &request, &lapdu, &flag)) == NULL) {
					sta_aux_bytestr_free(resp);
					return (S_ERR);
				}
			} else {

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

			/*
			 * allocate new response-buffer, if response =
			 * CONCEALED
			 */
			/*-----------------------------------------------------------------*/

			if (p_elem->secure_messaging.response != SEC_NORMAL) {

				sta_aux_bytestr_free(resp);

#ifdef MALLOC
				resp->bytes = malloc(p_elem->apdusize);
#endif

				if (resp->bytes == NULL) {
					sct_errno = EMEMAVAIL;
					sct_errmsg = sct_error[sct_errno].msg;
					free(s_apdu);
					return (S_ERR);
				};
			}
		}
	} while (sw1 == OKSCT && sw2 == SCTWAIT);

	/*------------------------------------*/
	/* S-STATUS ended;                    */
	/* if lastcmd = S_REQUEST_SC, then    */
	/* store SC-historical characters in  */
	/* p_elem and set sc_request = TRUE in */
	/* p_elem                             */
	/*------------------------------------*/
	/* release old schistory buffer */
	if (lastcmd == S_REQUEST_SC) {
		if (p_elem->schistory != NULL) {
			free(p_elem->schistory);
			p_elem->schistory = NULL;
		}
		/*------------------------------------*/
		/* allocate schistory buffer          */
		/*------------------------------------*/

#ifdef MALLOC
		p_elem->schistory = malloc(resp->nbytes + 1);
#endif

		if (p_elem->schistory == NULL) {
			sct_errno = EMEMAVAIL;
			sct_errmsg = sct_error[sct_errno].msg;
			free(s_apdu);
			sta_aux_bytestr_free(resp);
			return (S_ERR);
		};
		/*------------------------------------*/
		/* store history in p_elem            */
		/*------------------------------------*/
		for (i = 0; i < resp->nbytes; i++)
			*(p_elem->schistory + i) = *(resp->bytes + i);
		*(p_elem->schistory + resp->nbytes) = '\0';

		/*------------------------------------*/
		/* set sc_request in p_elem           */
		/*------------------------------------*/
		p_elem->sc_request = TRUE;

	}
	/*------------------------------------*/
	/* release s_apdu                     */
	/*------------------------------------*/
	free(s_apdu);
	return (S_NOERR);
}

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



/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTcheck            VERSION   2.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/*  Check field, if 1 or 3 Bytes and return integer value */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/*                                                        */
/* INOUT                     DESCRIPTION                  */
/*  buffer                    pointer to buffer           */
/*                                                        */
/*                                                        */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   size                      integer value              */
/*                                                        */
/*--------------------------------------------------------*/
int
SCTcheck(buffer)
	char          **buffer;
{
	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	char           *p;
	int             size;


	/*----------------------------------------------------------*/
	/* Statements                                             */
	/*----------------------------------------------------------*/
	p = *buffer;
	if ((size = ((int) *p++) & 0xFF) >= 255) {
		size = ((((int) *p++) & 0xff) << 8);
		size += (((int) *p++) & 0xFF);
	};
	*buffer = p;
	return (size);
}

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



/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTresponse         VERSION   2.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/* Execute secure messaging for response and check        */
/* sw1 / sw2 .                                            */
/*                                                        */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*  p_elem                    pointer of portparam struct.*/
/*                                                        */
/*  command		      executed command		  */
/*							  */
/*  response		      pointer of response buffer  */
/*                                                        */
/* OUT                                                    */
/*  sw1		              sw1 - value                 */
/*                                                        */
/*  sw2		              sw2 - value                 */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   0                         o.k.                       */
/*                                                        */
/*   -1                        error                      */
/*                              sw1/sw2 from SCT response */
/*                                                        */
/* CALLED FUNCTIONS                                       */
/*   sta_aux_sct_resp                                     */
/*   sta_aux_elemlen                                      */
/*   sta_aux_bytestr_free                                 */
/*                                                        */
/*                                                        */
/*                                                        */
/*--------------------------------------------------------*/
int
SCTresponse(p_elem, command, response, sw1, sw2)
	struct s_portparam *p_elem;
	unsigned int    command;
	Bytestring     *response;
	unsigned int   *sw1;
	unsigned int   *sw2;
{
	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	BitString       sec_key;
	Bytestring      out_apdu;
	int             rc;

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


	/*------------------------------------*/
	/* test secure messaging for response */
	/*------------------------------------*/

	if (p_elem->secure_messaging.response != SEC_NORMAL) {
		if ((command != S_RESET) &&
		    (command != S_GET_TRANSPORT_KEY) &&
		    (command != S_GEN_SESSION_KEY)) {
			if (response->nbytes != 3) {
				/* Call SCTdec */
				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 = SCTdec(&sec_key, p_elem->ssc, response, &out_apdu, DES);
				sta_aux_bytestr_free(response);
				/*------------------------------------*/
				/* set ssc                            */
				/*------------------------------------*/
				p_elem->ssc++;
				if (rc < 0) {
					if (command == S_EJECT_SC)
						p_elem->sc_request = FALSE;
					return (-1);
				}
				response->nbytes = out_apdu.nbytes;
				response->bytes = out_apdu.bytes;
			}
		}
	}
	/*------------------------------------*/
	/* print response			 */
	/*------------------------------------*/

#ifdef STREAM
	sta_aux_sct_resp(sct_trfp, response->bytes, response->nbytes);
#endif

	/*------------------------------------*/
	/* eleminate Length-field in Response */
	/*------------------------------------*/
	sta_aux_elemlen(response);


	/*------------------------------------*/
	/* check SW1/SW2			 */
	/*------------------------------------*/
	*sw1 = *(response->bytes + (response->nbytes - 2)) & 0xFF;
	*sw2 = *(response->bytes + (response->nbytes - 1)) & 0xFF;

	/* delete sw1/sw2 in response-buffer */
	*(response->bytes + (response->nbytes - 2)) = 0x00;
	*(response->bytes + (response->nbytes - 1)) = 0x00;
	response->nbytes -= 2;


	/*------------------------------------*/
	/* if sw1 indicates an error, then	 */
	/* search in sct_error list sw1/sw2	 */
	/* and return index in sct_errno to	 */
	/* calling procedure 		 */
	/*------------------------------------*/
	if ((*sw1 != OKSC) && (*sw1 != OKSCT)) {
		sta_aux_bytestr_free(response);
		return (SCTerr(*sw1, *sw2));
	};

	return (S_NOERR);
}

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



/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  SCTenc               VERSION   2.0               */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                                        */
/* DESCRIPTION                                            */
/*  Encrypt SCT-COMMAND-APDU (without CLA-Byte)           */
/*  This Procedure can be called in case of               */
/*  secure messaging = CONCEALED .			  */
/*                                                        */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*   sec_key		       Secure Messaging key	  */
/*							  */
/*   in_apdu		       Pointer of SCT-APDU        */
/*                             The SC-APDU must have the  */
/*                             structur:                  */
/*			       __________________________ */
/*			      | CLA,INS,P1,P2,L,SSC,DATA |*/
/*			       __________________________ */
/*			      (= output of the procedure  */
/*				 SCTcreate)		  */
/*							  */
/*   algenc		       Encryption method          */
/*							  */
/* OUT                                                    */
/*   out_apdu                  Pointer of SEC-APDU        */
/*			       out_apdu->bytes will be    */
/*			       allocated by the called    */
/*			       program			  */
/*			       and must be set free by the*/
/*			       calling program            */
/*                             The SEC-APDU has the       */
/*                             structure:                 */
/*		           _____________________          */
/*			  | CLA,ENCRYPTED DATA  |         */
/*		           _____________________          */
/*							  */
/*

/*

*/
/* RETURN                    DESCRIPTION                  */
/*   0                         o.k                        */