orxytest.cpp

在cdma2000移动通信系统使用ORYX流密码算法实现空中接口部分的数据加密。

#include <stdio.h>
#include "cave.h" /* see Exhibit 2-2 */
#include "oryx.h" /* see Exhibit 2-45 */
  /* NAM stored data */
unsigned char ESN[4] = { 0xd7, 0x5a, 0x96, 0xec };
unsigned char MIN1[3] = { 0x79, 0x29, 0x71 };
unsigned char A_key[8];
unsigned char SSD_A_NEW[8], SSD_A[8];
unsigned char SSD_B_NEW[8], SSD_B[8];
void pause(void)
 {
 printf("Enter to continue\n");
 getchar();
 }
 void main(void)
 {
 int i, j;
 unsigned long hook;
 unsigned char buf[24], rand[4];
rand[0] = 0x12;
rand[1] = 0x34;
rand[2] = 0xab;
rand[3] = 0xcd;
hook = 0xcdef5678;
SSD_B[0] = 0x14;
SSD_B[1] = 0x92;
SSD_B[2] = 0x52;
SSD_B[3] = 0x80;
SSD_B[4] = 0x17;
SSD_B[5] = 0x76;
SSD_B[6] = 0x18;
SSD_B[7] = 0x67;

 printf("\nSSD_B =");
 for (i = 0; i < 4; i++)
 {
 printf(" ");
 for (j = 0; j < 2; j++)
 {
 printf("%02x", (unsigned int)SSD_B[2*i+j]);
}
}

 printf("\nRAND =");
 for (i = 0; i < 2; i++)
 {
 printf(" ");
 for (j = 0; j < 2; j++)
 {
 printf("%02x", rand[2*i+j]);
 }
 }

 printf("\nHOOK = %04lx %04lx\n", hook >> 16, hook & 0x0000ffff);

 pause();

 printf("24 octets of mask to be returned");

 DataKey = DataKey_Generation();

 printf("\n\nOutput:\n\n");

 printf("\nDataKey = %04lx %04lx\n", DataKey >> 16, DataKey & 0x0000ffff);

 LTable_Generation(rand);

 printf("\n\nL:\n\n");

 for(i = 0; i < 16; i++)
 {
 for (j = 0; j < 16; j++)
 {
 printf("%02x ", L[16*i+j]);
 }
 printf("\n");
 }

 pause();

 Data_Mask(DataKey,   hook,   24,   buf);
  printf("\n\nmask:\n\n");

 for(i = 0; i < 2; i++)
 {
 for (j = 0; j < 12; j++)
 {
 printf("%02x ", (unsigned int)buf[12*i+j]);
 }
 printf("\n");
 }
 pause();
 }

////////////////////////////////////////
 #define high(x) (unsigned char)(0xffU&(x>>24)) /* leftmost octet */

#define FA1 000460216667 /* Peterson & Weldon prim 32 */

#define FA2 001760427607 /* Peterson & Weldon prim 32 */

#define FB 020014300113 /* P&W prim 31 020004100071 times z+1 */

#define FK 030634530010 /* reverse of P&W prim 32 04200324714328 */

static 
unsigned long K; /* 32-bit K register */
static
unsigned long A, B; /* 32-bit LFSRs */
//unsigned char L[256]; /* look up table */
//unsigned long DataKey; /* data encryption key */
static
void kstep(void);
static
unsigned char keygen(void);
 unsigned long DataKey_Generation(void) /*datakey*/
{
int i;
unsigned long temp;
A=0;
for(i=0; i<4; i++)
A = (A<<8) + (unsigned long)SSD_B[i];
B=0;
for(i=4; i<8; i++)
B = (B<<8) + (unsigned long)SSD_B[i];
K=A^B;
for(i=0; i<256; i++)
{
kstep();
L[i] = high(K);
}
for(i=0; i<32; i++)
{
temp = (unsigned long)keygen();
A = (A<<9) + temp;
temp = (unsigned long)keygen();
B = (B<<9) + temp;
temp = (unsigned long)keygen();
K = (0xff00ffffU & K) + (temp << 16);
K &= 0xffff00ffU + (temp<<8);
}
return ( (A^B^K)& 0xffffffff );
}
static
unsigned char keygen(void)
{
unsigned char x;
int i, trips;
kstep();
/*
* if high bit of K set, use A1 feedback
* otherwise use A2 feedback
*/
if((1UL<<31) & A)
{
A+=A;
if((1UL<<31) & K)
A=A^ FA1;
else
A=A^ FA2;
}
else
A+=A;
/*
* if next-high bit of K set, step B twice
* otherwise once
*/
if((1UL<<30) & K)
trips = 2;
else
trips = 1;
for(i=0; i<trips; i++
)
{
if((1UL<<31) & B)
{
B+=B;
B=B^FB;
}
else
B+=B;
}
x = high(K) + L[high(A)] + L[high(B)];
x &= 0xffU; /* use only 8 bits */
return x;
}
/*
* step the K register
*/
static
void kstep(void)
{
if(K==0) K = 0x31415926;
if(K&1)
{
K = (K>>1) ^ FK;
}
else
{
K = (K>>1);
}
K &= 0xffffffff;
}
///////////////////////////////////////////////
void LTable_Generation(//const
					   unsigned char RAND[4]) /*L*/
{int i,j;
 unsigned char tempc;

 K = 0;
for(i=0; i<4; i++)
 K = (K<<8) + (unsigned long)RAND[i];
 for (i=0; i<256; i++)
 L[i] = (unsigned char)i;

 /* use high octet of K to permute 0 through 255 */
 for (i=0; i< 256; i++)
 {
 kstep();
 j = high(K);
 tempc = L[i];
 L[i] = L[j];
 L[j] = tempc;
 }
 }
////////////////////////////////////////////////
void Data_Mask(//const 
			   unsigned long DataKey,/*mask*/
//const
 unsigned long HOOK,
 //const
 int len,
 unsigned char mask[] )
{
 int i;

 K = (unsigned long)L[HOOK&0xff];
 K += ((unsigned long)L[((HOOK>>8)+HOOK)&0xff])<<8;
 K += ((unsigned long)L[((HOOK>>16)+HOOK)&0xff])<<16;
 K += ((unsigned long)L[((HOOK>>24)+HOOK)&0xff])<<24;
 kstep();
 A = DataKey ^ K; /* kstep() is defined in Exhibit 2-45 */
 kstep();
 B = DataKey ^ K;
 kstep(); 
 K = DataKey ^ K;

 for(i=0; i<len; i++)
mask[i] = keygen(); /* keygen() is defined in Exhibit 2-45 */
}