stadev.c

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

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




/*-------------------------------------------------------------*/
/*						         | GMD */
/*						         +-----*/
/* PROC  check_sct_sc             VERSION   1.0	    	       */
/*				     DATE   Januar 1992	       */
/*			      	       BY   Levona Eckstein    */
/*							       */
/* DESCRIPTION						       */
/*  Check, if SCT initialized and SC inserted 	               */
/*							       */
/*							       */
/* IN			     DESCRIPTION		       */
/*   sct_id		       SCT identifier		       */
/*   sc_expect		       = TRUE => SC is expected        */
/*   			       = FALSE => SC is not expected   */
/*                                                             */
/* OUT							       */
/*							       */
/*							       */
/* RETURN		     DESCRIPTION	      	       */
/*   0	         	       o.k			       */
/*  -1			       error			       */
/*                               ENOCARD		       */
/*							       */
/* CALLED FUNCTIONS					       */
/*  sct_info                   ERROR-Codes		       */
/*			         ESIDUNK		       */
/*							       */
/*  sct_reset		       ERROR-Codes		       */
/*			 	 ENOSHELL		       */
/*                               EOPERR                        */
/*			         EEMPTY                        */
/*                               EMEMAVAIL                     */
/*                               ECLERR                        */
/*                               ESIDUNK                       */
/*                               ERDERR                        */
/*                               EINVARG		       */
/*                               ETOOLONG		       */
/*                               sw1/sw2 from SCT response     */
/*                               T1 - ERROR                    */
/*							       */
/*  err_analyse		      ERROR_Codes	               */
/*				ENOSHELL		       */
/*                              EOPERR                         */
/*			        EEMPTY                         */
/*                              ECLERR                         */
/*                              ESIDUNK                        */
/*                              ERDERR                         */
/*							       */
/*							       */
/*  set_errmsg						       */
/*-------------------------------------------------------------*/
int
check_sct_sc(sct_id, sc_expect)
	int             sct_id;
	Boolean         sc_expect;
{
	/*----------------------------------------------------------*/
	/* Definitions					       */
	/*----------------------------------------------------------*/
	int             rc;

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

	/*-------------------------------------*/
	/* if first_call = TRUE               */
	/* then reset SCT                  */
	/*-------------------------------------*/
	if (first_call == TRUE) {
		rc = sct_reset(sct_id);
		if (rc < 0) {
			sca_errno = sct_errno;
			sca_errmsg = sct_errmsg;
			err_analyse(sct_id);
			return (-1);
		}
		first_call = FALSE;
	}
	/*-------------------------------------*/
	/* call sct_info                      */
	/*-------------------------------------*/
	if (sct_info(sct_id, &sctinfo) == -1) {
		sca_errno = sct_errno;
		sca_errmsg = sct_errmsg;
		return (-1);
	}
	/*-------------------------------------*/
	/* test, if port open                 */
	/*-------------------------------------*/
	if (sctinfo.port_open == FALSE) {
		/* port not open => call sct_reset */
		if (sct_reset(sct_id) == -1) {
			sca_errno = sct_errno;
			sca_errmsg = sct_errmsg;
			err_analyse(sct_id);
			return (-1);
		}
		if (sc_expect == TRUE) {
			sca_errno = ENOCARD;
			set_errmsg();
			return (-1);
		}
	}
	/*-------------------------------------*/
	/* function only allowed, if smartcard */
	/* already requested.                 */
	/* Therefore test, if smartcard is    */
	/* inserted				  */
	/*-------------------------------------*/
	if ((sc_expect == TRUE) && (sctinfo.sc_request == FALSE)) {
		/* error => smartcard not requested */
		sca_errno = ENOCARD;
		set_errmsg();
		return (-1);
	}
	/*-------------------------------------*/
	/* normal end                          */
	/*-------------------------------------*/
	return (0);
}

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





/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  get_sct_keyid       VERSION   1.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                     U.Viebeg,GMD       */
/*                                                        */
/* DESCRIPTION                                            */
/*  Check key_id of SCA-IF and                            */
/*  transform key_id of SCA-IF to one character, which is */
/*  used at the SCT-IF.				          */
/*                                                        */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*   kid                       kid structure              */
/*                                                        */
/*                                                        */
/* OUT                                                    */
/*                                                        */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   char                      SCT specific key-id        */
/*                                                        */
/*   -1                        error                      */
/*                               EINVKID                  */
/*--------------------------------------------------------*/
char
get_sct_keyid(kid)
	KeyId          *kid;
{
	/*----------------------------------------------------------*/
	/* Definitions                                            */
	/*----------------------------------------------------------*/
	char            kidvalue;

	/*----------------------------------------------------------*/
	/* Statements                                             */
	/*----------------------------------------------------------*/
	if ((kid->key_number <= 0) || (kid->key_number > 63) ||
	    ((kid->key_level != SC_MF) &&
	     (kid->key_level != SC_DF) &&
	     (kid->key_level != SC_SF) &&
	     (kid->key_level != SCT))) {
		sca_errno = EINVKID;
		set_errmsg();
		return (-1);
	}
	kidvalue = (((char) kid->key_number & 0xFF) << 2) |
		((char) kid->key_level & 0xff);

#ifdef TEST
	fprintf(stdout, "key_id_char: ");
	aux_fxdump(stdout, &kidvalue, 1, 0);
	fprintf(stdout, "\n");
#endif

	return (kidvalue);

}

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




/*--------------------------------------------------------*/
/*                                                  | GMD */
/*                                                  +-----*/
/* PROC  get_sct_algid       VERSION   1.0                */
/*                              DATE   November 1991      */
/*                                BY   L.Eckstein,GMD     */
/*                                     U.Viebeg,GMD       */
/*							                           */
/*	Achtung: AlgId = DES-3 is still missing		                           */
/*							                           */
/*                                                        */
/* DESCRIPTION                                            */
/*  Check alg_id of SCA-IF and                            */
/*  transform  alg_id of SCA-IF to SCT specific alg_id,   */
/*  which is used at the SCT-IF.		          */
/*  In case of RSA keysize is checked: allowed values are */
/*  256, 512 bits.               	                  */
/*                                                        */
/*  alg_id	is transformed to 	sct_algid:        */
/*  ------                              ----------        */
/*  rsa			->		S_RSA_F4          */
/*  sqmodnWithRsa	->		S_RSA_F4          */
/*  md2WithRsa		->		S_RSA_F4          */
/*  md4WithRsa		->		S_RSA_F4          */
/*  md5WithRsa		->		S_RSA_F4          */
/*  desCBC		->		S_DES_CBC         */
/*  missing		->		S_DES_3_CBC       */
/*                                                        */
/* IN                        DESCRIPTION                  */
/*   algid                     algid structure            */
/*                                                        */
/*                                                        */
/* OUT                                                    */
/*                                                        */
/*                                                        */
/* RETURN                    DESCRIPTION                  */
/*   char                      Value of Byte              */
/*                                                        */
/*   -1                        error                      */
/*                               EINVALGID                */
/*                               EKEYLENINV               */
/*                                                        */
/*                                                        */
/*  CALLED FUNCTIONS                                      */
/*    aux_cmp_ObjId              ERROR-Codes                */
/*    		                 -1 => EINVALGID          */
/*--------------------------------------------------------*/
char
get_sct_algid(algid)
	AlgId          *algid;
{
	/*----------------------------------------------------------*/
	/* Definitions                                              */
	/*----------------------------------------------------------*/
	KeyAlgId        sct_algid;
	int             rc;

	/*----------------------------------------------------------*/
	/* Statements                                               */
	/*----------------------------------------------------------*/
	sct_algid = -1;


	/*-----------------------------------------------------*/
	/* aux_cmp_ObjId returns 0 if objids are equal         */
	/* aux_cmp_ObjId returns 1 if objids are not equal     */
	/*-----------------------------------------------------*/
	if ((!algid) || (!algid->objid)) {
		sca_errno = EINVALGID;
		set_errmsg();
		return (-1);
	}
/* 17.11.92 WS
	if (((rc = aux_cmp_ObjId(algid->objid, rsa->objid)) == 0) ||
	  ((rc = aux_cmp_ObjId(algid->objid, sqmodnWithRsa->objid)) == 0) ||
	    ((rc = aux_cmp_ObjId(algid->objid, md2WithRsa->objid)) == 0) ||
	    ((rc = aux_cmp_ObjId(algid->objid, md4WithRsa->objid)) == 0) ||
	    ((rc = aux_cmp_ObjId(algid->objid, md5WithRsa->objid)) == 0)) {
*/
	if(aux_ObjId2AlgEnc(algid->objid) == RSA) {
		/* if RSA, then check keysize */
		if (algid->parm) {
			if ((RSA_PARM(algid->parm) != 256) &&
			    (RSA_PARM(algid->parm) != 512)) {
				sca_errno = EKEYLENINV;
				set_errmsg();
				return (-1);
			}
		}
		sct_algid = S_RSA_F4;
	} else if ((rc = aux_cmp_ObjId(algid->objid, desCBC->objid)) == 0) {
		sct_algid = S_DES_CBC;
	} else {
		if ((rc = aux_cmp_ObjId(algid->objid, desCBC3->objid)) == 0) {
			sct_algid = S_DES_3_CBC;
		} else {
			sca_errno = EINVALGID;
			set_errmsg();
			return (-1);
		}
	};


#ifdef TEST
	fprintf(stdout, "SCT algid: %d\n ", sct_algid);
#endif

	return (sct_algid);


}

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






/*-------------------------------------------------------------*/
/*						         | GMD */
/*						         +-----*/
/*   check_key_attr_list      VERSION   1.0	    	       */
/*				     DATE   Januar 1992	       */
/*			      	       BY   Ursula Viebeg      */
/*							       */
/* DESCRIPTION						       */
/*  Check key attribute list for user keys, device keys, PIN   */
/*  and PUK. 						       */
/*  In case of a user key,PIN or PUK the value of key_purpose  */
/*  is set by  this function.				       */
/*  The MAC_length is automatically set to 4.                  */
/*  If the key is not an authentication key, key_fpc will be   */
/*  set to 0 by this function.				       */
/*  In case of PIN or PUK, key_status.PIN_check is checked,    */
/*  otherwise key_status.PIN_check is set to FALSE.            */
/*							       */
/*							       */
/* IN			     DESCRIPTION		       */
/*   kind_of_key	       {USER_KEY, PIN_KEY, PUK_KEY     */
/*                              DEVICE_KEY}                    */
/*                                                             */
/*   key_attr_list	       pointer to the list of the key  */
/*                             attributes                      */
/*							       */
/*							       */
/* OUT							       */
/*							       */
/*							       */