zdtkipseed.c

ZYDAS zd1211b driver for Linux2.4

        iv32 = 0;

        for (i=0; i<4; i++) {	// initiv is little endian
                iv32 += *initiv << (i*8);
                *initiv++;
        }

        Seed->IV32 = iv32+1; // Force Recaculating on Tkip Phase1
        Tkip_phase1_key_mix(iv32, Seed);

        Seed->IV16 = iv16;
        Seed->IV32 = iv32;
}



/***********************************************************************/
/*                                                                     */
/*   FUNCTION DESCRIPTION                   Tkip_phase1_key_mix        */
/*                                                                     */
/*   TKIP seed generation function for phase1 key mixing               */
/*                                                                     */
/*   AUTHOR                                                            */
/*     Liam,Hwu            ZyDAS Technology   Corporation              */
/*   Return value:													   */
/*		Return TRUE if expected IV sequence is correct.	               */
/*                                                                     */
/***********************************************************************/
char Tkip_phase1_key_mix(U32 iv32, Seedvar *Seed)
{
        unsigned short tsc0;
        unsigned short tsc1;
        int i, j;

        if (iv32 == Seed->IV32)    //don't need to proceed this function the same
                return 1;
        else {
                tsc0 = (unsigned short)((iv32 >> 16) & 0xffff); /* msb */
                tsc1 = (unsigned short)(iv32 & 0xffff);

                /* Phase 1, step 1 */
                Seed->TTAK[0] = tsc1;
                Seed->TTAK[1] = tsc0;
                Seed->TTAK[2] = (unsigned short)(Seed->TA[0] + (Seed->TA[1] <<8));
                Seed->TTAK[3] = (unsigned short)(Seed->TA[2] + (Seed->TA[3] <<8));
                Seed->TTAK[4] = (unsigned short)(Seed->TA[4] + (Seed->TA[5] <<8));

                /* Phase 1, step 2 */
                for (i=0; i<8; i++) {
                        j = 2*(i & 1);
                        Seed->TTAK[0] = (Seed->TTAK[0] + tkip_sbox(Seed->TTAK[4]
                                         ^ Mk16(Seed->TK[1+j],Seed->TK[j]))) & 0xffff;
                        Seed->TTAK[1] = (Seed->TTAK[1] + tkip_sbox(Seed->TTAK[0]
                                         ^ Mk16(Seed->TK[5+j],Seed->TK[4+j] ))) & 0xffff;
                        Seed->TTAK[2] = (Seed->TTAK[2] + tkip_sbox(Seed->TTAK[1]
                                         ^ Mk16(Seed->TK[9+j],Seed->TK[8+j] ))) & 0xffff;
                        Seed->TTAK[3] = (Seed->TTAK[3] + tkip_sbox(Seed->TTAK[2]
                                         ^ Mk16(Seed->TK[13+j],Seed->TK[12+j])))& 0xffff;
                        Seed->TTAK[4] = (Seed->TTAK[4] + tkip_sbox(Seed->TTAK[3]
                                         ^ Mk16(Seed->TK[1+j] ,Seed->TK[j]  ))) & 0xffff;
                        Seed->TTAK[4] = (Seed->TTAK[4] + i) & 0xffff;
                }

                if (iv32 == (Seed->IV32+1)) {
                        Seed->iv32tmp = iv32;
                        return 1;
                } else
                        return 0;
        }
}


/***********************************************************************/
/*                                                                     */
/*   FUNCTION DESCRIPTION                   Tkip_phase2_key_mix        */
/*                                                                     */
/*   TKIP seed generation function for phase2 key mixing               */
/*                                                                     */
/*   AUTHOR                                                            */
/*     Liam,Hwu            ZyDAS Technology   Corporation              */
/*   Return value:													   */
/*		Return TRUE if expected IV sequence is correct.	               */
/*                                                                     */
/***********************************************************************/
char Tkip_phase2_key_mix(U16 iv16, Seedvar *Seed)
{
        unsigned int tsc2;

        tsc2 = iv16;
        /* Phase 2, Step 1 */
        Seed->ppk[0] = Seed->TTAK[0];
        Seed->ppk[1] = Seed->TTAK[1];
        Seed->ppk[2] = Seed->TTAK[2];
        Seed->ppk[3] = Seed->TTAK[3];
        Seed->ppk[4] = Seed->TTAK[4];
        Seed->ppk[5] = (Seed->TTAK[4] + tsc2) & 0xffff;

        /* Phase2, Step 2 */
        Seed->ppk[0] = Seed->ppk[0] + tkip_sbox(Seed->ppk[5] ^ Mk16(Seed->TK[1],Seed->TK[0])) ;
        Seed->ppk[1] = Seed->ppk[1] + tkip_sbox(Seed->ppk[0] ^ Mk16(Seed->TK[3],Seed->TK[2])) ;
        Seed->ppk[2] = Seed->ppk[2]	+ tkip_sbox(Seed->ppk[1] ^ Mk16(Seed->TK[5],Seed->TK[4])) ;
        Seed->ppk[3] = Seed->ppk[3]	+ tkip_sbox(Seed->ppk[2] ^ Mk16(Seed->TK[7],Seed->TK[6])) ;
        Seed->ppk[4] = Seed->ppk[4]	+ tkip_sbox(Seed->ppk[3] ^ Mk16(Seed->TK[9],Seed->TK[8] )) ;
        Seed->ppk[5] = Seed->ppk[5]	+ tkip_sbox(Seed->ppk[4] ^ Mk16(Seed->TK[11],Seed->TK[10])) ;

        Seed->ppk[0] = Seed->ppk[0]	+ rotr1(Seed->ppk[5] ^ Mk16(Seed->TK[13],Seed->TK[12]));
        Seed->ppk[1] = Seed->ppk[1]	+ rotr1(Seed->ppk[0] ^ Mk16(Seed->TK[15],Seed->TK[14]));
        Seed->ppk[2] = Seed->ppk[2] + rotr1(Seed->ppk[1]);
        Seed->ppk[3] = Seed->ppk[3] + rotr1(Seed->ppk[2]);
        Seed->ppk[4] = Seed->ppk[4] + rotr1(Seed->ppk[3]);
        Seed->ppk[5] = Seed->ppk[5] + rotr1(Seed->ppk[4]);

        if (iv16 == 0) {
                if (Seed->IV16 == 0xffff) {
                        Seed->iv16tmp = 0;
                        return 1;
                } else
                        return 0;
        } else if (iv16 == (Seed->IV16+1)) {
                Seed->iv16tmp = iv16;
                return 1;
        } else
                return 0;
}


/***********************************************************************/
/*                                                                     */
/*   FUNCTION DESCRIPTION                   Tkip_getseeds              */
/*                                                                     */

/*   Get RC4Key seeds generated by TKIP                                */
/*                                                                     */
/*   AUTHOR                                                            */
/*     Liam,Hwu            ZyDAS Technology   Corporation              */
/*                                                                     */
/***********************************************************************/
void Tkip_getseeds(U16 iv16, U8 *RC4Key, Seedvar *Seed)
{
        RC4Key[0]  = Hi8(iv16);
        RC4Key[1]  = (Hi8(iv16) | 0x20) & 0x7f;
        RC4Key[2]  = Lo8(iv16);
        RC4Key[3]  = ((Seed->ppk[5] ^ Mk16(Seed->TK[1],Seed->TK[0]))>>1) & 0xff;
        RC4Key[4]  = Seed->ppk[0] & 0xff;
        RC4Key[5]  = Seed->ppk[0] >> 8  ;
        RC4Key[6]  = Seed->ppk[1] & 0xff;
        RC4Key[7]  = Seed->ppk[1] >> 8  ;
        RC4Key[8]  = Seed->ppk[2] & 0xff;
        RC4Key[9]  = Seed->ppk[2] >> 8  ;
        RC4Key[10] = Seed->ppk[3] & 0xff;
        RC4Key[11] = Seed->ppk[3] >> 8  ;
        RC4Key[12] = Seed->ppk[4] & 0xff;
        RC4Key[13] = Seed->ppk[4] >> 8  ;
        RC4Key[14] = Seed->ppk[5] & 0xff;
        RC4Key[15] = Seed->ppk[5] >> 8  ;
}


/***********************************************************************/
/*                                                                     */
/*   FUNCTION DESCRIPTION                   Tkip_updateiv              */
/*                                                                     */
/*   update stored iv value                                            */
/*                                                                     */
/*   AUTHOR                                                            */
/*     Liam,Hwu            ZyDAS Technology   Corporation              */
/*                                                                     */
/***********************************************************************/
void Tkip_updateiv(Seedvar *Seed)
{
        Seed->IV16 = Seed->iv16tmp;
        Seed->IV32 = Seed->iv32tmp;
}
#endif