param.c

来自「这个linux源代码是很全面的~基本完整了~使用c编译的~由于时间问题我没有亲自」· C语言 代码 · 共 506 行 · 第 1/2 页

/*
 *  Broadcom Cryptonet Driver software is distributed as is, without any warranty
 *  of any kind, either express or implied as further specified in the GNU Public
 *  License. This software may be used and distributed according to the terms of
 *  the GNU Public License.
 *
 * Cryptonet is a registered trademark of Broadcom Corporation.
 */
/******************************************************************************
 *
 *  Copyright 2000
 *  Broadcom Corporation
 *  16215 Alton Parkway
 *  PO Box 57013
 *  Irvine CA 92619-7013
 *
 *****************************************************************************/
/* 
 * Broadcom Corporation uBSec SDK 
 */
/*
 * param.c: IO parameter manipulation routines
 */
/*
 * Revision History:
 *
 * May 2000 SOR/JTT Created.
 * March 2001 PW Release for Linux 2.4 UP and SMP kernel
 */

#include "cdevincl.h"



extern unsigned long Page_Size;

int
KeyCommandCopyin(unsigned long Command, 
		 ubsec_KeyCommandParams_pt pSRLParams, 
		 ubsec_KeyCommandParams_pt pIOparams,
		 unsigned char *KeyLoc,
		 ubsec_FragmentInfo_pt pDSAMessageFragList)
{

  /*
   * Now we need to format the command for the SRL.
   * This depends on the type of the key command.
   */
  switch (Command) {
  case UBSEC_DH_PUBLIC    :
  case UBSEC_DH_SHARED  :
    if(ubsec_keysetup_Diffie_Hellman(Command, pSRLParams,
					     pIOparams, KeyLoc) != 0)
	return -EINVAL;
    break;

  case UBSEC_RSA_PUBLIC  :
  case UBSEC_RSA_PRIVATE  : 
   if( ubsec_keysetup_RSA(Command, pSRLParams,
				  pIOparams, KeyLoc) != 0)
	return -EINVAL;
    break;

  case UBSEC_DSA_VERIFY: 
  case UBSEC_DSA_SIGN: 
    if (ubsec_keysetup_DSA(Command, pSRLParams,
			   pIOparams, KeyLoc, 
			   pDSAMessageFragList) != 0) {
      return UBSEC_STATUS_NO_RESOURCE;
    }
    break;

  default:
    PRINTK("Invalid Key Command %lx\n",Command);
    return -EINVAL;
  }

return 0 ;
}

/*
 * 
 */
int
KeyCommandCopyout(unsigned long Command, 
		 ubsec_KeyCommandParams_pt pSRLParams, 
		 ubsec_KeyCommandParams_pt pIOparams,
		 unsigned char *KeyLoc)
{
  ubsec_DH_Params_pt pDHSRLparams=NULL,pDHIOparams = NULL;
  ubsec_RSA_Params_pt pRSASRLparams=NULL, pRSAIOparams=NULL;
  ubsec_DSA_Params_pt pDSASRLparams=NULL, pDSAIOparams=NULL;


  /* 
   * Now we need to copyout those parameters that were changed
   */
  switch (Command) {
  case UBSEC_DH_SHARED:
    pDHSRLparams=&pSRLParams->DHParams;
    pDHIOparams=&pIOparams->DHParams;
    pDHIOparams->K.KeyLength = pDHSRLparams->K.KeyLength; 
    copy_to_user(pDHIOparams->K.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*DH_K_OFFSET],
		 ROUNDUP_TO_32_BIT(pDHIOparams->K.KeyLength)/8);
    break;

  case UBSEC_DH_PUBLIC:
    pDHSRLparams=&pSRLParams->DHParams;
    pDHIOparams=&pIOparams->DHParams;
    pDHIOparams->Y.KeyLength = pDHSRLparams->Y.KeyLength;
    copy_to_user(pDHIOparams->Y.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*DH_Y_OFFSET],
		 ROUNDUP_TO_32_BIT(pDHIOparams->Y.KeyLength)/8);

    pDHIOparams->X.KeyLength = pDHSRLparams->X.KeyLength;
    copy_to_user(pDHIOparams->X.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*DH_X_OFFSET],
		 ROUNDUP_TO_32_BIT(pDHIOparams->X.KeyLength)/8);
    break;
  case UBSEC_RSA_PUBLIC  :
  case UBSEC_RSA_PRIVATE  : 
    pRSASRLparams=&pSRLParams->RSAParams;
    pRSAIOparams=&pIOparams->RSAParams;
    pRSAIOparams->OutputKeyInfo.KeyLength =
      pRSASRLparams->OutputKeyInfo.KeyLength;
    copy_to_user(pRSAIOparams->OutputKeyInfo.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*RSA_OUT_OFFSET],
		 ROUNDUP_TO_32_BIT(pRSAIOparams->OutputKeyInfo.KeyLength)/8);
    break;

  case UBSEC_DSA_SIGN     : 
    pDSASRLparams=&pSRLParams->DSAParams;
    pDSAIOparams=&pIOparams->DSAParams;
    pDSAIOparams->SigS.KeyLength = pDSASRLparams->SigS.KeyLength;
    pDSAIOparams->SigR.KeyLength = pDSASRLparams->SigR.KeyLength;
    copy_to_user(pDSAIOparams->SigS.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*DSA_S_OFFSET],
		 ROUNDUP_TO_32_BIT(pDSAIOparams->SigS.KeyLength)/8);
    copy_to_user(pDSAIOparams->SigR.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*DSA_R_OFFSET],
		 ROUNDUP_TO_32_BIT(pDSAIOparams->SigR.KeyLength)/8);
    break;

  case UBSEC_DSA_VERIFY   : 
    pDSAIOparams=&pIOparams->DSAParams;
    pDSASRLparams=&pSRLParams->DSAParams;
    pDSAIOparams->V.KeyLength = pDSASRLparams->V.KeyLength;
    copy_to_user(pDSAIOparams->V.KeyValue,
		 &KeyLoc[MAX_KEY_BYTE_SIZE*DSA_V_OFFSET],
		 ROUNDUP_TO_32_BIT(pDSAIOparams->V.KeyLength)/8);
    break;
  }
return 0 ;
}


/*
 * Diffie Hellman key setup function. Builds KeyCommandInfo for call to SRL.
 */
int
ubsec_keysetup_Diffie_Hellman(unsigned long command, 
			      ubsec_KeyCommandParams_pt pSRLparams, 
			      ubsec_KeyCommandParams_pt pIOparams,
			      unsigned char *KeyLoc)
{
  ubsec_DH_Params_pt 	pDHSRLparams = &pSRLparams->DHParams;
  ubsec_DH_Params_pt 	pDHIOparams = &pIOparams->DHParams;

  /* 
   * Setup key parameter locations and align them. Start with modulus N.
   */

  /* Validation */
 CHECK_SIZE(pDHIOparams->N.KeyLength,MAX_KEY_LENGTH_BITS);
 CHECK_SIZE(pDHIOparams->Y.KeyLength,MAX_KEY_LENGTH_BITS);
  copy_from_user( &KeyLoc[MAX_KEY_BYTE_SIZE*DH_N_OFFSET],pDHIOparams->N.KeyValue,
	 ROUNDUP_TO_32_BIT(pDHIOparams->N.KeyLength)/8);
  pDHSRLparams->N.KeyValue=(void *)&KeyLoc[MAX_KEY_BYTE_SIZE*DH_N_OFFSET];
  pDHSRLparams->N.KeyLength = pDHIOparams->N.KeyLength;

  /* 
   * Now copy in the specific parameters.
   */
  if ((command & UBSEC_DH_SHARED)==UBSEC_DH_SHARED) {
    /*
     * Computing K=Y**x|N
     */
    /* Validation of the Length */
    CHECK_SIZE(pDHIOparams->K.KeyLength,MAX_KEY_LENGTH_BITS);
    CHECK_SIZE(pDHIOparams->X.KeyLength,MAX_KEY_LENGTH_BITS);
    copy_from_user(&KeyLoc[MAX_KEY_BYTE_SIZE*DH_Y_OFFSET],pDHIOparams->Y.KeyValue,
	   ROUNDUP_TO_32_BIT(pDHIOparams->Y.KeyLength)/8);

    /*
     * Copy in our secret value x. 
     */
    copy_from_user(&KeyLoc[MAX_KEY_BYTE_SIZE*DH_X_OFFSET],pDHIOparams->X.KeyValue,
	   ROUNDUP_TO_32_BIT(pDHIOparams->X.KeyLength)/8);
    pDHSRLparams->X.KeyLength = pDHIOparams->X.KeyLength;
	/*
	 * Output parameter is the shared key. Must represent integral
	 * number of 32 bit words.
	 */
    pDHSRLparams->K.KeyValue=(void *) 
      (&KeyLoc[MAX_KEY_BYTE_SIZE*DH_K_OFFSET]);
    pDHSRLparams->K.KeyLength = pDHIOparams->K.KeyLength;
  } 
  else {
    /*
     * Computing Y=g**x|N
     */
    /* Validation of the Length */
    CHECK_SIZE(pDHIOparams->G.KeyLength,MAX_KEY_LENGTH_BITS);

    copy_from_user( &KeyLoc[MAX_KEY_BYTE_SIZE*DH_G_OFFSET],pDHIOparams->G.KeyValue,
	   ROUNDUP_TO_32_BIT(pDHIOparams->G.KeyLength)/8);
    pDHSRLparams->G.KeyValue=(void *)(&KeyLoc[MAX_KEY_BYTE_SIZE*DH_G_OFFSET]);
    pDHSRLparams->G.KeyLength = pDHIOparams->G.KeyLength;
    pDHSRLparams->RNGEnable=pDHIOparams->RNGEnable;

    /*
     * X and Y are input/output fragment data and must be physical addresses.
     */
    pDHSRLparams->X.KeyValue=(void *)(&KeyLoc[MAX_KEY_BYTE_SIZE*DH_X_OFFSET]);
 
    if (!pDHSRLparams->RNGEnable) {

      CHECK_SIZE(pDHIOparams->UserX.KeyLength,MAX_KEY_LENGTH_BITS);

      copy_from_user(&KeyLoc[MAX_KEY_BYTE_SIZE*DH_USERX_OFFSET],pDHIOparams->UserX.KeyValue,
	     ROUNDUP_TO_32_BIT(pDHIOparams->UserX.KeyLength)/8);
      pDHSRLparams->UserX.KeyValue=(void *)
	(&KeyLoc[MAX_KEY_BYTE_SIZE*DH_USERX_OFFSET]);
      pDHSRLparams->UserX.KeyLength = pDHIOparams->UserX.KeyLength;
	/*
	 * Set length for return. X will be copied from supplied UserX.
	 */
      pDHIOparams->X.KeyLength = pDHIOparams->UserX.KeyLength;

	/*
	 * User supplied secret value will be copied to the output X.
	 * Output needs to be an integral number of 32-bit words.
	 */
      pDHSRLparams->X.KeyLength=pDHIOparams->UserX.KeyLength;
    }
    else {
      /*
       * Set length for return. X will be the random number
       * generated by the chip. Output needs to be integral 
       * number of 32-bit words.
       */