pc4.c

/* PC4 Cipher */
/* 49-bit block cipher in ECB Mode for DMR Radio*/
/* by Alexander PUKALL 2015 */
/* Code free for all, even for commercial software */
/* No restriction to use. Public Domain */

/* Use MD2-II */
/* Use Arc4 */
/* Use Splitmix64 */
 
/* PC4 encryption uses key-dependent S-boxes */

/* Key can be hexadecimal or user password */
/* Key size can vary from 8 bits to 2112 bits */

/* PC4 uses 253 encryption rounds */
/* The number of round can be reduced */
/* if the DMR processor is too slow */

/* how to compile : gcc pc4.c -o pc4 */
 
 
#include <stdio.h>
#include <stdint.h>

#define nbround 254 
#define n1 264
short bits[49],temp[49];
uint8_t ptconvert;
uint8_t convert[7];
uint8_t perm[16][256];
uint8_t new1[256];
uint8_t array[49];
uint8_t array2[49];
uint8_t decal[nbround];
uint8_t rngxor[nbround][3];
uint8_t rngxor2[nbround][3];
uint8_t rounds;
uint8_t tab[256];
uint8_t inv[256];
uint8_t permut[3][3]; 
uint64_t bb;
uint64_t x;
uint8_t tot[3];
uint8_t l[2][3],r[2][3];
uint8_t y,totb;
uint32_t result;
uint8_t xyz, count;
uint8_t keys[16]; 
unsigned char array_arc4[256];
int i_arc4,j_arc4;

int x1,x2,i;
unsigned char h2[n1];
unsigned char h1[n1*3];

uint64_t next() {

	uint64_t z = (x += 0x9e3779b97f4a7c15);
	z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
	z = (z ^ (z >> 27)) * 0x94d049bb133111eb;

	return z ^ (z >> 31);
}


void arc4_init(unsigned char key[])

{
       int tmp;
           
       for (i_arc4=0;i_arc4<256;i_arc4++)
       {
          array_arc4[i_arc4]=i_arc4;
       }
       
       
       j_arc4=0;
                 
        for (i_arc4=0;i_arc4<256;i_arc4++)
       {
         j_arc4=(j_arc4+array_arc4[i_arc4]+key[i_arc4%256])%256;
         tmp=array_arc4[i_arc4];
         array_arc4[i_arc4]=array_arc4[j_arc4];
         array_arc4[j_arc4]=tmp;
       }
 
 i_arc4=0;
 j_arc4=0;
}
       
unsigned char arc4_output()

{
       uint8_t rndbyte,decal;
       int tmp, t;

    i_arc4=(i_arc4+1)%256;
    j_arc4=(j_arc4+array_arc4[i_arc4])%256;
    tmp=array_arc4[i_arc4];
    array_arc4[i_arc4]=array_arc4[j_arc4];
    array_arc4[j_arc4]=tmp;
    t=(array_arc4[i_arc4]+array_arc4[j_arc4])%256;

       if (xyz==0) bb=next();
       decal=56-(8*xyz);  
       rndbyte=(bb>>decal)& 0xff;
       xyz++;
       if (xyz==8) xyz=0;
 
    
    if (count==0)
     {
       rndbyte=rndbyte^array_arc4[t];
       count=1;
     }
     else
     {
       rndbyte=rndbyte+array_arc4[t];
       count=0;
     }
     
     
    return(rndbyte);


}


void md2_init()
{
    
   x1 = 0;
   x2 = 0;
    for (i = 0; i < n1; i++)
        h2[i] = 0;
    for (i = 0; i < n1; i++)
        h1[i] = 0;
}

void md2_hashing(unsigned char t1[], size_t b6)
{
    static unsigned char s4[256] = 
    {   13, 199,  11,  67, 237, 193, 164,  77, 115, 184, 141, 222,  73,
        38, 147,  36, 150,  87,  21, 104,  12,  61, 156, 101, 111, 145,
       119,  22, 207,  35, 198,  37, 171, 167,  80,  30, 219,  28, 213,
       121,  86,  29, 214, 242,   6,   4,  89, 162, 110, 175,  19, 157,
         3,  88, 234,  94, 144, 118, 159, 239, 100,  17, 182, 173, 238,
        68,  16,  79, 132,  54, 163,  52,   9,  58,  57,  55, 229, 192,
       170, 226,  56, 231, 187, 158,  70, 224, 233, 245,  26,  47,  32,
        44, 247,   8, 251,  20, 197, 185, 109, 153, 204, 218,  93, 178,
       212, 137,  84, 174,  24, 120, 130, 149,  72, 180, 181, 208, 255,
       189, 152,  18, 143, 176,  60, 249,  27, 227, 128, 139, 243, 253,
        59, 123, 172, 108, 211,  96, 138,  10, 215,  42, 225,  40,  81,
        65,  90,  25,  98, 126, 154,  64, 124, 116, 122,   5,   1, 168,
        83, 190, 131, 191, 244, 240, 235, 177, 155, 228, 125,  66,  43,
       201, 248, 220, 129, 188, 230,  62,  75,  71,  78,  34,  31, 216,
       254, 136,  91, 114, 106,  46, 217, 196,  92, 151, 209, 133,  51,
       236,  33, 252, 127, 179,  69,   7, 183, 105, 146,  97,  39,  15,
       205, 112, 200, 166, 223,  45,  48, 246, 186,  41, 148, 140, 107,
        76,  85,  95, 194, 142,  50,  49, 134,  23, 135, 169, 221, 210,
       203,  63, 165,  82, 161, 202,  53,  14, 206, 232, 103, 102, 195,
       117, 250,  99,   0,  74, 160, 241,   2, 113};
       
    int b1,b2,b3,b4,b5;
   
	b4=0;
    while (b6) {
    
        for (; b6 && x2 < n1; b6--, x2++) {
            b5 = t1[b4++];
            h1[x2 + n1] = b5;
            h1[x2 + (n1*2)] = b5 ^ h1[x2];

            x1 = h2[x2] ^= s4[b5 ^ x1];
        }

        if (x2 == n1)
        {
            b2 = 0;
            x2 = 0;
            
            for (b3 = 0; b3 < (n1+2); b3++) {
                for (b1 = 0; b1 < (n1*3); b1++)
                    b2 = h1[b1] ^= s4[b2];
                b2 = (b2 + b3) % 256;
            }
           }
          }
        }

void md2_end(unsigned char h4[n1])
{
    
    unsigned char h3[n1];
    int i, n4;
    
    n4 = n1 - x2;
    for (i = 0; i < n4; i++) h3[i] = n4;
    md2_hashing(h3, n4);
    md2_hashing(h2, sizeof(h2));
    for (i = 0; i < n1; i++) h4[i] = h1[i];
}

int mixy(int nn2) 
{
int maxo;
maxo = arc4_output();
return (maxo%nn2);
}

void mixer(uint8_t *mixu, int nn) 
{
   int ii, jj, tmmp;
      for (ii = nn - 1; ii > 0; ii--) 
       {
          jj = mixy(ii + 1);
          tmmp = mixu[jj];
          mixu[jj] = mixu[ii];
          mixu[ii] = tmmp;
       }
}

void create_keys(unsigned char key1[], size_t size1)
{
    
     int i,w,k;
     unsigned char h4[n1];
       
	     md2_init();
       md2_hashing(key1, size1);
       md2_end(h4);
       
       for (i=0;i<16;i++) keys[i]=h4[i];
       
       arc4_init(h4);
       
       x=0;
       for (i=0;i<8;i++) x=(x<<8)+(h4[256+i]&0xff);
      
       xyz=0;
       count=0;
              
     for (i=0;i<20000;i++) arc4_output();

      uint8_t numbers[256];
       
     for (w=0;w<16;w++)
      {
         
       k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
        
        for (i = 0; i < 256; i++) {numbers[i]= i;}

       mixer(numbers, 256);

        for ( i = 0; i < 256; i++) 
        {
          perm[w][i]=numbers[i];
        }

      }
    
       k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
    
       for (int i = 0; i < 256; i++) {numbers[i]= i;}

        mixer(numbers, 256);

        for (int i = 0; i < 256; i++) 
        {
          new1[i]=numbers[i];
        }

       k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();

      for (int i = 0; i < 49; i++) {numbers[i]= i;}

        mixer(numbers, 49);

           for (int i = 0; i < 49; i++)
           {
              array[i]=numbers[i];
           }
    
      k=arc4_output()+256;  
      for (i=0;i<k;i++) arc4_output();
       
    for (int i=0;i<nbround;i++) 
    {
      decal[i]=(arc4_output()%23)+1;
    }
    
      k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
       
    for (w=0;w<3;w++)
    {
        for (int i=0;i<nbround;i++)
        {
            rngxor[i][w]=arc4_output();
        }
    }

  k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
       
for (int i = 0; i < 49; i++) {numbers[i]= i;}

        mixer(numbers, 49);

           for (int i = 0; i < 49; i++)
           {
              array2[i]=numbers[i];
           }
   
     k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
       
    for (int i = 0; i < 256; i++) {numbers[i]= i;}

        mixer(numbers, 256);

        for (int i = 0; i < 256; i++) 
        {
          tab[i]=numbers[i];
          inv[tab[i]] = (unsigned char)i;
        }
    
     k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
       
        for (w=0;w<3;w++)
      {
    
       k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
       
        for (i = 0; i < 3; i++) {numbers[i]= i;}

       mixer(numbers, 3);

        for ( i = 0; i < 3; i++) 
        {
          permut[w][i]=numbers[i];
        }
      }
      
         k=arc4_output()+256;  
       for (i=0;i<k;i++) arc4_output();
       
    for (w=0;w<3;w++)
    {
        for (int i=0;i<nbround;i++)
        {
            rngxor2[i][w]=arc4_output();
        }
    }
       
       
  }

uint32_t ror(uint32_t x,int shift,int bits)
    {
                      
    uint32_t m0=(1<<(bits-shift))-1;   
                                  
    uint32_t m1=(1<<shift)-1;         
                                   
    return ((x>>shift)&m0) | ((x&m1)<<(bits-shift));
    }
    
uint32_t rol(uint32_t x,int shift,int bits)
    {
    
                      
    uint32_t m0=(1<<(bits-shift))-1;   
                                   
    uint32_t m1=(1<<shift)-1;          
                                   
    return ((x&m0)<<shift) | ((x>>(bits-shift))&m1);
    }

void compute(uint8_t *tab1, uint8_t round)
{
 tot[0]=(perm[round][tab1[permut[0][0]]]+perm[round][tab1[permut[0][1]]])^perm[round][tab1[permut[0][2]]];
 tot[0]=tot[0]+new1[tot[0]]; 
 tot[1]=(perm[round][tab1[permut[1][0]]]+perm[round][tab1[permut[1][1]]])^perm[round][tab1[permut[1][2]]];
 tot[1]=tot[1]+new1[tot[1]]; 
 tot[2]=(perm[round][tab1[permut[2][0]]]+perm[round][tab1[permut[2][1]]])^perm[round][tab1[permut[2][2]]];
 tot[2]=tot[2]+new1[tot[2]]; 
}

void pc4encrypt()
{
 int i;
 totb=0;
	
  for (int i=0;i<3;i++)
  {
    l[0][i]=convert[i];
    r[0][i]=convert[i+3];
  }


  for (int i=1;i<=rounds;i++) 
  {
       totb=totb^r[(i-1)%2][0];
       totb=totb^r[(i-1)%2][1];
       totb=totb^r[(i-1)%2][2];
       
       r[(i-1)%2][0]=r[(i-1)%2][0] + ((unsigned char)~rngxor2[rounds-i][0]);
       r[(i-1)%2][1]=r[(i-1)%2][1] ^ ((unsigned char)~rngxor2[rounds-i][1]);
       r[(i-1)%2][2]=r[(i-1)%2][2] + ((unsigned char)~rngxor2[rounds-i][2]);
       
       result=0;
       result=result+(r[(i-1)%2][0]<<16);
       result=result+(r[(i-1)%2][1]<<8);
       result=(result+r[(i-1)%2][2]);
        
       result=rol(result,decal[i-1],24);
    
               
       r[(i-1)%2][0]=result>>16;
       r[(i-1)%2][1]=(result>>8)& 0xff;
       r[(i-1)%2][2]=result & 0xff; 
       
       
       r[(i-1)%2][0]=tab[(r[(i-1)%2][0])];
       r[(i-1)%2][0]=r[(i-1)%2][0] ^ rngxor[i-1][0];
       
       r[(i-1)%2][1]=inv[(r[(i-1)%2][1])];
       r[(i-1)%2][1]=r[(i-1)%2][1] - rngxor[i-1][1];
       
       r[(i-1)%2][2]=tab[(r[(i-1)%2][2])];
       r[(i-1)%2][2]=r[(i-1)%2][2] ^ rngxor[i-1][2];
       
       
       compute(r[(i-1)%2],(i-1)%16);

         
       l[i%2][0]=r[(i-1)%2][0];
       r[i%2][0]=l[(i-1)%2][0] -tot[0];
      
       l[i%2][1]=r[(i-1)%2][1]; 
       r[i%2][1]=l[(i-1)%2][1] ^tot[1];
       
       l[i%2][2]=r[(i-1)%2][2]; 
       r[i%2][2]=l[(i-1)%2][2] -tot[2];
             
  }
 

  for (i=0;i<3;i++)
  {
    convert[i+3]=l[(rounds-1)%2][i];
    convert[i]=r[(rounds-1)%2][i];
  }


 totb=totb%2;
 
}

void pc4decrypt()

{
	int i;
  totb=0;
	
	 for (i=0;i<3;i++)
  {
    l[0][i]=convert[i];
    r[0][i]=convert[i+3];
  }
 
  y=(rounds-1)%16;
  if (y==0) y=16;  
         
  for (i=1;i<=rounds;i++)
  {
       y--;
       compute(r[(i-1)%2],y);
       if (y==0) y=16;
     
       result=0;
       
       l[(i-1)%2][0]=l[(i-1)%2][0] ^ rngxor[rounds-i][0];
       l[(i-1)%2][0]=inv[(l[(i-1)%2][0])]; 
       
       l[(i-1)%2][1]=l[(i-1)%2][1] + rngxor[rounds-i][1];
       l[(i-1)%2][1]=tab[(l[(i-1)%2][1])]; 
       
       l[(i-1)%2][2]=l[(i-1)%2][2] ^ rngxor[rounds-i][2];
       l[(i-1)%2][2]=inv[(l[(i-1)%2][2])]; 
       
           
       
       result=result+(l[(i-1)%2][0]<<16);
       result=result+(l[(i-1)%2][1]<<8);
       result=(result+l[(i-1)%2][2]);
  
       result=ror(result,decal[rounds-i],24);
  
         
       l[(i-1)%2][0]=result>>16;
       l[(i-1)%2][1]=(result>>8)& 0xff;
       l[(i-1)%2][2]=result & 0xff;
       
       
       l[(i-1)%2][0]=l[(i-1)%2][0] - ((unsigned char)~rngxor2[i-1][0]);
       l[(i-1)%2][1]=l[(i-1)%2][1] ^ ((unsigned char)~rngxor2[i-1][1]);
       l[(i-1)%2][2]=l[(i-1)%2][2] - ((unsigned char)~rngxor2[i-1][2]);
      
       totb=totb^l[(i-1)%2][0];
       totb=totb^l[(i-1)%2][1];
       totb=totb^l[(i-1)%2][2];
       
       l[i%2][0]=r[(i-1)%2][0]; 
       r[i%2][0]=l[(i-1)%2][0] + tot[0];
       
       l[i%2][1]=r[(i-1)%2][1]; 
       r[i%2][1]=l[(i-1)%2][1] ^ tot[1];
       
       l[i%2][2]=r[(i-1)%2][2]; 
       r[i%2][2]=l[(i-1)%2][2] + tot[2];
     

  }
 

  for (i=0;i<3;i++)
  {
    convert[i+3]=l[(rounds-1)%2][i];
    convert[i]=r[(rounds-1)%2][i];
  }
 
 
  totb=totb%2;
  
}
	
void binhex(short *z, int length){

    short *b;
  b=(short *)z; 
 
    uint8_t i,j;
 
    for(i = 0; i < length; i = j){
        uint8_t a = 0; 
        for(j = i; j < i+8; ++j){ 
            a |= b[((7-(j%8))+j)-(j%8)]<<(j-i); 
        }
       convert[ptconvert]=a;
       ptconvert++;
       
    }           
}

void hexbin(short *q, uint8_t w, uint8_t hex) {
    
       short *bits; 
  bits=(short *)q; 
  
    for (uint8_t i = 0; i < 8; ++i) {
        bits[(7+w)-i] = (hex >> i) & 1;
        
    }
}

void main()
{
	rounds=254;
    
   
    // Plaintext frame // 
    uint8_t frame1[49]={
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,0,0,0,0,0};
	
    uint8_t i,w;
     
       
    // KEY 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01
    unsigned char data[16]={1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 
    
    /* The key creation procedure is very slow, it only needs to be done once */
    /* as long as the user does not change the key. You can encrypt and decrypt */
    /* as many frames as you want without having to recreate the key. */
    
    create_keys(data,16); // KEY creation : key, length of key
    
   printf("\nENCRYPTION PROCESS with key 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01\n"); 
    
      
   for (i=0;i<49;i++) bits[i]=frame1[i];
   
   printf("Plaintext Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);
   
   for (i=0; i<49; i++) temp[i]=bits[array[i]];
   for (i=0; i<49; i++) bits[i]=temp[i];

	ptconvert=0;
  binhex(bits, 48);

	pc4encrypt();

 	for (int q=0;q<6;q++)
	{
	w=q*8;
	hexbin(bits, w,convert[q]);
    }

   bits[48]=bits[48]^totb;
   
   for (i=0; i<49; i++) temp[array2[i]]=bits[i];
   for (i=0; i<49; i++) bits[i]=temp[i];


   printf("\nEncrypted Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);
    
   printf("\n\nDECRYPTION PROCESS with key 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01\n");
   
     
    printf("Encrypted Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);
    
    
   for (i=0; i<49; i++) temp[i]=bits[array2[i]];
   for (i=0; i<49; i++) bits[i]=temp[i];
    
   ptconvert=0;
   binhex(bits, 48);

   pc4decrypt();

  for (int q=0;q<6;q++)
	{
	w=q*8;
	hexbin(bits, w,convert[q]);
    }
    
   bits[48]=bits[48]^totb;
    
   for (i=0; i<49; i++) temp[array[i]]=bits[i];
   for (i=0; i<49; i++) bits[i]=temp[i];

   printf("\nDecrypted Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);


     /*     USER PASSWORD               */
     
     // plaintext frame
      uint8_t frame2[49]={
	0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
	0,0,1,0,0,0,0,0,1};
     
    /* The key creation procedure is very slow, it only needs to be done once */
    /* as long as the user does not change the key. You can encrypt and decrypt */
    /* as many frames as you want without having to recreate the key. */
    
    create_keys("My Top Secret Password!",23); // KEY creation : password, length of password
    
   printf("\n\nENCRYPTION PROCESS with user password 'My Top Secret Password!'\n"); 
   
   for (i=0;i<49;i++) bits[i]=frame2[i];
   
   printf("Plaintext Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);
   
     
   for (i=0; i<49; i++) temp[i]=bits[array[i]];
   for (i=0; i<49; i++) bits[i]=temp[i];

	ptconvert=0;
  binhex(bits, 48);

	pc4encrypt();

 	for (int q=0;q<6;q++)
	{
	w=q*8;
	hexbin(bits, w,convert[q]);
    }

   bits[48]=bits[48]^totb;
   
   for (i=0; i<49; i++) temp[array2[i]]=bits[i];
   for (i=0; i<49; i++) bits[i]=temp[i];


   printf("\nEncrypted Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);
    
   printf("\n\nDECRYPTION PROCESS with user password 'My Top Secret Password!'\n");
   
     
    printf("Encrypted Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);
    
    
   for (i=0; i<49; i++) temp[i]=bits[array2[i]];
   for (i=0; i<49; i++) bits[i]=temp[i];
    
   ptconvert=0;
   binhex(bits, 48);

   pc4decrypt();

  for (int q=0;q<6;q++)
	{
	w=q*8;
	hexbin(bits, w,convert[q]);
    }
   
   bits[48]=bits[48]^totb;
    
   for (i=0; i<49; i++) temp[array[i]]=bits[i];
   for (i=0; i<49; i++) bits[i]=temp[i];

   printf("\nDecrypted Frame :\n");
   for (i=0;i<49;i++) printf("%d",bits[i]);

	printf("\n");


}

/*  
ENCRYPTION PROCESS with key 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01
Plaintext Frame :
0000000000000000000000000000000000000000000000000
Encrypted Frame :
1000110101001100000100001000111011010010001001101

DECRYPTION PROCESS with key 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01
Encrypted Frame :
1000110101001100000100001000111011010010001001101
Decrypted Frame :
0000000000000000000000000000000000000000000000000

ENCRYPTION PROCESS with user password 'My Top Secret Password!'
Plaintext Frame :
0010000001000000001000000000000010000000001000001
Encrypted Frame :
0000011100110010010110111010110010110100000110100

DECRYPTION PROCESS with user password 'My Top Secret Password!'
Encrypted Frame :
0000011100110010010110111010110010110100000110100
Decrypted Frame :
0010000001000000001000000000000010000000001000001
*/