stasc.c

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

/*                               ETOOLONG		       */
/*                               EMEMAVAIL		       */
/*                               ESIDUNK                       */
/*                               EPARMISSED                    */
/*			         EPARINC		       */
/*                               INVPAR                        */
/*                               EINVINS                       */
/*                               sw1/sw2 from SCT response     */
/*                               T1 - ERROR                    */
/*                               sw1/sw2 from SC  response     */
/*							       */
/*-------------------------------------------------------------*/
int
sca_delete_file(sct_id, file_cat, file_sel, sec_mess)
	int             sct_id;
	FileCat         file_cat;
	FileSel        *file_sel;
	SecMess        *sec_mess;
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/

#ifdef TEST
	fprintf(stdout, "\n***** STAMOD-Routine sca_delete_file *****\n\n");
	fprintf(stdout, "TRACE of the input parameters : \n");
	fprintf(stdout, "sct_id                  : %d\n", sct_id);
	print_filecat(file_cat);
	print_filesel(file_cat, file_sel);
	print_secmess(sec_mess);
#endif

	/*-------------------------------------*/
	/* call check_sct_sc                  */
	/*-------------------------------------*/
	if (check_sct_sc(sct_id, TRUE))
		return (-1);


	/*-------------------------------------*/
	/* create SC command LOCKF            */
	/*-------------------------------------*/
	/* create header                       */
	if (cr_header(SC_DELF, sec_mess))
		return (-1);


	/* set parameters			  */
	SCDELFILE.filecat = file_cat;
	SCDELFILE.file_sel = file_sel;


	/* call create_trans			  */
	if (create_trans(sct_id, TRUE))
		return (-1);

	/*----------------------------------------------*/
	/* normal end => release response storage       */
	/*----------------------------------------------*/
	sta_aux_bytestr_free(&response);

#ifdef TEST
	fprintf(stdout, "\n***** Normal end of   sca_delete_file *****\n\n");
#endif

	return (0);





}

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



/*-------------------------------------------------------------*/
/*						         | GMD */
/*						         +-----*/
/* PROC  create_trans             VERSION   1.0	    	       */
/*				     DATE   Januar 1992	       */
/*			      	       BY   Levona Eckstein    */
/*							       */
/* DESCRIPTION						       */
/*  Create SC command and send it via S_TRANS 	               */
/*							       */
/*							       */
/* IN			     DESCRIPTION		       */
/*   sct_id		       SCT identifier		       */
/*                                                             */
/*   flag                      if flag = TRUE =>               */
/*    				       - create sc_command     */
/*                                     - check sc_response     */
/*                             if flag = FALSE =>              */
/*                                   only in case of sca_trans */
/*				     don't check sc_response   */
/* OUT							       */
/*   common variable response				       */
/*							       */
/* RETURN		     DESCRIPTION	      	       */
/*   0	         	       o.k			       */
/*  -1			       error			       */
/*							       */
/* CALLED FUNCTIONS					       */
/*  sct_interface	       ERROR-Codes	               */
/*                               EINVARG		       */
/*                               ETOOLONG		       */
/*                               EMEMAVAIL		       */
/*                               EPARMISSED                    */
/*                               INVPAR                        */
/*                               EINVINS                       */
/*                               sw1/sw2 from SCT response     */
/*                               T1 - ERROR                    */
/*							       */
/*  sc_create                  ERROR_Codes		       */
/*                               EPARINC                       */
/*			         EMEMAVAIL                     */
/*                               ETOOLONG		       */
/*    							       */
/*  sc_check		       ERROR-Codes		       */
/*                               sw1/sw2 from SC  response     */
/*							       */
/*  err_analyse		      ERROR_Codes	               */
/*				ENOSHELL		       */
/*                              EOPERR                         */
/*			        EEMPTY                         */
/*                              ECLERR                         */
/*                              ESIDUNK                        */
/*                              ERDERR                         */
/*							       */
/*-------------------------------------------------------------*/
int
create_trans(sct_id, flag)
	int             sct_id;
	Boolean         flag;
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	Boolean         sec_mode;
	int             ssc;

	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/
	sec_mode = FALSE;

	if (flag == TRUE) {

		/*
		 * call sc_create ; in case of no error sc_apdu.bytes must be
		 * set free
		 */
		if (sc_create(&sc_param, sec_mode, ssc, &sc_apdu) == -1) {
			/* error  => release sc_apdu and return */
			sca_errno = sc_errno;
			sca_errmsg = sc_errmsg;
			return (-1);
		}
		/*--------------------------------------------*/
		/* prepare parameters for the S_TRANS-command */
		/*--------------------------------------------*/
		command = S_TRANS;
		request.rq_p1.secmode = SECURE;

		request.rq_datafield.sccommand = &sc_apdu;
	}
	/*-------------------------------------*/
	/* send SC command via S_TRANS         */
	/*-------------------------------------*/

	/* call sct_interface		  */
	if (sct_interface(sct_id, command, &request, &response) == -1) {
		sca_errno = sct_errno;
		sca_errmsg = sct_errmsg;
		if (flag == TRUE)
			sta_aux_bytestr_free(&sc_apdu);
		/* error => call err_analyse  */
		err_analyse(sct_id);
		return (-1);
	}
	/*-----------------------------------------------------*/
	/* normal end => release storage of sc_apdu.bytes      */
	/*-----------------------------------------------------*/
	sta_aux_bytestr_free(&sc_apdu);


	if (flag == TRUE) {
		/*-------------------------------------*/
		/* check SC response                   */
		/*-------------------------------------*/
		if (sc_check(&response) == -1) {
			sca_errno = sc_errno;
			sca_errmsg = sc_errmsg;
			if ((sca_errno == EDATAINC_CLPEN) && (SCCMD == SC_READF) &&
			    (response.nbytes != 0)) {
				/* data inconsistency, but data received */
				return (-1);
			}
			/* error => release buffer and return */
			sta_aux_bytestr_free(&response);
			return (-1);
		}
	}
	return (0);
}

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


/*-------------------------------------------------------------*/
/*						         | GMD */
/*						         +-----*/
/* PROC  cr_header                VERSION   1.0	    	       */
/*				     DATE   Januar 1992	       */
/*			      	       BY   Levona Eckstein    */
/*							       */
/* DESCRIPTION						       */
/*  Create Header of SC command         	               */
/*							       */
/*							       */
/* IN			     DESCRIPTION		       */
/*   ins		       Instruction code		       */
/*                                                             */
/*   sec_mess                  security modes                  */
/*							       */
/* OUT							       */
/*							       */
/*							       */
/* RETURN		     DESCRIPTION	      	       */
/*   0	         	       o.k			       */
/*  -1			       error			       */
/*							       */
/* CALLED FUNCTIONS					       */
/*  check_sec_mess	       ERROR-Codes	               */
/*                               M_ESECMESS		       */
/*-------------------------------------------------------------*/
int
cr_header(ins, sec_mess)
	int             ins;
	SecMess        *sec_mess;
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/

	/*-------------------------------------*/
	/* check sec_mess                      */
	/*-------------------------------------*/
	if (check_sec_mess(sec_mess))
		return (-1);


	/* set instruction code		  */
	SCCMD = ins;

	/* set security modes		  */
	SCHEAD.security_mess.command = sec_mess->command;
	SCHEAD.security_mess.response = sec_mess->response;

	/* set command set			  */
	SCHEAD.cmd_class = SC_NON_INTER;	/* non interindustry command
						 * set */


	return (0);

}

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



/*-------------------------------------------------------------*/
/*						         | GMD */
/*						         +-----*/
/* PROC  get_bits                 VERSION   1.0	    	       */
/*				     DATE   Januar 1992	       */
/*			      	       BY   Levona Eckstein    */
/*							       */
/* DESCRIPTION						       */
/*  Get n bits from position p.         	               */
/*							       */
/*							       */
/* IN			     DESCRIPTION		       */
/*   x  		       1 byte   		       */
/*                                                             */
/*   n                         number of bits                  */
/*							       */
/*   p                         position                        */
/* OUT							       */
/*							       */
/*							       */
/* RETURN		     DESCRIPTION	      	       */
 /* n-bit field of x that begins at position p                *//*-------------------------------------------------------------*/
unsigned int
get_bits(x, n, p)
	unsigned int    x;
	unsigned int    n;
	unsigned int    p;

{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/
	return ((x >> (p + 1 - n)) & ~(~0 << n));
}

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




/*-------------------------------------------------------------*/
/* E N D   O F	 P A C K A G E	     STAMOD-stasc 	       */
/*-------------------------------------------------------------*/