AuthorizationCodeTool/3des源码/des.c

/*---------------------------------------------------------------------------------------------*/
/*  (c) Copyright Tokheim, unpublished work, created 2008.                                     */
/*  This computer program includes Confidential, Proprietary Information and is a Trade        */
/*  Secret of Tokheim.                                                                         */
/*  All use, disclosure, and / or reproduction is prohibited unless authorized in writing.     */
/*  All Rights Reserved.                                                                       */
/*---------------------------------------------------------------------------------------------*/
/*
 *  $Header$
 *
 *  File    : tax_comm.c
 *  Purpose : source file containing the Main Loop for communication with TAX CPU
 *  Status  :
 *      $Revision$
 *      $Change$
 *      $Date$
 *      $Author$
 *
 *
 *  Record of changes :
 *
 *  Version  Date            Author              Comment
 *   00.01   2011.05.18       wu               - initial file.
 *   00.02   2014.05.13     LaiXihong     - modified to avoid warning for ubuntu environment
 *---------------------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------------*/
/* SYSTEM INCLUDES                                                                        */
/*----------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <malloc.h>

//#include   <errno.h>   
//#include   <time.h>   
//#include   <sys/types.h>   
#include   <sys/time.h>   

/*----------------------------------------------------------------------------------------*/
/* PLATFORM INCLUDES                                                                      */
/*----------------------------------------------------------------------------------------*/
#include <Pfm.h>

/*----------------------------------------------------------------------------------------*/
/* TQC INCLUDES                                                                           */
/*----------------------------------------------------------------------------------------*/
#include <Tokheim.h>
#include <TqcNames.h>
#include <TqcMsgs.h>

#include <Tgt.h>

#include <TqcPrc.h>
#include <Xml.h>

/*-------------------------------------------------------------------------------------*/
/* LOCAL INCLUDES                                                                         */
/*----------------------------------------------------------------------------------------*/
#include <protocol.h>                   /* generic header */
#include <prot_IFSF.h>                  /* public header  */
//#include <prot_sin_protocol.h>
#include <prot_Sinopec_comm.h>    /* local header   */
#include <prot_Sinopec_DB.h>
//#include <prot_sin_DB.h>

extern SAFETY_VALIDATE_DSCR    g_UiValidate[MAX_DISPENSER_FIPS];




#define  Key16_LEN      16
unsigned char  Key16_Code[Key16_LEN] = {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F};
///////////////////////////////////////////////////////////////////////////////////////////
//Initialize the tables

//Table-s1
unsigned char  s1[4][16] = 
{
    {14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
    {0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
    {4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
    {15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}
} ;

//Table-s2
unsigned char  s2[4][16] = 
{
    {15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
    {3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
    {0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
    {13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}
} ;

//Table-s3
unsigned char  s3[4][16] = 
{
    {10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
    {13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
    {13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
    {1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}
} ;

//Table-s4
unsigned char  s4[4][16] = 
{
    {7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
    {13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
    {10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
    {3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}
} ;

//Table-s5
unsigned char  s5[4][16] = 
{
    {2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
    {14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
    {4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
    {11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}
} ;

//Table-s6
unsigned char  s6[4][16] = 
{
    {12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
    {10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
    {9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
    {4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}
} ;

//Table-s7
unsigned char  s7[4][16] = 
{
    {4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
    {13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
    {1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
    {6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}
} ;

//Table-s8
unsigned char  s8[4][16] = 
{
    {13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
    {1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
    {7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
    {2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}
} ;


//Table - Shift
unsigned char  ucShift[16] = 
{
    1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
} ;

//Table - Binary
unsigned char  ucBinary[64] = 
{
    0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,
    0,1,0,0,0,1,0,1,0,1,1,0,0,1,1,1,
    1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,1,
    1,1,0,0,1,1,0,1,1,1,1,0,1,1,1,1
} ;


void TripleDES(unsigned char *pszData,unsigned char *pszDesKey,unsigned char nFlag);
void DES(unsigned char  *pszData,unsigned char  *pszDesKey,unsigned char nFlag);


///////////////////////////////////////////////////////////////////////////////////
// Function :TripleDES
//
// Purpose  : send the answer for realtime information
// 
// Inputs   : FipID: fip id
// 
// Outputs  : NONE
// Returns  : true: send command success.
//			  false: send command failed.
// Version  Date        Author          Comment
// 00.01    2011.05.12  wujianhong       initial version
//
//////////////////////////////////////////////////////////////////////////////////////
void TripleDES(unsigned char *pszData,unsigned char *pszDesKey,unsigned char nFlag) 
{
    unsigned char cnFlag;

    cnFlag= 1- nFlag;

    DES(pszData,pszDesKey,nFlag);
    DES(pszData,pszDesKey+8,cnFlag);
    DES(pszData,pszDesKey,nFlag);

    return;
}
///////////////////////////////////////////////////////////////////////////////////
// Function : DES
//
// Purpose  : send the answer for realtime information
// 
// Inputs   : FipID: fip id
// 
// Outputs  : NONE
// Returns  : true: send command success.
//			  false: send command failed.
// Version  Date        Author          Comment
// 00.01    2011.05.12  wujianhong       initial version
//
//////////////////////////////////////////////////////////////////////////////////////
void DES(unsigned char *pszData,unsigned char *pszDesKey,unsigned char nFlag) 
{
    unsigned char pszBufOut[64],pszKeyWork[56],pszWork[48],pszKeyNo[48] ;
    unsigned char pszBuffer[64],pszKey[64];
    unsigned char nIndex,nItem,ucBrofunShift,nTemp1,nTemp2 ;
    unsigned char i,j,k ;



    //Main Process

    //convert from 64-bit key into 64-byte key
    for ( i=0;i<8;i++ )
    {
        pszKey[8*i] = ( ( j=*( pszDesKey+i ) ) / 128 ) % 2 ;
        pszKey[8*i+1] = ( j/64 ) % 2 ;
        pszKey[8*i+2] = ( j/32 ) % 2 ;
        pszKey[8*i+3] = ( j/16 ) % 2 ;
        pszKey[8*i+4] = ( j/8 ) % 2 ;
        pszKey[8*i+5] = ( j/4 ) % 2 ;
        pszKey[8*i+6] = ( j/2 ) % 2 ;
        pszKey[8*i+7] = j % 2 ;
    }

    //Convert from 64-bit data into 64-byte data
    for ( i=0;i<8;i++ )
    {
        pszBuffer[8*i] = ( ( j=*( pszData+i) ) / 128 ) % 2 ;
        pszBuffer[8*i+1] = ( j/64 ) % 2 ;
        pszBuffer[8*i+2] = ( j/32 ) % 2 ;
        pszBuffer[8*i+3] = ( j/16 ) % 2 ;
        pszBuffer[8*i+4] = ( j/8 ) % 2 ;
        pszBuffer[8*i+5] = ( j/4 ) % 2 ;
        pszBuffer[8*i+6] = ( j/2 ) % 2 ;
        pszBuffer[8*i+7] = j % 2 ;
    }

    //Initial Permutation of Data
    pszBufOut[0]  = pszBuffer[57] ;
    pszBufOut[1]  = pszBuffer[49] ;
    pszBufOut[2]  = pszBuffer[41] ;
    pszBufOut[3]  = pszBuffer[33] ;
    pszBufOut[4]  = pszBuffer[25] ;
    pszBufOut[5]  = pszBuffer[17] ;
    pszBufOut[6]  = pszBuffer[9]  ;
    pszBufOut[7]  = pszBuffer[1]  ;
    pszBufOut[8]  = pszBuffer[59] ;
    pszBufOut[9]  = pszBuffer[51] ;
    pszBufOut[10] = pszBuffer[43] ;
    pszBufOut[11] = pszBuffer[35] ;
    pszBufOut[12] = pszBuffer[27] ;
    pszBufOut[13] = pszBuffer[19] ;
    pszBufOut[14] = pszBuffer[11] ;
    pszBufOut[15] = pszBuffer[3]  ;
    pszBufOut[16] = pszBuffer[61] ;
    pszBufOut[17] = pszBuffer[53] ;
    pszBufOut[18] = pszBuffer[45] ;
    pszBufOut[19] = pszBuffer[37] ;
    pszBufOut[20] = pszBuffer[29] ;
    pszBufOut[21] = pszBuffer[21] ;
    pszBufOut[22] = pszBuffer[13] ;
    pszBufOut[23] = pszBuffer[5]  ;
    pszBufOut[24] = pszBuffer[63] ;
    pszBufOut[25] = pszBuffer[55] ;
    pszBufOut[26] = pszBuffer[47] ;
    pszBufOut[27] = pszBuffer[39] ;
    pszBufOut[28] = pszBuffer[31] ;
    pszBufOut[29] = pszBuffer[23] ;
    pszBufOut[30] = pszBuffer[15] ;
    pszBufOut[31] = pszBuffer[7]  ;
    pszBufOut[32] = pszBuffer[56] ;
    pszBufOut[33] = pszBuffer[48] ;
    pszBufOut[34] = pszBuffer[40] ;
    pszBufOut[35] = pszBuffer[32] ;
    pszBufOut[36] = pszBuffer[24] ;
    pszBufOut[37] = pszBuffer[16] ;
    pszBufOut[38] = pszBuffer[8]  ;
    pszBufOut[39] = pszBuffer[0]  ;
    pszBufOut[40] = pszBuffer[58] ;
    pszBufOut[41] = pszBuffer[50] ;
    pszBufOut[42] = pszBuffer[42] ;
    pszBufOut[43] = pszBuffer[34] ;
    pszBufOut[44] = pszBuffer[26] ;
    pszBufOut[45] = pszBuffer[18] ;
    pszBufOut[46] = pszBuffer[10] ;
    pszBufOut[47] = pszBuffer[2]  ;
    pszBufOut[48] = pszBuffer[60] ;
    pszBufOut[49] = pszBuffer[52] ;
    pszBufOut[50] = pszBuffer[44] ;
    pszBufOut[51] = pszBuffer[36] ;
    pszBufOut[52] = pszBuffer[28] ;
    pszBufOut[53] = pszBuffer[20] ;
    pszBufOut[54] = pszBuffer[12] ;
    pszBufOut[55] = pszBuffer[4]  ;
    pszBufOut[56] = pszBuffer[62] ;
    pszBufOut[57] = pszBuffer[54] ;
    pszBufOut[58] = pszBuffer[46] ;
    pszBufOut[59] = pszBuffer[38] ;
    pszBufOut[60] = pszBuffer[30] ;
    pszBufOut[61] = pszBuffer[22] ;
    pszBufOut[62] = pszBuffer[14] ;
    pszBufOut[63] = pszBuffer[6]  ;

    //Initial Permutation of key
    pszKeyWork[0] = pszKey[56] ;
    pszKeyWork[1] = pszKey[48] ;
    pszKeyWork[2] = pszKey[40] ;
    pszKeyWork[3] = pszKey[32] ;
    pszKeyWork[4] = pszKey[24] ;
    pszKeyWork[5] = pszKey[16] ;
    pszKeyWork[6] = pszKey[8] ;
    pszKeyWork[7] = pszKey[0] ;
    pszKeyWork[8] = pszKey[57] ;
    pszKeyWork[9] = pszKey[49] ;
    pszKeyWork[10] = pszKey[41] ;
    pszKeyWork[11] = pszKey[33] ;
    pszKeyWork[12] = pszKey[25] ;
    pszKeyWork[13] = pszKey[17] ;
    pszKeyWork[14] = pszKey[9] ;
    pszKeyWork[15] = pszKey[1] ;
    pszKeyWork[16] = pszKey[58] ;
    pszKeyWork[17] = pszKey[50] ;
    pszKeyWork[18] = pszKey[42] ;
    pszKeyWork[19] = pszKey[34] ;
    pszKeyWork[20] = pszKey[26] ;
    pszKeyWork[21] = pszKey[18] ;
    pszKeyWork[22] = pszKey[10] ;
    pszKeyWork[23] = pszKey[2] ;
    pszKeyWork[24] = pszKey[59] ;
    pszKeyWork[25] = pszKey[51] ;
    pszKeyWork[26] = pszKey[43] ;
    pszKeyWork[27] = pszKey[35] ;
    pszKeyWork[28] = pszKey[62] ;
    pszKeyWork[29] = pszKey[54] ;
    pszKeyWork[30] = pszKey[46] ;
    pszKeyWork[31] = pszKey[38] ;
    pszKeyWork[32] = pszKey[30] ;
    pszKeyWork[33] = pszKey[22] ;
    pszKeyWork[34] = pszKey[14] ;
    pszKeyWork[35] = pszKey[6] ;
    pszKeyWork[36] = pszKey[61] ;
    pszKeyWork[37] = pszKey[53] ;
    pszKeyWork[38] = pszKey[45] ;
    pszKeyWork[39] = pszKey[37] ;
    pszKeyWork[40] = pszKey[29] ;
    pszKeyWork[41] = pszKey[21] ;
    pszKeyWork[42] = pszKey[13] ;
    pszKeyWork[43] = pszKey[5] ;
    pszKeyWork[44] = pszKey[60] ;
    pszKeyWork[45] = pszKey[52] ;
    pszKeyWork[46] = pszKey[44] ;
    pszKeyWork[47] = pszKey[36] ;
    pszKeyWork[48] = pszKey[28] ;
    pszKeyWork[49] = pszKey[20] ;
    pszKeyWork[50] = pszKey[12] ;
    pszKeyWork[51] = pszKey[4] ;
    pszKeyWork[52] = pszKey[27] ;
    pszKeyWork[53] = pszKey[19] ;
    pszKeyWork[54] = pszKey[11] ;
    pszKeyWork[55] = pszKey[3] ;

    //16 nItemations
    for ( nItem=1;nItem<17;nItem++ )
    {
        for ( i=0;i<32;i++ )
        {
            pszBuffer[i] = pszBufOut[32+i] ;
        }
        //Calculation of F(R,K)
        //Permute - E
        pszWork[0]  = pszBuffer[31] ;
        pszWork[1]  = pszBuffer[0]  ;
        pszWork[2]  = pszBuffer[1]  ;
        pszWork[3]  = pszBuffer[2]  ;
        pszWork[4]  = pszBuffer[3]  ;
        pszWork[5]  = pszBuffer[4]  ;
        pszWork[6]  = pszBuffer[3]  ;
        pszWork[7]  = pszBuffer[4]  ;
        pszWork[8]  = pszBuffer[5]  ;
        pszWork[9]  = pszBuffer[6]  ;
        pszWork[10] = pszBuffer[7]  ;
        pszWork[11] = pszBuffer[8]  ;
        pszWork[12] = pszBuffer[7]  ; 
        pszWork[13] = pszBuffer[8]  ;
        pszWork[14] = pszBuffer[9]  ;
        pszWork[15] = pszBuffer[10] ;
        pszWork[16] = pszBuffer[11] ;
        pszWork[17] = pszBuffer[12] ;
        pszWork[18] = pszBuffer[11] ;
        pszWork[19] = pszBuffer[12] ;
        pszWork[20] = pszBuffer[13] ;
        pszWork[21] = pszBuffer[14] ;
        pszWork[22] = pszBuffer[15] ;
        pszWork[23] = pszBuffer[16] ;
        pszWork[24] = pszBuffer[15] ;
        pszWork[25] = pszBuffer[16] ;
        pszWork[26] = pszBuffer[17] ;
        pszWork[27] = pszBuffer[18] ;
        pszWork[28] = pszBuffer[19] ;
        pszWork[29] = pszBuffer[20] ;
        pszWork[30] = pszBuffer[19] ;
        pszWork[31] = pszBuffer[20] ;
        pszWork[32] = pszBuffer[21] ;
        pszWork[33] = pszBuffer[22] ;
        pszWork[34] = pszBuffer[23] ;
        pszWork[35] = pszBuffer[24] ;
        pszWork[36] = pszBuffer[23] ;
        pszWork[37] = pszBuffer[24] ;
        pszWork[38] = pszBuffer[25] ;
        pszWork[39] = pszBuffer[26] ;
        pszWork[40] = pszBuffer[27] ;
        pszWork[41] = pszBuffer[28] ;
        pszWork[42] = pszBuffer[27] ;
        pszWork[43] = pszBuffer[28] ;
        pszWork[44] = pszBuffer[29] ;
        pszWork[45] = pszBuffer[30] ;
        pszWork[46] = pszBuffer[31] ;
        pszWork[47] = pszBuffer[0] ;
        //K S Function Begin
        if (nFlag)
        {//Encrypt The Data
            ucBrofunShift = ucShift[nItem-1] ;
            for (i=0;i<(int)ucBrofunShift;i++ )
            {
                nTemp1 = pszKeyWork[0] ;
                nTemp2 = pszKeyWork[28] ;
                for (j=0;j<27;j++)
                {
                    pszKeyWork[j] = pszKeyWork[j+1] ;
                    pszKeyWork[j+28] = pszKeyWork[j+29] ;
                }
                pszKeyWork[27] = nTemp1 ;
                pszKeyWork[55] = nTemp2 ;
            }
        }
        else
        {//Decrypt The Data
            if (nItem>1)
            {
                ucBrofunShift = ucShift[17-nItem] ;
                for (i=0;i<(int)ucBrofunShift;i++)
                {
                    nTemp1 = pszKeyWork[27] ;
                    nTemp2 = pszKeyWork[55] ;
                    for (j=27;j>0;j--)
                    {
                        pszKeyWork[j] = pszKeyWork[j-1] ;
                        pszKeyWork[j+28] = pszKeyWork[j+27] ;
                    }
                    pszKeyWork[0] = nTemp1 ;
                    pszKeyWork[28] = nTemp2 ;
                }
            }
        }
        //Permute kwork - PC2
        pszKeyNo[0]  = pszKeyWork[13] ;
        pszKeyNo[1]  = pszKeyWork[16] ;
        pszKeyNo[2]  = pszKeyWork[10] ;
        pszKeyNo[3]  = pszKeyWork[23] ;
        pszKeyNo[4]  = pszKeyWork[0]  ;
        pszKeyNo[5]  = pszKeyWork[4]  ;
        pszKeyNo[6]  = pszKeyWork[2]  ;
        pszKeyNo[7]  = pszKeyWork[27] ;
        pszKeyNo[8]  = pszKeyWork[14] ;
        pszKeyNo[9]  = pszKeyWork[5]  ;
        pszKeyNo[10] = pszKeyWork[20] ;
        pszKeyNo[11] = pszKeyWork[9]  ;
        pszKeyNo[12] = pszKeyWork[22] ;
        pszKeyNo[13] = pszKeyWork[18] ;
        pszKeyNo[14] = pszKeyWork[11] ;
        pszKeyNo[15] = pszKeyWork[3]  ;
        pszKeyNo[16] = pszKeyWork[25] ;
        pszKeyNo[17] = pszKeyWork[7]  ;
        pszKeyNo[18] = pszKeyWork[15] ;
        pszKeyNo[19] = pszKeyWork[6]  ;
        pszKeyNo[20] = pszKeyWork[26] ;
        pszKeyNo[21] = pszKeyWork[19] ;
        pszKeyNo[22] = pszKeyWork[12] ;
        pszKeyNo[23] = pszKeyWork[1]  ;
        pszKeyNo[24] = pszKeyWork[40] ;
        pszKeyNo[25] = pszKeyWork[51] ;
        pszKeyNo[26] = pszKeyWork[30] ;
        pszKeyNo[27] = pszKeyWork[36] ;
        pszKeyNo[28] = pszKeyWork[46] ;
        pszKeyNo[29] = pszKeyWork[54] ;
        pszKeyNo[30] = pszKeyWork[29] ;
        pszKeyNo[31] = pszKeyWork[39] ;
        pszKeyNo[32] = pszKeyWork[50] ;
        pszKeyNo[33] = pszKeyWork[44] ;
        pszKeyNo[34] = pszKeyWork[32] ;
        pszKeyNo[35] = pszKeyWork[47] ;
        pszKeyNo[36] = pszKeyWork[43] ;
        pszKeyNo[37] = pszKeyWork[48] ;
        pszKeyNo[38] = pszKeyWork[38] ;
        pszKeyNo[39] = pszKeyWork[55] ;
        pszKeyNo[40] = pszKeyWork[33] ;
        pszKeyNo[41] = pszKeyWork[52] ;
        pszKeyNo[42] = pszKeyWork[45] ;
        pszKeyNo[43] = pszKeyWork[41] ;
        pszKeyNo[44] = pszKeyWork[49] ;
        pszKeyNo[45] = pszKeyWork[35] ;
        pszKeyNo[46] = pszKeyWork[28] ;
        pszKeyNo[47] = pszKeyWork[31] ;
        //K S Functin End
        //pszWork XOR pszKeyNo
        for (i=0;i<48;i++)
            pszWork[i] = pszWork[i]^pszKeyNo[i] ;
        //8 s-functions
        nIndex = s1[2*pszWork[0]+pszWork[5]][2*(2*(2*pszWork[1]+pszWork[2])+pszWork[3])+pszWork[4]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[0] = ucBinary[0+nIndex] ;
        pszKeyNo[1] = ucBinary[1+nIndex] ;
        pszKeyNo[2] = ucBinary[2+nIndex] ;
        pszKeyNo[3] = ucBinary[3+nIndex] ;

        nIndex = s2[2*pszWork[6]+pszWork[11]][2*(2*(2*pszWork[7]+pszWork[8])+pszWork[9])+pszWork[10]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[4] = ucBinary[0+nIndex] ;
        pszKeyNo[5] = ucBinary[1+nIndex] ;
        pszKeyNo[6] = ucBinary[2+nIndex] ;
        pszKeyNo[7] = ucBinary[3+nIndex] ;

        nIndex = s3[2*pszWork[12]+pszWork[17]][2*(2*(2*pszWork[13]+pszWork[14])+pszWork[15])+pszWork[16]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[8] = ucBinary[0+nIndex] ;
        pszKeyNo[9] = ucBinary[1+nIndex] ;
        pszKeyNo[10] = ucBinary[2+nIndex] ;
        pszKeyNo[11] = ucBinary[3+nIndex] ;

        nIndex = s4[2*pszWork[18]+pszWork[23]][2*(2*(2*pszWork[19]+pszWork[20])+pszWork[21])+pszWork[22]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[12] = ucBinary[0+nIndex] ;
        pszKeyNo[13] = ucBinary[1+nIndex] ;
        pszKeyNo[14] = ucBinary[2+nIndex] ;
        pszKeyNo[15] = ucBinary[3+nIndex] ;

        nIndex = s5[2*pszWork[24]+pszWork[29]][2*(2*(2*pszWork[25]+pszWork[26])+pszWork[27])+pszWork[28]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[16] = ucBinary[0+nIndex] ;
        pszKeyNo[17] = ucBinary[1+nIndex] ;
        pszKeyNo[18] = ucBinary[2+nIndex] ;
        pszKeyNo[19] = ucBinary[3+nIndex] ;

        nIndex = s6[2*pszWork[30]+pszWork[35]][2*(2*(2*pszWork[31]+pszWork[32])+pszWork[33])+pszWork[34]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[20] = ucBinary[0+nIndex] ;
        pszKeyNo[21] = ucBinary[1+nIndex] ;
        pszKeyNo[22] = ucBinary[2+nIndex] ;
        pszKeyNo[23] = ucBinary[3+nIndex] ;

        nIndex = s7[2*pszWork[36]+pszWork[41]][2*(2*(2*pszWork[37]+pszWork[38])+pszWork[39])+pszWork[40]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[24] = ucBinary[0+nIndex] ;
        pszKeyNo[25] = ucBinary[1+nIndex] ;
        pszKeyNo[26] = ucBinary[2+nIndex] ;
        pszKeyNo[27] = ucBinary[3+nIndex] ;

        nIndex = s8[2*pszWork[42]+pszWork[47]][2*(2*(2*pszWork[43]+pszWork[44])+pszWork[45])+pszWork[46]] ;
        nIndex = nIndex*4 ;
        pszKeyNo[28] = ucBinary[0+nIndex] ;
        pszKeyNo[29] = ucBinary[1+nIndex] ;
        pszKeyNo[30] = ucBinary[2+nIndex] ;
        pszKeyNo[31] = ucBinary[3+nIndex] ;

        //Permute - P
        pszWork[0] = pszKeyNo[15]  ;
        pszWork[1] = pszKeyNo[6]   ;
        pszWork[2] = pszKeyNo[19]  ;
        pszWork[3] = pszKeyNo[20]  ;
        pszWork[4] = pszKeyNo[28]  ;
        pszWork[5] = pszKeyNo[11]  ;
        pszWork[6] = pszKeyNo[27]  ;
        pszWork[7] = pszKeyNo[16]  ;
        pszWork[8] = pszKeyNo[0]   ;
        pszWork[9] = pszKeyNo[14]  ;
        pszWork[10] = pszKeyNo[22] ;
        pszWork[11] = pszKeyNo[25] ;
        pszWork[12] = pszKeyNo[4]  ;
        pszWork[13] = pszKeyNo[17] ;
        pszWork[14] = pszKeyNo[30] ;
        pszWork[15] = pszKeyNo[9]  ;
        pszWork[16] = pszKeyNo[1]  ;
        pszWork[17] = pszKeyNo[7]  ;
        pszWork[18] = pszKeyNo[23] ;
        pszWork[19] = pszKeyNo[13] ;
        pszWork[20] = pszKeyNo[31] ;
        pszWork[21] = pszKeyNo[26] ;
        pszWork[22] = pszKeyNo[2]  ;
        pszWork[23] = pszKeyNo[8]  ;
        pszWork[24] = pszKeyNo[18] ;
        pszWork[25] = pszKeyNo[12] ;
        pszWork[26] = pszKeyNo[29] ;
        pszWork[27] = pszKeyNo[5]  ;
        pszWork[28] = pszKeyNo[21] ;
        pszWork[29] = pszKeyNo[10] ;
        pszWork[30] = pszKeyNo[3]  ;
        pszWork[31] = pszKeyNo[24] ;

        //Buffer XOR pszWork
        for (i=0;i<32;i++)
        {
            pszBufOut[i+32] = pszBufOut[i]^pszWork[i] ;
            pszBufOut[i] = pszBuffer[i] ;
        }
    }//End of nItem

    //Prepare Output
    for (i=0;i<32;i++)
    {
        j = pszBufOut[i] ;
        pszBufOut[i] = pszBufOut[32+i] ;
        pszBufOut[32+i] = j ;
    }

    //Inverse Initial Permutation
    pszBuffer[0]  = pszBufOut[39] ;
    pszBuffer[1]  = pszBufOut[7]  ;
    pszBuffer[2]  = pszBufOut[47] ;
    pszBuffer[3]  = pszBufOut[15] ; 
    pszBuffer[4]  = pszBufOut[55] ;
    pszBuffer[5]  = pszBufOut[23] ;
    pszBuffer[6]  = pszBufOut[63] ;
    pszBuffer[7]  = pszBufOut[31] ;
    pszBuffer[8]  = pszBufOut[38] ;
    pszBuffer[9]  = pszBufOut[6]  ;
    pszBuffer[10] = pszBufOut[46] ;
    pszBuffer[11] = pszBufOut[14] ; 
    pszBuffer[12] = pszBufOut[54] ;
    pszBuffer[13] = pszBufOut[22] ;
    pszBuffer[14] = pszBufOut[62] ;
    pszBuffer[15] = pszBufOut[30] ;
    pszBuffer[16] = pszBufOut[37] ;
    pszBuffer[17] = pszBufOut[5]  ;
    pszBuffer[18] = pszBufOut[45] ;
    pszBuffer[19] = pszBufOut[13] ; 
    pszBuffer[20] = pszBufOut[53] ;
    pszBuffer[21] = pszBufOut[21] ;
    pszBuffer[22] = pszBufOut[61] ;
    pszBuffer[23] = pszBufOut[29] ;
    pszBuffer[24] = pszBufOut[36] ;
    pszBuffer[25] = pszBufOut[4]  ;
    pszBuffer[26] = pszBufOut[44] ;
    pszBuffer[27] = pszBufOut[12] ; 
    pszBuffer[28] = pszBufOut[52] ;
    pszBuffer[29] = pszBufOut[20] ;
    pszBuffer[30] = pszBufOut[60] ;
    pszBuffer[31] = pszBufOut[28] ;
    pszBuffer[32] = pszBufOut[35] ;
    pszBuffer[33] = pszBufOut[3]  ;
    pszBuffer[34] = pszBufOut[43] ;
    pszBuffer[35] = pszBufOut[11] ; 
    pszBuffer[36] = pszBufOut[51] ;
    pszBuffer[37] = pszBufOut[19] ;
    pszBuffer[38] = pszBufOut[59] ;
    pszBuffer[39] = pszBufOut[27] ;
    pszBuffer[40] = pszBufOut[34] ;
    pszBuffer[41] = pszBufOut[2]  ;
    pszBuffer[42] = pszBufOut[42] ;
    pszBuffer[43] = pszBufOut[10] ; 
    pszBuffer[44] = pszBufOut[50] ;
    pszBuffer[45] = pszBufOut[18] ;
    pszBuffer[46] = pszBufOut[58] ;
    pszBuffer[47] = pszBufOut[26] ;
    pszBuffer[48] = pszBufOut[33] ;
    pszBuffer[49] = pszBufOut[1]  ;
    pszBuffer[50] = pszBufOut[41] ;
    pszBuffer[51] = pszBufOut[9]  ; 
    pszBuffer[52] = pszBufOut[49] ;
    pszBuffer[53] = pszBufOut[17] ;
    pszBuffer[54] = pszBufOut[57] ;
    pszBuffer[55] = pszBufOut[25] ;
    pszBuffer[56] = pszBufOut[32] ;
    pszBuffer[57] = pszBufOut[0]  ;
    pszBuffer[58] = pszBufOut[40] ;
    pszBuffer[59] = pszBufOut[8]  ; 
    pszBuffer[60] = pszBufOut[48] ;
    pszBuffer[61] = pszBufOut[16] ;
    pszBuffer[62] = pszBufOut[56] ;
    pszBuffer[63] = pszBufOut[24] ;

    j=0 ;
    for (i=0;i<8;i++)
    {
        *(pszData+i) = 0x00 ;
        for (k=0;k<7;k++)
            *(pszData+i) = ((*(pszData+i))+pszBuffer[j+k])*2 ;
        *(pszData+i) = *(pszData+i)+pszBuffer[j+7] ;
        j+=8 ;
    }
}

///////////////////////////////////////////////////////////////////////////////////
// Function : DecryptDesData
//
// Purpose  : send the answer for realtime information
// 
// Inputs   : FipID: fip id
// 
// Outputs  : NONE
// Returns  : true: send command success.
//			  false: send command failed.
// Version  Date        Author          Comment
// 00.01    2011.05.12  wujianhong       initial version
//
//////////////////////////////////////////////////////////////////////////////////////
void DecryptDesData(unsigned char flag, unsigned char *pdata, unsigned char *presult)   
{
    unsigned char src8[8];
    unsigned char key48[48];

    memcpy(src8,pdata,8);
    memcpy(key48,Key16_Code,Key16_LEN);

    TripleDES(src8,key48,flag);

    memcpy(presult,src8,8);
}

///////////////////////////////////////////////////////////////////////////////////
// Function : InitAntiFraud
//
// Purpose  : send the answer for realtime information
// 
// Inputs   : FipID: fip id
// 
// Outputs  : NONE
// Returns  : true: send command success.
//			  false: send command failed.
// Version  Date        Author          Comment
// 00.01    2011.05.12  wujianhong       initial version
//
//////////////////////////////////////////////////////////////////////////////////////
int InitAntiFraud(BYTE fips)   
{

    char filename[256];
    unsigned char  buffer[100];
    FILE *binfile = NULL;
    int imagesize = 0; // without module header
    int  offset;

    memset(filename,0,sizeof(filename));
    sprintf(filename,"%s/%s",SELFSERVICE_DB_PATH,IDKEYBIN);

    if (tgt_access(filename, TGT_FILEACCESS_EXISTS) != TGT_CC_NO_ERROR)
    {
        printf("error:can not find the file[Idkey]!!!!!!!!!!!!!!!!");
    }
    else
    {
        // If there is a name specified, open the bin file
        binfile = fopen(filename, "rb");
        // Get file size
        fseek(binfile, 0, SEEK_END);
        imagesize = ftell(binfile);
        fseek(binfile, 0, SEEK_SET);
        //printf("binfile imagesize[%d] \n",imagesize);
        fread(buffer, imagesize, 1, binfile);

        for (int i=0;i< imagesize/8;i++)
        {
            DecryptDesData(0,&buffer[8*i],&buffer[8*i]);
        }   

        offset=0;
        for (int i=0;i<fips;i++)
        {
            g_UiValidate[i].ui=0x64+i;
            memcpy(g_UiValidate[i].CalculateId,&buffer[offset],8);
            offset+=8;

            memcpy(g_UiValidate[i].Key,&buffer[offset],16);
            offset+=16;
        }

        // Do not forget to close the binfile
        fclose(binfile);
    }

    return 0;   
}  

///////////////////////////////////////////////////////////////////////////////////
// Function : DesData
//
// Purpose  : send the answer for realtime information
// 
// Inputs   : FipID: fip id
// 
// Outputs  : NONE
// Returns  : true: send command success.
//			  false: send command failed.
// Version  Date        Author          Comment
// 00.01    2011.05.12  wujianhong       initial version
//
//////////////////////////////////////////////////////////////////////////////////////
void DesData(int fip, BYTE *pdata, BYTE *ptr_key,BYTE *presult)   
{
    unsigned char src8[8];
    unsigned char key48[48];
    unsigned char flag=1;

    memcpy(src8,pdata,8);
    memcpy(key48,ptr_key,16);

    TripleDES(src8,key48,flag);

    memcpy(presult,src8,8);
}