/////// Feistel Cipher Algorithm  (most common symmetric encyption algorithm)

// round function: takes 32bit half xor with key at offset,
// which tells it to use the ith version of the key. boolean rev applies
// key offsets in reverse order (for decryption)

// Max KEYSIZE is 128 because OFFSET array is an array of signed bytes.

public class Feistel
 {

    public static int ROUNDS = 4;   //number of roungs in Feistel Cipher
    public static int HALFSIZE = 4;  // in bytes
    public static int BLOCKSIZE = HALFSIZE*2;
    public static int BASESIZE = 124;  // number of random bytes
    public static int KEYSIZE = ROUNDS+BASESIZE;  // number of random bytes     
    // actual key consists of BASESIZE + ROUNDS number of bytes
    // randomize buffer, with each having (byte)max value:

     public static void setsizes(int r, int h, int ks)
     {
	 if (r<1 || h<2 || ks<2) return;
	 ROUNDS = r; HALFSIZE =h; BLOCKSIZE = h*2; BASESIZE=ks;
	 KEYSIZE = ROUNDS+BASESIZE;
     }
     
    public static void randomize(byte[] buf, int max)
    {
	for (int i=0;i<buf.length;i++) buf[i] = (byte)(int)(Math.random()*max);
    }

    // function to copy src to dst, starting at index si in src and di in dst,
    // and of length l bytes, or until end of either buffer
    public static int memcpy(byte[] dst, byte src[], int di, int si, int l)
    {
	while (si<src.length && di<dst.length && l>0)
	    { dst[di++] = src[si++];  l--; }
	return l; // 0 if copy completed
    }

     // instance vars and functions
     byte[] KEY = new byte[BASESIZE];
     byte[] KEYI = new byte[ROUNDS];

     public Feistel()
     {
	randomize(KEY,256);
	randomize(KEYI,BASESIZE);
     }
     public Feistel(byte[] k)
     {
	 if (k.length!=KEYSIZE)
	     throw new RuntimeException("bad key size");
	 memcpy(KEY,k,0,0,BASESIZE);
	 memcpy(KEYI,k,0,BASESIZE,ROUNDS);
	 // force the offsets to be compliant
	 for(int i=0;i<ROUNDS;i++)
	     if (KEYI[i]<0 || KEYI[i]>123) throw new RuntimeException("invalid key");
     }
     public Feistel(byte[] base, byte[] offsets)
     {
	 if (base.length==BASESIZE && offsets.length==ROUNDS)
	     { KEY=base; KEYI = offsets;}
	 else throw new RuntimeException("bad buffer lengths");
     }//constructors

     // The Feistel "rounding" function
    void F(int i, byte[] val, byte[] outbuf, boolean rev)
    {
      // for the ith key: lookup starting bit index in KEYI, then align i with
      // KEY[i] and bitwise xor:
      int si = KEYI[i];  // starting byte index
      if (rev) si = KEYI[ROUNDS-1-i];
      for(int j=0;j<HALFSIZE;j++)
	  outbuf[j] = (byte)(val[j] ^ KEY[(j+si)%BASESIZE]);
    }//F(i)

     // crypt one block, set rev to false to encrypt, true to decrypt, start at si
     void crypt1(byte[] LR, byte[] out, int si, boolean rev)
     {
	 byte[] Li = new byte[HALFSIZE];
	 byte[] Ri = new byte[HALFSIZE];
	 byte[] Lnext = new byte[HALFSIZE];
	 byte[] Rnext = new byte[HALFSIZE];
	 memcpy(Li,LR,0,si,HALFSIZE);  memcpy(Ri,LR,0,si+HALFSIZE,HALFSIZE);
	 for(int i=0;i<ROUNDS;i++)
	     {
		 memcpy(Lnext,Ri,0,0,HALFSIZE); // Lnext = Ri
		 F(i,Ri,Rnext,rev); // F(Ri,Keyi)  
		 for (int k=0;k<HALFSIZE;k++)
		     Rnext[k] = (byte)(Li[k] ^ Rnext[k]);
		 memcpy(Li,Lnext,0,0,HALFSIZE); memcpy(Ri,Rnext,0,0,HALFSIZE);
	     }
	 memcpy(out,Rnext,si,0,HALFSIZE);
	 memcpy(out,Lnext,si+HALFSIZE,0,HALFSIZE);  //ciphertext is (Rnext,Lnext)
     }//encrypt1

     // crypt M to C 
     public void crypt(byte[] M, byte[] C, boolean rev)
     {
	 if ((M.length % (BLOCKSIZE)) !=0)
	     throw new RuntimeException("bad buffer length");
	 for (int offset=0;offset<M.length;offset+=BLOCKSIZE)
	     {
		 crypt1(M,C,offset,rev);
	     }
     }

     // aliases
     public void encrypt(byte[] M, byte[] C) { crypt(M,C,false); }  
     public void decrypt(byte[] C, byte[] M) { crypt(C,M,true); }     
     // destructive aliases
     public void encrypt(byte[] M) { crypt(M,M,false); }  
     public void decrypt(byte[] C) { crypt(C,C,false); }

     /*// testing the encryption algorithm
    public static void maing(String[] args)
    {   String m = args[0];
	int n = m.length();
	if (n%BLOCKSIZE!=0) n += (BLOCKSIZE - n%BLOCKSIZE); // pad
	byte[] Mbuf = new byte[n];
	byte[] Cbuf = new byte[n];
	byte[] Dbuf = new byte[n];		
	Netutils.StringToBuf(Mbuf,m,0);
	//Feistel.setsizes(ROUNDS,HALFSIZE,BASESIZE);
	Feistel Ft = new Feistel();
	Ft.crypt(Mbuf,Cbuf,false);
	Ft.crypt(Cbuf,Dbuf,true); // decrypt
	String dm = Netutils.bufToString(Dbuf,0,Dbuf.length);
	System.out.println("original: "+dm);
    }// testing encryption algorithm on string m
    */
}// class Feistel 
    
// Program by Chuck Liang, for academic exercise.