decrypt.c

STM32F10xx的LCD驱动源码

     Peramater :none 
        Output :none
          Note :
***********************************************************************/
KeyID KeyGen(void)
{

  u32    csr,DecryptedCode;        // seed value = serial number       ,keybit,keybit2,bitin
  KeyID KeyIDx;
       //KeyNumber=number;
       //pih   =VenderNumberH;                           //high 32  bits  of decryypt key  //pil   =VenderNumberL; Decrypt_KeyL=0;  Decrypt_KeyH=0;
       /**** MS4_bit of the Recived_Data.Serial_Number must never be lager  than
       0 since it is a 28_bit code.*****/
      KeyIDx.SeriaNumber=Recived_Data.Serial_Number;
      DecryptedCode=Recived_Data.Hopping_Code;
      Recived_Data.Hopping_Code    =0;  
      Recived_Data.Serial_Number   =0;
      Recived_Data.ButtonAStatus   =0;
      
      csr  = KeyIDx.SeriaNumber;
      csr |= 0x20000000;              // add constant 0x20:set the highest 4 bits of csr 0010   
      
        KeyIDx.Decrypt_KeyL=Decrypt(VenderNumberH, VenderNumberL, csr);                    //low 32 bits of key generation
    /********************************************************************/
       csr   = Recived_Data.Serial_Number;
       csr  |= 0x60000000;              // add constant 0x20 :set the highest 4 bits of csr 0110   
       
        KeyIDx.Decrypt_KeyH  =Decrypt( VenderNumberH, VenderNumberL, csr);                //High 32 bits of key generation
        
   /******initiate the synchronous field of responding key***************************/
        DecryptedCode=Decrypt(KeyIDx.Decrypt_KeyH,KeyIDx.Decrypt_KeyL, DecryptedCode);
        KeyIDx.Sync_Counter1  =DecryptedCode&0x0000FFFF;                                                          //if validate ,update the Sync_Counter value
        KeyIDx.Sync_Counter2  =DecryptedCode&0x0000FFFF;
        
        return KeyIDx;
} 

/*****************************************************************************************************
Founction Name :Decrypt()    private function
     Founction :             Perform the decrypt algorithm
     Peramater :u32    pih   The high 32 bits of the vender code
                u32    pil   The low 32 bits of the vender code
                u32    csr   The recived seria number or seed of the transmitter which is the first time 
                             transmit toward the reciver .
        Output :u32    csr   It is the low 32 bits of the 64 bits decrypt key you want to generate when 
                             the input csr is seed+0x20000000 or Recived_Data.Seria_Number+0x20000000 , 
                             else ,if csr equal to Seed+0x60000000 or Recived_Data.Seria_Number+0x60000000,
                             it is the high 32 bits of the decrypt key.  
          Note :
***************************************************************************************************/
u32 Decrypt(u32 pih,u32 pil,  u32    csr)
{
  u16   ix   ,
        bitlu;
  u32   keybit  ,
        keybit2 ,
        bitin   ; 
  u32 lut[32] ={ 0,1,1,1, 0,1,0,0,
	         0,0,1,0, 1,1,1,0, 
	         0,0,1,1, 1,0,1,0, 
	         0,1,0,1, 1,1,0,0 };/* E 2 4 7 C 5 A 3 */
        ix       =0;
        bitlu    =0;
        keybit   =0;
        keybit2  =0;
        bitin    =0; 
       for(ix=0; ix < 528; ix++)
        {
           bitin   =getbit(csr,31);                      // Rotate Code Shift Register
             csr <<=1;
          
         keybit2   =getbit(pil,15);                         // Get Key Bit
          
         
          keybit   =getbit(pih,31);                        // Rotate Key Right
             pih   =(pih<<1)|getbit(pil,31);
             pil   =(pil<<1)|keybit;                       // 64-bit left rotate 
        
             
          bitlu     = 0;                                   // Get result from Non-Linear Lookup Table
          ifbit (csr, 1) setbit(bitlu,0);
          ifbit (csr, 9) setbit(bitlu,1);
          ifbit (csr,20) setbit(bitlu,2);
          ifbit (csr,26) setbit(bitlu,3);                 //
          ifbit (csr,31) setbit(bitlu,4);
   
          csr = csr^ bitin ^ ((csr&0x10000L)>>16) ^ lut[bitlu]^ keybit2;         // Calculate Result of XOR and shift in
        }
       Learn_Key_State=0;
       return csr;
}
/*****************************************************************************************************
Founction Name :Learn_Key()
     Founction :                      To check whether the Learn_Key is being pressed.If the Learn_Key is pressed ,then system enter learning mode.
     Peramater :none
        Output :u8  Learn_Key_Status  If Learn_Key_Status equal 1 ,it indicate the Learn_Key has been 
                                      pressed ddown, and the reciver will enter the learn mode .
          Note :
***************************************************************************************************/
u8 Learn_Key(void)
{
	 u8  Learn_Key_Status=0;
  if(   ((GPIOD->IDR&0x0010)==0)
     || ((GPIOD->IDR&0x0008)==0))
   {
    Learn_Key_Status=1;
    GPIOC->ODR  =0x0040;
    Delay_Xs(1);
    GPIOC->ODR  =0x0080;
    Delay_Xs(1);
   }
    return Learn_Key_Status;    //this function is not as good to use ,maybe it is due to the GPIOD configure faulse
}


/****************************************************************
*******************************************************************/


KeyID  Read_KeyID_From_EEP( KeyID_Address  KeyIDx_Address)
{
  KeyID KeyIDRead={0,0,0,0,0};
  
     KeyIDRead.SeriaNumber      =ReadKeyID32(KeyIDx_Address.SeriaNumber_Address);
     KeyIDRead.Decrypt_KeyH     =ReadKeyID32(KeyIDx_Address.Decrypt_KeyH_Address);

     KeyIDRead.Decrypt_KeyL     =ReadKeyID32(KeyIDx_Address.Decrypt_KeyL_Address);

     KeyIDRead.Sync_Counter1    =ReadKeyID32(KeyIDx_Address.Sync_Counter1_Address);
     KeyIDRead.Sync_Counter2    =ReadKeyID32(KeyIDx_Address.Sync_Counter2_Address);
     return KeyIDRead;
}
/****************************************************************
*******************************************************************/
void  Write_KeyID_To_EEP(KeyID KeyIDx,KeyID_Address KeyIDx_Address)
{
     WriteKeyID32( KeyIDx.SeriaNumber,    KeyIDx_Address.SeriaNumber_Address);
     WriteKeyID32( KeyIDx.Decrypt_KeyH,   KeyIDx_Address.Decrypt_KeyH_Address);
     WriteKeyID32( KeyIDx.Decrypt_KeyL,   KeyIDx_Address.Decrypt_KeyL_Address);
     WriteKeyID32( KeyIDx.Sync_Counter1,  KeyIDx_Address.Sync_Counter1_Address);
     WriteKeyID32( KeyIDx.Sync_Counter2,  KeyIDx_Address.Sync_Counter2_Address);
  
}  

/****************************************************************
*******************************************************************/
u32 ReadKeyID32(u8 Data_Read_FromAddress)
{
  u8   Buffer[4];
  u32  temp=0; 
  u32  Key_Number=0;
   EEPR_Read_Commend(Data_Read_FromAddress,Buffer,4);
   temp=(u32)Buffer[0];
   Key_Number |=      (temp<<24)  &0xFF000000;
   temp=(u32)Buffer[1];
   Key_Number |=      (temp<<16)  &0x00FF0000;
   temp=(u32)Buffer[2];
   Key_Number |=      (temp<<8)   &0x0000FF00;
   temp=(u32)Buffer[3];
   Key_Number |=       temp       &0x000000FF;
  return Key_Number;
}
/****************************************************************
*******************************************************************/
void WriteKeyID32(u32 Data,u8 Data_Write_To_Address)
{
  u8 Buffer[4];
  Buffer[0]=(u8)((Data&0xFF000000)>>24);
  Buffer[1]=(u8)((Data&0x00FF0000)>>16);
  Buffer[2]=(u8)((Data&0x0000FF00)>>8) ;
  Buffer[3]=(u8) (Data&0x000000FF)     ;

  EEPR_Write_Commend(Data_Write_To_Address, Buffer,4);
}