sctint.c

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

	keysize = RSA_PARM(subjectAI->parm);
	memolen = in.noctets + ((keysize + 7) / 8);

#ifdef STREAM
	fprintf(sct_trfp, "keysize                 : %d\n", keysize);
	fprintf(sct_trfp, "memolen                 : %d\n", memolen);
#endif

	out.nbits = 0;

#ifdef MALLOC
	out.bits = malloc(memolen);	/* will be set free in this proc. */
#endif

	if (out.bits == NULL) {
		sct_errno = EMEMAVAIL;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_OctetString(&key_bits.part1);
		if (old_key == FALSE)
			aux_free_BitString(&sessionkey);
		free(des_key);
		return (-1);
	}
	rc = rsa_encrypt(&in, &out, more, keysize);
	free(des_key);
	if (rc < 0) {
		sct_errno = ERSAENC;
		sct_errmsg = sct_error[sct_errno].msg;
		aux_free2_OctetString(&key_bits.part1);
		aux_free2_BitString(&out);
		if (old_key == FALSE)
			aux_free_BitString(&sessionkey);
		return (-1);
	}
#ifdef STREAM
	fprintf(sct_trfp, "encrypted sessionkey    : \n");
	fprintf(sct_trfp, "    nbits/8             : %d\n", out.nbits / 8);
	fprintf(sct_trfp, "    bits                : \n");
	aux_fxdump(sct_trfp, out.bits, out.nbits / 8, 0);
#endif

	/*--------------------------------------*/
	/* Release storage   		        */
	/*--------------------------------------*/
	aux_free2_OctetString(&key_bits.part1);



	/*--------------------------------------*/
	/* Prepare parameters for the           */
	/* SCT Interface Cmd S_GEN_SESSION_KEY  */
	/*--------------------------------------*/
	request.rq_p1.kid = 0x00;
	request.rq_p2.algid = S_DES_CBC;
	sess_key_par.sec_mode = CONCEALED;
	sess_key_par.com_line = DTE_SCT;
	enc_sess_key.nbytes = out.nbits / 8;
	enc_sess_key.bytes = out.bits;
	sess_key_par.session_key = &enc_sess_key;
	request.rq_datafield.session_key = &sess_key_par;

	/*--------------------------------------*/
	/* Call SCT Interface 			 */
	/*--------------------------------------*/
	rc = sct_interface(sct_id, S_GEN_SESSION_KEY, &request, &response);
	if (rc < 0) {
		aux_free2_BitString(&out);
		if (old_key == FALSE)
			aux_free_BitString(&sessionkey);
		return (-1);
	}
	ssc = (*response.bytes) & 0xFF;

#ifdef STREAM
	fprintf(sct_trfp, "ssc                     : %x\n", ssc);
#endif

	/*--------------------------------------*/
	/* Release storage   		        */
	/*--------------------------------------*/
	sta_aux_bytestr_free(&response);
	aux_free2_BitString(&out);


	/*----------------------------------------------*/
	/* Store sessionkey and ssc in port-memory 	 */
	/*----------------------------------------------*/
	if (old_key == FALSE) {

#ifdef MALLOC
		/* allocate buffer for sessionkey;    */
		p_elem->session_key.subjectkey.bits = malloc(sessionkey->nbits / 8);
#endif

		if (p_elem->session_key.subjectkey.bits == NULL) {
			sct_errno = EMEMAVAIL;
			sct_errmsg = sct_error[sct_errno].msg;
			aux_free_BitString(&sessionkey);
			return (-1);
		}
		for (i = 0; i < sessionkey->nbits / 8; i++)
			*(p_elem->session_key.subjectkey.bits + i) = *(sessionkey->bits + i);
		p_elem->session_key.subjectAI = desCBC;
		p_elem->session_key.subjectkey.nbits = sessionkey->nbits;

		aux_free_BitString(&sessionkey);

	}
	p_elem->ssc = ssc + 1;

#ifdef MEMTRACE
	pr_element(sct_trfp, p_elem);
	fprintf(sct_trfp, "End of sct_secure\n");
#endif

	return (S_NOERR);

}

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



/*--------------------------------------------------------*/
/*						    | GMD */
/*						    +-----*/
/* PROC  sct_setmode	     VERSION   2.0		  */
/*				DATE   November 1991	  */
/*				  BY   L.Eckstein,GMD	  */
/*							  */
/* DESCRIPTION						  */
/*   Set security mode for DTE-SCT in port memory 	  */
/*							  */
/*							  */
/*							  */
/*							  */
/*							  */
/* IN			     DESCRIPTION		  */
/*   sct_id		      SCT-Identifier		  */
/*							  */
/*   sec_mess                 security mode               */
/*							  */
/* OUT							  */
/*							  */
/* RETURN		     DESCRIPTION		  */
/*  0			      o.k			  */
/*							  */
/*  -1			      no element found in LIST	  */
/*                             ESIDUNK                    */
/*							  */
/*							  */
/* CALLED FUNCTIONS					  */
/*  get_idelem						  */
/*--------------------------------------------------------*/
int
sct_setmode(sct_id, sec_mess)
	int             sct_id;	/* SCT - Identifier */
	SecMess        *sec_mess;
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	struct s_portparam *p_elem;

	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/
	sct_errno = 0;

	if (!resfirst) {	/* sct-list not created  */
		return (S_NOERR);
	};

	/*------------------------------------*/
	/* test sct_id  in sct_list		 */
	/*------------------------------------*/
	if ((p_elem = get_idelem(sct_id)) == PORTNULL)
		return (S_ERR);	/* ERROR: sct_id not in sct-list */

#ifdef MEMTRACE
	fprintf(sct_trfp, "Element after get_idelem in sct_setmode\n");
	pr_element(sct_trfp, p_elem);
#endif

	p_elem->secure_messaging.command = sec_mess->command;
	p_elem->secure_messaging.response = sec_mess->response;
	p_elem->setmode = 1;

#ifdef MEMTRACE
	pr_element(sct_trfp, p_elem);
	fprintf(sct_trfp, "END of sct_setmode\n");
#endif

	return (S_NOERR);

}

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




/*--------------------------------------------------------*/
/*						    | GMD */
/*						    +-----*/
/* PROC  sct_list	     VERSION   2.0		  */
/*				DATE   November 1991	  */
/*				  BY   L.Eckstein,GMD	  */
/*							  */
/* DESCRIPTION						  */
/*   Information about installed sct's                    */
/*							  */
/*							  */
/*							  */
/*							  */
/* IN			     DESCRIPTION		  */
/*							  */
/*							  */
/* OUT							  */
/*							  */
/* RETURN		     DESCRIPTION		  */
/*  entryno		      Number of entries 	  */
/*  -1			      error			  */
/*				ENOSHELL		  */
/*                              EOPERR                    */
/*			        EEMPTY                    */
/*                              EMEMAVAIL                 */
/*                              ECLERR                    */
/*							  */
/* CALLED FUNCTIONS					  */
/*  cr_sctlist						  */
/*--------------------------------------------------------*/
int
sct_list()
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	struct s_portparam *dp_tail;
	int             lindex = 0;

	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/
	sct_errno = 0;
	/*------------------------------------*/
	/* Create sct_list			 */
	/*------------------------------------*/
	if (!resfirst) {	/* create sct-list */
		if (cr_sctlist() == -1)
			return (S_ERR);
		resfirst = TRUE;
	};
	dp_tail = p_lhead;

	while (dp_tail != PORTNULL) {
		dp_tail = dp_tail->p_next;
		lindex++;
	}


	return (lindex);

}

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


/*--------------------------------------------------------*/
/*						    | GMD */
/*						    +-----*/
/* PROC  sct_close	     VERSION   2.0		  */
/*				DATE   November 1991	  */
/*				  BY   L.Eckstein,GMD	  */
/*							  */
/* DESCRIPTION						  */
/*   Close port of SCT          			  */
/*							  */
/*							  */
/*							  */
/*							  */
/*							  */
/* IN			     DESCRIPTION		  */
/*   sct_id		      SCT-Identifier		  */
/*							  */
/*							  */
/* OUT							  */
/*							  */
/*							  */
/* RETURN		     DESCRIPTION		  */
/*  0			      o.k			  */
/*							  */
/*  -1			      error             	  */
/*				ENOSHELL		  */
/*                              EOPERR                    */
/*			        EEMPTY                    */
/*                              ECLERR                    */
/*                              ESIDUNK                   */
/*                              ERDERR                    */
/*							  */
/*							  */
/* CALLED FUNCTIONS					  */
/*  get_idelem						  */
/*  get_orgelem						  */
/*  COMclose
/*--------------------------------------------------------*/
int
sct_close(sct_id)
	int             sct_id;	/* SCT - Identifier */
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	struct s_portparam *p_elem;



	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/
	/*------------------------------------------*/
	/* test, if sct_id refers to a sct element  */
	/*------------------------------------------*/
	if ((p_elem = get_idelem(sct_id)) == PORTNULL)
		return (S_ERR);	/* ERROR: sct not in sct-list */

#ifdef MEMTRACE
	fprintf(sct_trfp, "Element after get_idelem in sct_close\n");
	pr_element(sct_trfp, p_elem);
#endif

	/*------------------------------------*/
	/* call COMclose - procedure		 */
	/*------------------------------------*/
	if (p_elem->port_id > 0)
		COMclose(p_elem->port_id);





	/*------------------------------------*/
	/* get original element out of	 */
	/* installation file			 */
	/*------------------------------------*/

#ifdef TRACE
	fprintf(sct_trfp, "CALL get_orgelem in sct_close \n");
#endif

	if (get_orgelem(sct_id, p_elem) == -1)
		return (S_ERR);

#ifdef MEMTRACE
	pr_element(sct_trfp, p_elem);
	fprintf(sct_trfp, "END of sct_close\n");
#endif


	return (0);
}

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


/*--------------------------------------------------------*/
/*						    | GMD */
/*						    +-----*/
/* PROC  sct_get_errmsg	     VERSION   2.0		  */
/*				DATE   November 1991	  */
/*				  BY   L.Eckstein,GMD	  */
/*							  */
/* DESCRIPTION						  */
/*   Get pointer of error message     			  */
/*							  */
/*							  */
/*							  */
/*							  */
/*							  */
/* IN			     DESCRIPTION		  */
/*   error_no		      Error number		  */
/*							  */
/*							  */
/* OUT							  */
/*							  */
/*							  */
/* RETURN		     DESCRIPTION		  */
/*--------------------------------------------------------*/
void
sct_get_errmsg(error_no)
	unsigned int    error_no;
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/


	/*----------------------------------------------------------*/
	/* Statements					       */
	/*----------------------------------------------------------*/
	sct_errno = error_no;
	sct_errmsg = sct_error[error_no].msg;
}

/*-------------------------------------------------------------*/
/* E N D   O F	 P R O C E D U R E	sct_get_errmsg	       */
/*-------------------------------------------------------------*/
/*-------------------------------------------------------------*/
/* E N D   O F	 P A C K A G E	     sctint		       */
/*-------------------------------------------------------------*/