├── README.md
└── src
    ├── yao
        ├── CryptChain.java
        ├── Main.java
        ├── Transfer.java
        ├── Utils.java
        └── gate
        │   ├── AndGate.java
        │   ├── Gate.java
        │   ├── GenericGate.java
        │   ├── OrGate.java
        │   ├── Wire.java
        │   └── XorGate.java
    └── yao4
        └── gate
            ├── AndGate.java
            ├── Gate.java
            ├── GenericGate.java
            ├── OrGate.java
            ├── Wire.java
            └── XorGate.java


/README.md:
--------------------------------------------------------------------------------
 1 | Introduction
 2 | ============
 3 | 
 4 | The classic approach of secure function evaluation (SFE) also deals with encrypted programs but is often based on Yao’s Garbled Circuits. The concept of garbled circuits is an alternative to homomorphically encrypted function representations and is currently considered the most effective way to hide program functionality. In contrast to FHE encryted data, garbled circuits encrypt the function tables of boolean gates. The input values are used as row and column keys to decrypt the output value of the gates. Garbled circuits only support one pass directed, acyclic circuits.
 5 | 
 6 | The Java-based sample implementation uses AES to encrypt the function tables and supports delegation only, i.e. the untrusted party is not allowed to input it’s own data which the first party encrypts during an oblivious transfer protocol.
 7 | 
 8 | 
 9 | License
10 | =======
11 | 
12 | The source code is published under a MIT license:
13 | 
14 | Copyright © 2011
15 | 
16 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
17 | 
18 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
19 | 
20 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/src/yao/CryptChain.java:
--------------------------------------------------------------------------------
 1 | package yao;
 2 | 
 3 | import java.security.KeyPair;
 4 | 
 5 | import yao.gate.Gate;
 6 | import yao.gate.Wire;
 7 | import yao.gate.XorGate;
 8 | 
 9 | public class CryptChain 
10 | {
11 | 	
12 | 	
13 | 	public static void main(String[] args) throws Exception
14 | 	{
15 | 		KeyPair kp=Utils.genRSAkeypair();
16 | 		
17 | 		Wire a1=new Wire();
18 | 		Wire a2=new Wire();
19 | 		Wire ra=new Wire();
20 | 		Gate g1=new XorGate(a1,a2,ra);
21 | 		
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/src/yao/Main.java:
--------------------------------------------------------------------------------
  1 | package yao;
  2 | 
  3 | import yao.gate.AndGate;
  4 | import yao.gate.Gate;
  5 | import yao.gate.Wire;
  6 | import yao.gate.XorGate;
  7 | 
  8 | public class Main 
  9 | {
 10 | 	public static void main(String [] args) throws Exception
 11 | 	{
 12 | 		new Main()._main();
 13 | 	}
 14 | 	
 15 | 	void _main() throws Exception
 16 | 	{
 17 | 		/* PHASE A: CONSTRUCTION (on trusted resource) 
 18 | 		 * ===========================================*/
 19 | 		
 20 | 		/* (a1 XOR a2) XOR (b1 AND b2)
 21 | 		 * 
 22 | 		 * ra=a1 XOR a2
 23 | 		 * rb=b1 AND b2
 24 | 		 * r =ra XOR rb
 25 | 		 * 
 26 | 		 */
 27 | 		
 28 | 		Wire a1=new Wire();
 29 | 		Wire a2=new Wire();
 30 | 		Wire b1=new Wire();
 31 | 		Wire b2=new Wire();
 32 | 		Wire ra=new Wire();
 33 | 		Wire rb=new Wire();
 34 | 		Wire r=new Wire(3);
 35 | 		
 36 | 		Gate g1=new XorGate(a1,a2,ra);
 37 | 		Gate g2=new AndGate(b1,b2,rb);
 38 | 		Gate g3=new XorGate(ra,rb,r);
 39 | 		
 40 | 		/* ship the luts and input wires
 41 | 		 * to the untrusted evaluator
 42 | 		 * 
 43 | 		 * we want him to execute (1 XOR 0) XOR (1 AND 1)
 44 | 		 */
 45 | 		byte[][] lut_g1=g1.getLut();
 46 | 		byte[][] lut_g2=g2.getLut();
 47 | 		byte[][] lut_g3=g3.getLut();
 48 | 		byte[] in_a1=a1.getValue1();
 49 | 		byte[] in_a2=a2.getValue0();
 50 | 		byte[] in_b1=b1.getValue1();
 51 | 		byte[] in_b2=b2.getValue1();
 52 | 		
 53 | 		/* PHASE T: TRANSPORT-FORMAT
 54 | 		 * =========================*/
 55 | 		
 56 | 		Utils.printLut(g1, "g1");
 57 | 		Utils.printLut(g2, "g2");
 58 | 		Utils.printLut(g3, "g3");
 59 | 		System.out.println("in_a1:"+Utils.getHex(in_a1));
 60 | 		System.out.println("in_a2:"+Utils.getHex(in_a2));
 61 | 		System.out.println("in_b1:"+Utils.getHex(in_b1));
 62 | 		System.out.println("in_b2:"+Utils.getHex(in_b2));
 63 | 		
 64 | 		
 65 | 		/* PHASE B: EVALUATE (on untrusted resource) 
 66 | 		 * =========================================*/
 67 | 		
 68 | 		//notice that the evaluator instantiates untyped gates
 69 | 		Gate gate1=new Gate(lut_g1);
 70 | 		Gate gate2=new Gate(lut_g2);
 71 | 		Gate gate3=new Gate(lut_g3);
 72 | 				
 73 | 		byte[] r1=gate1.operate(in_a2, in_a1);
 74 | 		byte[] r2=gate2.operate(in_b2, in_b1);
 75 | 		byte[] r3=gate3.operate(r2, r1);
 76 | 		System.out.println("encrypted result="+Utils.getHex(r3));
 77 | 		
 78 | 		/* PHASE C: RESULT DECRYPTION (on trustes resource)
 79 | 		 * ================================================*/
 80 | 		
 81 | 		if(Utils.arraysAreEqual(r3,r.getValue0()))
 82 | 			System.out.println("result is 0");
 83 | //		else if(Utils.arraysAreEqual(r3,r.getValue0()))
 84 | //			System.out.println("result is 0");
 85 | 		else if(Utils.arraysAreEqual(r3,r.getValue1()))
 86 | 			System.out.println("result is 1");
 87 | //		else if(Utils.arraysAreEqual(r3,r.getValue1()))
 88 | //			System.out.println("result is 1");
 89 | 		else
 90 | 			System.out.println("result is undefined");
 91 | 		
 92 | //		KeyPair kp=Utils.genRSAkeypair();
 93 | //		
 94 | //		byte[] secret=new byte[]{0x12,0x34,0x56,0x78};
 95 | //		
 96 | //		byte[] cipher=Utils.RSAencrypt(secret, kp.getPublic());
 97 | //		
 98 | //		System.out.println("RSA encrypted="+Utils.getHex(cipher));
 99 | //		
100 | //		secret=Utils.RSAdecrypt(cipher, kp.getPrivate());
101 | //		
102 | //		System.out.println("RSA decrypted="+Utils.getHex(secret));
103 | //		
104 | //		new Transfer().exchange();
105 | 		
106 | 		
107 | 	}
108 | }
109 | 


--------------------------------------------------------------------------------
/src/yao/Transfer.java:
--------------------------------------------------------------------------------
 1 | package yao;
 2 | 
 3 | import java.math.BigInteger;
 4 | import java.security.KeyFactory;
 5 | import java.security.KeyPair;
 6 | import java.security.PrivateKey;
 7 | import java.security.PublicKey;
 8 | import java.security.spec.RSAPrivateKeySpec;
 9 | import java.security.spec.RSAPublicKeySpec;
10 | import java.util.Random;
11 | 
12 | public class Transfer 
13 | {
14 | 	Random rand=new Random();
15 | 	
16 | 	public void exchange() throws Exception
17 | 	{
18 | 		KeyPair keypair=Utils.genRSAkeypair();
19 | 		KeyFactory fact = KeyFactory.getInstance("RSA");
20 | 		
21 | 		PrivateKey 			Alice_privatekey=keypair.getPrivate();
22 | 		RSAPrivateKeySpec 	Alice_priv=fact.getKeySpec(Alice_privatekey,RSAPrivateKeySpec.class);
23 | 		BigInteger 			Alice_N=Alice_priv.getModulus();
24 | 		BigInteger 			Alice_d=Alice_priv.getPrivateExponent();
25 | 		System.out.println("Alice_d="+Alice_d.toString(10));
26 | 		BigInteger 			Alice_m0=new BigInteger("12345",10);
27 | 		BigInteger 			Alice_m1=new BigInteger("67890",10);
28 | 		BigInteger 			Alice_x0=new BigInteger(1024,rand);
29 | 		BigInteger		 	Alice_x1=new BigInteger(1024,rand);
30 | 		
31 | 		PublicKey 			Bob_publickey=keypair.getPublic();
32 | 		RSAPublicKeySpec 	Bob_pub = fact.getKeySpec(Bob_publickey,RSAPublicKeySpec.class);
33 | 		BigInteger 			Bob_N=Bob_pub.getModulus();
34 | 		BigInteger 			Bob_e=Bob_pub.getPublicExponent();
35 | 		
36 | 		System.out.println("Bob_e="+Bob_e.toString(10));
37 | 		BigInteger 			Bob_x0=Alice_x0;
38 | 		BigInteger 			Bob_x1=Alice_x1;
39 | 		
40 | 		BigInteger 			Bob_secretx=Bob_x1; //wir wollen m1 haben
41 | 		BigInteger			Bob_k=new BigInteger(1024,rand);
42 | 		BigInteger 			Bob_v=Bob_secretx.add(Bob_k.pow(Bob_e.intValue())).mod(Bob_N); 
43 | 		
44 | 		BigInteger 			Alice_v=Bob_v;
45 | 		
46 | 		
47 | 	
48 | 	}
49 | }
50 | 


--------------------------------------------------------------------------------
/src/yao/Utils.java:
--------------------------------------------------------------------------------
  1 | package yao;
  2 | 
  3 | import java.security.KeyPair;
  4 | import java.security.KeyPairGenerator;
  5 | import java.security.MessageDigest;
  6 | import java.security.PrivateKey;
  7 | import java.security.PublicKey;
  8 | 
  9 | import javax.crypto.Cipher;
 10 | import javax.crypto.KeyGenerator;
 11 | import javax.crypto.SecretKey;
 12 | import javax.crypto.spec.SecretKeySpec;
 13 | 
 14 | import yao.gate.Gate;
 15 | 
 16 | public class Utils 
 17 | {
 18 | 	public static void swap(byte[] a,byte[] b)
 19 | 	{
 20 | 		byte[] h;
 21 | 		h=a;
 22 | 		a=b;
 23 | 		b=h;
 24 | 	}
 25 | 	
 26 | 	public static void printLut(Gate gate,String title)
 27 | 	{
 28 | 		System.out.println(title);
 29 | 		for(int i=0;i<4;i++)
 30 | 		{
 31 | 			System.out.println(getHex(gate.getLutEntry(i)));
 32 | 		}
 33 | 		System.out.println();
 34 | 	}
 35 | 	
 36 | 	public static String getHex(byte[] b)
 37 | 	{
 38 | 		String result="";
 39 | 		for(int j=0;j<b.length;j++)
 40 | 		{
 41 | 			String hex="0"+Integer.toHexString(b[j]&255);
 42 | 			result+=hex.substring(hex.length()-2);
 43 | 		}
 44 | 		return result;
 45 | 	}
 46 | 	
 47 | 	public static boolean arraysAreEqual(byte[] a,byte[] b)
 48 | 	{
 49 | 		if(a.length!=b.length)
 50 | 			return false;
 51 | 		
 52 | 		for(int i=0;i<a.length;i++)
 53 | 			if(a[i]!=b[i])
 54 | 				return false;
 55 | 		
 56 | 		return true;
 57 | 	}
 58 | 	
 59 | 	public static byte[] genAESkey(int size) throws Exception
 60 | 	{
 61 | 		KeyGenerator kgen = KeyGenerator.getInstance("AES");
 62 | 		kgen.init(size); 
 63 | 		
 64 | 		SecretKey skey = kgen.generateKey();
 65 | 		byte[] raw = skey.getEncoded();
 66 | 		
 67 | 		return raw;
 68 | 	}
 69 | 	public static byte[] AESdecrypt(byte[] encrypted,byte[] key) throws Exception
 70 | 	{
 71 | 		SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");
 72 | 		Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
 73 | 		cipher.init(Cipher.DECRYPT_MODE, skeySpec);
 74 | 		byte[] plain=cipher.doFinal(encrypted);
 75 | 		return plain;
 76 | 	}
 77 | 	
 78 | 	public static byte[] AESencrypt(byte[] plain,byte[] key) throws Exception
 79 | 	{
 80 | 		SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");
 81 | 		Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
 82 | 		cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
 83 | 		byte[] encrypted =cipher.doFinal(plain);
 84 | 		return encrypted;
 85 | 	}
 86 | 	
 87 | 	public static KeyPair genRSAkeypair() throws Exception
 88 | 	{
 89 | 		KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
 90 | 		kpg.initialize(128);
 91 | 		KeyPair kp = kpg.genKeyPair();
 92 | //		Key publicKey = kp.getPublic();
 93 | //		Key privateKey = kp.getPrivate();
 94 | 		return kp;
 95 | 	}
 96 | 	
 97 | 	public static byte[] RSAencrypt(byte[] data,PublicKey key) throws Exception
 98 | 	{		  
 99 | 	  Cipher cipher = Cipher.getInstance("RSA");
100 | 	  cipher.init(Cipher.ENCRYPT_MODE, key);
101 | 	  byte[] cipherData = cipher.doFinal(data);
102 | 	  return cipherData;
103 | 	}
104 | 	
105 | 	public static byte[] RSAdecrypt(byte[] data,PrivateKey key) throws Exception
106 | 	{		  
107 | 	  Cipher cipher = Cipher.getInstance("RSA");
108 | 	  cipher.init(Cipher.DECRYPT_MODE, key);
109 | 	  byte[] cipherData = cipher.doFinal(data);
110 | 	  return cipherData;
111 | 	}
112 | 
113 | 	
114 | 	public void bench(Gate gate1,byte[] in_a1,byte[] in_a2) throws Exception
115 | 	{
116 | 		long start=System.currentTimeMillis();
117 | 		
118 | 		for(int i=0;i<10000;i++)
119 | 			gate1.operate(in_a2, in_a1);
120 | 		
121 | 		System.out.println("10000 operations: "+(System.currentTimeMillis()-start)+" ms");
122 | 		
123 | 		start=System.currentTimeMillis();
124 | 		
125 | 		for(int i=0;i<10000;i++)
126 | 		{
127 | 			for(int j=0;j<4;j++)
128 | 			{
129 | 				Utils.AESdecrypt(gate1.getLutEntry(0),in_a2);
130 | 				Utils.AESdecrypt(gate1.getLutEntry(0),in_a2);
131 | 			}
132 | 		}
133 | 		
134 | 		System.out.println("10000 *4 *2 decryptions: "+(System.currentTimeMillis()-start)+" ms");
135 | 		
136 | 		start=System.currentTimeMillis();
137 | 		
138 | 		for(int i=0;i<10000;i++)
139 | 		{
140 | 			for(int j=0;j<4;j++)
141 | 			{
142 | 				Utils.AESencrypt(gate1.getLutEntry(0),in_a2);
143 | 				Utils.AESencrypt(gate1.getLutEntry(0),in_a2);
144 | 			}
145 | 		}
146 | 		
147 | 		System.out.println("10000 *4 *2 encryptions: "+(System.currentTimeMillis()-start)+" ms");
148 | 		start=System.currentTimeMillis();
149 | 		
150 | 		MessageDigest md = MessageDigest.getInstance( "SHA" );
151 | 		
152 | 		for(int i=0;i<10000;i++)
153 | 		{
154 | 			for(int j=0;j<4;j++)
155 | 			{
156 | 				md.reset();
157 | 				md.update(in_a1);
158 | 				md.update(in_a2);
159 | 		        // md.update( int ) processes only the low order 8-bits. It actually expects an unsigned byte.
160 | 		        md.digest();
161 | 		        
162 | 		        md.reset();
163 | 				md.update(in_a1);
164 | 				md.update(in_a2);
165 | 		        // md.update( int ) processes only the low order 8-bits. It actually expects an unsigned byte.
166 | 		        md.digest();
167 | 			}
168 | 		}
169 | 		System.out.println("10000 *4 *2 hashes: "+(System.currentTimeMillis()-start)+" ms");
170 | 	}
171 | }
172 | 


--------------------------------------------------------------------------------
/src/yao/gate/AndGate.java:
--------------------------------------------------------------------------------
 1 | package yao.gate;
 2 | 
 3 | 
 4 | public class AndGate extends Gate
 5 | {
 6 | 	public AndGate(Wire i1,Wire i2,Wire r) throws Exception
 7 | 	{  
 8 | 		genEncryptedLut(0,0,0,1,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao/gate/Gate.java:
--------------------------------------------------------------------------------
  1 | package yao.gate;
  2 | 
  3 | import java.util.Random;
  4 | 
  5 | import yao.Utils;
  6 | 
  7 | public class Gate 
  8 | {
  9 | 	byte[][] lut=new byte[4][];
 10 | 	
 11 | 	public Gate(){}
 12 | 	
 13 | 	public Gate(byte[] l1,byte[] l2,byte[] l3,byte[] l4)
 14 | 	{
 15 | 		lut[0]=l1;
 16 | 		lut[1]=l2;
 17 | 		lut[2]=l3;
 18 | 		lut[3]=l4;
 19 | 	}
 20 | 	
 21 | 	public Gate(byte[][] lut)
 22 | 	{
 23 | 		this.lut=lut;
 24 | 	}
 25 | 	
 26 | 	public byte[] operate(byte[] key1, byte[] key2) throws Exception
 27 | 	{
 28 | 		byte[] result1=null;
 29 | 		byte[] result2=null;
 30 | 		
 31 | 		for(int i=0;i<4;i++)
 32 | 		{
 33 | 			result1=Utils.AESdecrypt(lut[i],key1);
 34 | 			result2=Utils.AESdecrypt(result1,key2);
 35 | 			
 36 | 			if(result2[0]==0x12&&result2[1]==0x33&&result2[2]==0x21)
 37 | 				return result2;
 38 | 		}
 39 | 		
 40 | 		return null;
 41 | 	}
 42 | 	
 43 | 	/*
 44 | 	 * generate an encrypted lookup-table
 45 | 	 * ==================================
 46 | 	 * 
 47 | 	 * i-wires are inputs, r-wire is the result
 48 | 	 * 
 49 | 	 * the table consists of entries that hold output values taken
 50 | 	 * from the r-wire values. this function can generate arbitrary
 51 | 	 * function tables, just call with 0's and 1's according to the
 52 | 	 * following table and the function picks the corresponding
 53 | 	 * wire ciphers
 54 | 	 * 
 55 | 	 * LUT  | i1.0   i1.1 
 56 | 	 * -------------------
 57 | 	 * i2.0 | 0:i00  1:i01
 58 | 	 *      |
 59 | 	 * i2.1 | 2:i10  3:i11
 60 | 	 * 
 61 | 	 * colums keys: i1.0,i1.1
 62 | 	 * row keys:    i2.0,i2.1
 63 | 	 *
 64 | 	 * 
 65 | 	 * examples:
 66 | 	 * 
 67 | 	 * AND: genEncryptedLut(0,0,0,1,i1,i2,r)
 68 | 	 * XOR: genEncryptedlut(0,1,1,0,i1,i2,r)
 69 | 	 *  OR: genEncryptedlut(0,1,1,1,i1,i2,r)
 70 | 	 * 
 71 | 	 * each entry is encrypted with its column- and row-key (in that
 72 | 	 * order):
 73 | 	 * 
 74 | 	 * lut[0]=encrypt(encrypt(entry,key_i1.0),key_i2.0)
 75 | 	 * lut[1]=encrypt(encrypt(entry,key_i1.1),key_i2.0)
 76 | 	 * lut[2]=encrypt(encrypt(entry,key_i1.0),key_i2.1)
 77 | 	 * lut[3]=encrypt(encrypt(entry,key_i1.1),key_i2.1)
 78 | 	 * 
 79 | 	 */
 80 | 	void genEncryptedLut(int i00,int i01,int i10,int i11,Wire i1, Wire i2, Wire r) throws Exception
 81 | 	{	
 82 | 		//encrypt
 83 | 		lut[0]=Utils.AESencrypt(Utils.AESencrypt(r.value[i00],i1.value[0]),i2.value[0]);
 84 | 		lut[1]=Utils.AESencrypt(Utils.AESencrypt(r.value[i01],i1.value[1]),i2.value[0]);
 85 | 		lut[2]=Utils.AESencrypt(Utils.AESencrypt(r.value[i10],i1.value[0]),i2.value[1]);
 86 | 		lut[3]=Utils.AESencrypt(Utils.AESencrypt(r.value[i11],i1.value[1]),i2.value[1]);
 87 | 		
 88 | 		//shuffle
 89 | 		Random rand=new Random();
 90 | 		if(rand.nextBoolean())
 91 | 			Utils.swap(lut[0],lut[1]);
 92 | 		if(rand.nextBoolean())
 93 | 			Utils.swap(lut[2],lut[3]);
 94 | 		if(rand.nextBoolean())
 95 | 			Utils.swap(lut[0],lut[2]);
 96 | 		if(rand.nextBoolean())
 97 | 			Utils.swap(lut[1],lut[3]);
 98 | 	}
 99 | 	
100 | 	public byte[] getLutEntry(int i)
101 | 	{
102 | 		return lut[i];
103 | 	}
104 | 	
105 | 	public byte[][] getLut()
106 | 	{
107 | 		return lut;
108 | 	}
109 | 
110 | }
111 | 


--------------------------------------------------------------------------------
/src/yao/gate/GenericGate.java:
--------------------------------------------------------------------------------
 1 | package yao.gate;
 2 | 
 3 | 
 4 | public class GenericGate extends Gate 
 5 | {
 6 | 	public GenericGate(Wire i1,Wire i2,Wire r,int i00,int i01,int i10,int i11) throws Exception
 7 | 	{  
 8 | 		genEncryptedLut(i00,i01,i10,i11,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao/gate/OrGate.java:
--------------------------------------------------------------------------------
 1 | package yao.gate;
 2 | 
 3 | 
 4 | public class OrGate extends Gate 
 5 | {
 6 | 	public OrGate(Wire i1,Wire i2,Wire r) throws Exception
 7 | 	{  
 8 | 		genEncryptedLut(0,1,1,1,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao/gate/Wire.java:
--------------------------------------------------------------------------------
 1 | package yao.gate;
 2 | 
 3 | import javax.crypto.KeyGenerator;
 4 | import javax.crypto.SecretKey;
 5 | 
 6 | public class Wire 
 7 | {
 8 | 	public static final int AES_KEYLENGTH=128;
 9 | 	byte[][] value=new byte[2][0];
10 | 	
11 | 	public Wire() throws Exception
12 | 	{
13 | 		KeyGenerator kgen = KeyGenerator.getInstance("AES");
14 | 		kgen.init(AES_KEYLENGTH); 
15 | 		SecretKey skey = kgen.generateKey();
16 | 		value[0]=skey.getEncoded();
17 | 		skey = kgen.generateKey();
18 | 		value[1]=skey.getEncoded();
19 | 		
20 | 		value[0][0]=0x12;value[0][1]=0x33;value[0][2]=0x21;
21 | 		value[1][0]=0x12;value[1][1]=0x33;value[1][2]=0x21;
22 | 	}
23 | 	
24 | 	public Wire(int plaintextmask)
25 | 	{
26 | 		if((plaintextmask&1)==1)
27 | 			value[0]=new byte[]{0x12,0x33,0x21,0,0,0,0,0,0,0,0,0,0,0,0,0};
28 | 		if((plaintextmask&2)==2)
29 | 			value[1]=new byte[]{0x12,0x33,0x21,1,1,1,1,1,1,1,1,1,1,1,1,1};
30 | 		
31 | 	}
32 | 	
33 | 	public byte[] getValue0()
34 | 	{
35 | 		return value[0];
36 | 	}
37 | 	
38 | 	public byte[] getValue1()
39 | 	{
40 | 		return value[1];
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/src/yao/gate/XorGate.java:
--------------------------------------------------------------------------------
 1 | package yao.gate;
 2 | 
 3 | 
 4 | public class XorGate extends Gate
 5 | {
 6 | 	public XorGate(Wire i1,Wire i2,Wire r) throws Exception
 7 | 	{
 8 | 		genEncryptedLut(0,1,1,0,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao4/gate/AndGate.java:
--------------------------------------------------------------------------------
 1 | package yao4.gate;
 2 | 
 3 | 
 4 | public class AndGate extends Gate
 5 | {
 6 | 	public AndGate(Wire i1,Wire i2,Wire r) throws Exception
 7 | 	{  
 8 | 		genEncryptedLut(0,0,0,1,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao4/gate/Gate.java:
--------------------------------------------------------------------------------
  1 | package yao4.gate;
  2 | 
  3 | import java.util.Random;
  4 | 
  5 | import yao.Utils;
  6 | 
  7 | public class Gate 
  8 | {
  9 | 	byte[][] lut=new byte[16][];
 10 | 	
 11 | 	public Gate(){}
 12 | 	
 13 | 	public Gate(byte[] l1,byte[] l2,byte[] l3,byte[] l4,
 14 | 				byte[] l5,byte[] l6,byte[] l7,byte[] l8,
 15 | 				byte[] l9,byte[] l10,byte[] l11,byte[] l12,
 16 | 				byte[] l13,byte[] l14,byte[] l15,byte[] l16)
 17 | 	{
 18 | 		lut[0]=l1;
 19 | 		lut[1]=l2;
 20 | 		lut[2]=l3;
 21 | 		lut[3]=l4;
 22 | 		lut[4]=l5;
 23 | 		lut[5]=l6;
 24 | 		lut[6]=l7;
 25 | 		lut[7]=l8;
 26 | 		lut[8]=l9;
 27 | 		lut[9]=l10;
 28 | 		lut[10]=l11;
 29 | 		lut[11]=l12;
 30 | 		lut[12]=l13;
 31 | 		lut[13]=l14;
 32 | 		lut[14]=l15;
 33 | 		lut[15]=l16;
 34 | 	}
 35 | 	
 36 | 	public Gate(byte[][] lut)
 37 | 	{
 38 | 		this.lut=lut;
 39 | 	}
 40 | 	
 41 | 	public byte[] operate(byte[] key1, byte[] key2) throws Exception
 42 | 	{
 43 | 		byte[] result1=null;
 44 | 		byte[] result2=null;
 45 | 		
 46 | 		for(int i=0;i<16;i++)
 47 | 		{
 48 | 			result1=Utils.AESdecrypt(lut[i],key1);
 49 | 			result2=Utils.AESdecrypt(result1,key2);
 50 | 			
 51 | 			if(result2[0]==0x12&&result2[1]==0x33&&result2[2]==0x21)
 52 | 				return result2;
 53 | 		}
 54 | 		
 55 | 		return null;
 56 | 	}
 57 | 	
 58 | 	/*
 59 | 	 * generate an encrypted lookup-table
 60 | 	 * ==================================
 61 | 	 * 
 62 | 	 * i-wires are inputs, r-wire is the result
 63 | 	 * 
 64 | 	 * the table consists of entries that hold output values taken
 65 | 	 * from the r-wire values. this function can generate arbitrary
 66 | 	 * function tables, just call with 0's and 1's according to the
 67 | 	 * following table and the function picks the corresponding
 68 | 	 * wire ciphers
 69 | 	 * 
 70 | 	 * LUT  | i1.0   i1.1 
 71 | 	 * -------------------
 72 | 	 * i2.0 | 0:i00  1:i01
 73 | 	 *      |
 74 | 	 * i2.1 | 2:i10  3:i11
 75 | 	 * 
 76 | 	 * colums keys: i1.0,i1.1
 77 | 	 * row keys:    i2.0,i2.1
 78 | 	 *
 79 | 	 * 
 80 | 	 * examples:
 81 | 	 * 
 82 | 	 * AND: genEncryptedLut(0,0,0,1,i1,i2,r)
 83 | 	 * XOR: genEncryptedlut(0,1,1,0,i1,i2,r)
 84 | 	 *  OR: genEncryptedlut(0,1,1,1,i1,i2,r)
 85 | 	 * 
 86 | 	 * each entry is encrypted with its column- and row-key (in that
 87 | 	 * order):
 88 | 	 * 
 89 | 	 * lut[0]=encrypt(encrypt(entry,key_i1.0),key_i2.0)
 90 | 	 * lut[1]=encrypt(encrypt(entry,key_i1.1),key_i2.0)
 91 | 	 * lut[2]=encrypt(encrypt(entry,key_i1.0),key_i2.1)
 92 | 	 * lut[3]=encrypt(encrypt(entry,key_i1.1),key_i2.1)
 93 | 	 * 
 94 | 	 */
 95 | 	
 96 | 	void genEncryptedLut(int i00,int i01,int i10,int i11,Wire i1, Wire i2, Wire r) throws Exception
 97 | 	{	
 98 | 		Random rnd=new Random();
 99 | 		//encrypt
100 | 		lut[0]=Utils.AESencrypt(Utils.AESencrypt(r.value[i00],i1.getValue0(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
101 | 		lut[1]=Utils.AESencrypt(Utils.AESencrypt(r.value[i00],i1.getValue0(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
102 | 		lut[4]=Utils.AESencrypt(Utils.AESencrypt(r.value[i00],i1.getValue0(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
103 | 		lut[5]=Utils.AESencrypt(Utils.AESencrypt(r.value[i00],i1.getValue0(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
104 | 		
105 | 		lut[2]=Utils.AESencrypt(Utils.AESencrypt(r.value[i01],i1.getValue0(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
106 | 		lut[3]=Utils.AESencrypt(Utils.AESencrypt(r.value[i01],i1.getValue0(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
107 | 		lut[6]=Utils.AESencrypt(Utils.AESencrypt(r.value[i01],i1.getValue0(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
108 | 		lut[7]=Utils.AESencrypt(Utils.AESencrypt(r.value[i01],i1.getValue0(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
109 | 			
110 | 		lut[8]=Utils.AESencrypt(Utils.AESencrypt(r.value[i10],i1.getValue1(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
111 | 		lut[9]=Utils.AESencrypt(Utils.AESencrypt(r.value[i10],i1.getValue1(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
112 | 		lut[12]=Utils.AESencrypt(Utils.AESencrypt(r.value[i10],i1.getValue1(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
113 | 		lut[13]=Utils.AESencrypt(Utils.AESencrypt(r.value[i10],i1.getValue1(rnd.nextInt(2))),i2.getValue0(rnd.nextInt(2)));
114 | 		
115 | 		lut[10]=Utils.AESencrypt(Utils.AESencrypt(r.value[i11],i1.getValue1(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
116 | 		lut[11]=Utils.AESencrypt(Utils.AESencrypt(r.value[i11],i1.getValue1(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
117 | 		lut[14]=Utils.AESencrypt(Utils.AESencrypt(r.value[i11],i1.getValue1(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
118 | 		lut[15]=Utils.AESencrypt(Utils.AESencrypt(r.value[i11],i1.getValue1(rnd.nextInt(2))),i2.getValue1(rnd.nextInt(2)));
119 | 
120 | 		
121 | 		
122 | 		//shuffle
123 | 		for(int i=0;i<16;i++)
124 | 		{
125 | 			int s1=rnd.nextInt(16);
126 | 			int s2=rnd.nextInt(16);
127 | 			if(s1!=s2)
128 | 				Utils.swap(lut[s1], lut[s2]);
129 | 		}
130 | 	}
131 | 	
132 | 	public byte[] getLutEntry(int i)
133 | 	{
134 | 		return lut[i];
135 | 	}
136 | 	
137 | 	public byte[][] getLut()
138 | 	{
139 | 		return lut;
140 | 	}
141 | 
142 | }
143 | 


--------------------------------------------------------------------------------
/src/yao4/gate/GenericGate.java:
--------------------------------------------------------------------------------
 1 | package yao4.gate;
 2 | 
 3 | 
 4 | public class GenericGate extends Gate 
 5 | {
 6 | 	public GenericGate(Wire i1,Wire i2,Wire r,int i00,int i01,int i10,int i11) throws Exception
 7 | 	{  
 8 | 		genEncryptedLut(i00,i01,i10,i11,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao4/gate/OrGate.java:
--------------------------------------------------------------------------------
 1 | package yao4.gate;
 2 | 
 3 | 
 4 | public class OrGate extends Gate 
 5 | {
 6 | 	public OrGate(Wire i1,Wire i2,Wire r) throws Exception
 7 | 	{  
 8 | 		genEncryptedLut(0,1,1,1,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/yao4/gate/Wire.java:
--------------------------------------------------------------------------------
 1 | package yao4.gate;
 2 | 
 3 | import javax.crypto.KeyGenerator;
 4 | import javax.crypto.SecretKey;
 5 | 
 6 | public class Wire 
 7 | {
 8 | 	public static final int AES_KEYLENGTH=128;
 9 | 	byte[][] value=new byte[4][0];
10 | 	
11 | 	public Wire() throws Exception
12 | 	{
13 | 		KeyGenerator kgen = KeyGenerator.getInstance("AES");
14 | 		kgen.init(AES_KEYLENGTH); 
15 | 		SecretKey skey = kgen.generateKey();
16 | 		value[0]=skey.getEncoded();
17 | 		skey = kgen.generateKey();
18 | 		value[1]=skey.getEncoded();
19 | 		skey = kgen.generateKey();
20 | 		value[2]=skey.getEncoded();
21 | 		skey = kgen.generateKey();
22 | 		value[3]=skey.getEncoded();
23 | 		
24 | 		value[0][0]=0x12;value[0][1]=0x33;value[0][2]=0x21;
25 | 		value[1][0]=0x12;value[1][1]=0x33;value[1][2]=0x21;
26 | 		value[2][0]=0x12;value[2][1]=0x33;value[2][2]=0x21;
27 | 		value[3][0]=0x12;value[3][1]=0x33;value[3][2]=0x21;
28 | 	}
29 | 	
30 | 	public byte[] getValue0(int i)
31 | 	{
32 | 		return value[0+i];
33 | 	}
34 | 	
35 | 	public byte[] getValue1(int i)
36 | 	{
37 | 		return value[2+i];
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/src/yao4/gate/XorGate.java:
--------------------------------------------------------------------------------
 1 | package yao4.gate;
 2 | 
 3 | 
 4 | public class XorGate extends Gate
 5 | {
 6 | 	public XorGate(Wire i1,Wire i2,Wire r) throws Exception
 7 | 	{
 8 | 		genEncryptedLut(0,1,1,0,i1,i2,r);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------