4.16

.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -0,0 +1 @@
+/bin/

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ThinORAM</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

src/nankai/oram/client/MCloudCommInfo.java

@@ -0,0 +1,29 @@
+package nankai.oram.client;
+
+public interface MCloudCommInfo { 
+	
+ 
+//	public static int severBeginLevel = 3;//the default level of each partition in the server
+//	public static int clientEndLevel = 2;//the default level of each partition in the client cache 
+//	public static int evictConditionSize = 8;//1+2+4+8+16=31
+//	public static int cloudNumber = 2; //the cloud number
+	
+//	public static int severBeginLevel = 4;//the default level of each partition in the server
+//	public static int clientEndLevel =3;//the default level of each partition in the client cache 
+//	public static int evictConditionSize = 16;//1+2+4=6
+//	public static int cloudNumber = 2; //the cloud number
+	
+	public static int severBeginLevel = 2;//the default level of each partition in the server
+	public static int clientEndLevel =1;//the default level of each partition in the client cache 
+	public static int evictConditionSize = 4;//1+2+4=6
+	public static int cloudNumber = 2; //the cloud number
+	
+//	public static int severBeginLevel = 5;//the default level of each partition in the server
+//	public static int clientEndLevel = 4;//the default level of each partition in the client cache 
+//	public static int evictConditionSize = 32;//1+2+4+8=15
+//	public static int cloudNumber = 2; //the cloud number
+
+	//public static String[] ip={ "114.215.26.85", "114.215.26.85"}; 
+	public static String[] ip={ "localhost", "localhost"}; 
+	public static int[] port={ 2121, 2122}; 
+}

src/nankai/oram/client/PartitionClient.java

@@ -0,0 +1,280 @@
+package nankai.oram.client;
+ 
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Random;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+
+import nankai.oram.client.common.Position;
+import nankai.oram.client.common.SlotObject;
+import nankai.oram.client.partition.Partition;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.SocketClientUtil;
+import nankai.oram.common.CommandType;
+import nankai.oram.common.ResponseType;
+import nankai.oram.common.Util;
+import nankai.oram.interfaces.ORAM;
+
+
+public class PartitionClient implements ORAM{
+ 
+	boolean initFlag;
+	int N;
+	int n_partitions;
+	int n_capacity;//the max capacity of a partition -- need the top level
+    int n_levels;	
+	int n_blocks;
+	int n_realBlocks_p;//the real number of blocks in a partition  
+	int counter=0;//for sequneceEvict
+	
+	byte s_buffer[][];//shuffule buffer - a large memory 
+	Position pos_map[];//position map
+	
+	/*************************************************/
+	Queue<SlotObject> slots[];
+	Partition partions[];
+
+	
+	SocketClientUtil cli; 
+	
+	
+	
+	public PartitionClient()
+	{ 
+		initFlag=false;
+	    cli=new SocketClientUtil("localhost",2121);
+	}
+	
+	/**
+	 * initialize the parameters, storage space and so on
+	 * @param nN
+	 */
+	public boolean init(int nN)
+	{
+		if (initFlag==true)
+		{
+			System.out.println("have inited!");
+			return false;
+		}
+		N=nN; 
+		n_partitions = (int) Math.ceil(Math.sqrt(nN));
+
+		n_realBlocks_p =   (int) Math.ceil(((double) nN) / n_partitions);
+	    n_blocks = n_realBlocks_p * n_partitions;
+	    
+	    n_levels = (int) (Math.log((double) n_realBlocks_p) / Math.log(2.0)) + 1;
+	    n_capacity = (int) Math.ceil(CommInfo.capacity_parameter * n_realBlocks_p);
+		 
+	    partions=new Partition[n_partitions];
+ 
+	    s_buffer=new byte[n_capacity][CommInfo.blockSize]; 
+	    pos_map=new Position[n_blocks];
+	    for (int i=0;i<n_blocks; i++)
+	    {
+	    	pos_map[i]=new Position();
+	    }
+	    slots=new Queue[n_partitions]; 
+	    
+	    //randomly generate the keys for each level of each partition 
+		for (int i = 0; i < n_partitions; i++)
+		{
+			slots[i]=new LinkedList<SlotObject>();
+			partions[i]=new Partition(N, n_partitions, pos_map, s_buffer, cli); 
+		}
+					
+	    counter = 0; 
+	    
+	    initFlag=true;
+	    return true;
+	}
+	
+	public void openConnection()
+	{
+		cli.connect();
+	}
+	public void closeConnection()
+	{
+		cli.disConnect();
+	}
+	
+	public boolean initORAM()
+	{
+		byte cmd[]=new byte[5]; 
+		cmd[0]=CommandType.initORAM;
+		Util.intToByte(cmd, 1, N);
+		
+		cli.send( cmd, 5, null , 0, null);
+		
+		return cli.responseType!=ResponseType.wrong;
+	}
+
+	/**
+	 * Notice the ORAM server to open the database, will use the created database
+	 * @return
+	 */
+	public boolean openORAM()
+	{
+		byte cmd[]=new byte[5]; 
+		cmd[0]=CommandType.openDB; 
+		
+		cli.send( cmd, 1, null , 0, null);
+		
+		return cli.responseType!=ResponseType.wrong;
+	}
+	 
+
+	byte[] access(char op, int block_id, byte[] value)
+    {
+		byte data[] = new byte[CommInfo.blockSize];
+		
+		int r = 1;
+    	if (Util.debug==false){
+            r = Util.rand_int(n_partitions); 
+        	//not write to the partition with more than the pre-defined real blocks
+        	while ( partions[r].realDataNumber >= this.n_realBlocks_p )
+        		r = Util.rand_int(n_partitions); 
+    	}
+    	
+        int p = pos_map[block_id].partition; 
+        /****************
+         * Read data from slots or the server
+         * If it is in the slot
+         *    readAndDel from the slot
+         *    read a dummy block from server
+         * Else
+         *    read the real block from the server
+         * ******************/
+		if (p >= 0) {
+			boolean isInSlot = false; 
+			Iterator itr = slots[p].iterator();
+			SlotObject targetObj = null;
+			while (itr.hasNext())
+			{
+				targetObj = (SlotObject)itr.next();
+				if (targetObj.id==block_id)
+				{
+					isInSlot=true;
+					break;
+				}
+			}
+			 
+			if ( isInSlot ) {
+				// in the slot
+				System.arraycopy(targetObj.value, 0, data, 0, CommInfo.blockSize); 
+				slots[p].remove(targetObj);
+				partions[p].readPartition(CommInfo.dummyID);
+			} else {
+				/**************************
+				 * Here, should send a request to the cloud server to get the
+				 * data
+				 * **************************/ 
+				byte[] bReadData=partions[p].readPartition(block_id);
+				System.arraycopy(bReadData, 0, data, 0, CommInfo.blockSize); 
+			}
+		}
+       
+        pos_map[block_id].partition = r;
+        pos_map[block_id].level = -1;
+        pos_map[block_id].offset = -1;
+        
+        if (op == 'w')
+        { 
+        	data=value;
+        }
+        SlotObject newObject = new SlotObject(block_id, data);
+    	slots[r].add(newObject);
+
+//    	if (p>=0)
+//            evict(p);
+
+    	randomEvict(CommInfo.v); 
+        return data;
+    }
+
+    void sequentialEvict(int vNumber)
+    {   
+		for (int i = 0; i < vNumber; i++) {
+			counter = (counter + 1) % n_partitions;
+			evict(counter);
+		}
+    }
+    void randomEvict(int vNumber)
+    {   
+    	Random rnd=new Random(); 
+		for (int i = 0; i < vNumber; i++) {
+			int r = rnd.nextInt(n_partitions); 
+			evict(r);
+		}
+    }
+	void evict(int p) {
+
+	    if (slots[p].isEmpty()) { 
+	    	partions[p].writePartition(CommInfo.dummyID, null);  
+	    } else {
+	    	//pop a data in slots
+	    	SlotObject obj=slots[p].poll();  
+	    	partions[p].writePartition( obj.id, obj.value);
+	    }
+	}
+	
+	public int getCacheSlotSize()
+	{
+		int ret = 0;
+		for (int i=0; i<slots.length; i++)
+		{
+			ret += slots[i].size();
+		}
+		return ret;
+	}
+
+	/**
+	 * Suggest the client to call this, when it will be closed
+	 */
+	public void clearSlot()
+	{
+		for (int i=0; i<slots.length; i++)
+		{
+			/**************
+			 * Here, do not clear directly
+			 * Just remove from the slot, but the data should always stored in the database
+			 * So, we should update the position map
+			 * 
+			 */
+
+			while (slots[i].size()>0){
+		    	SlotObject obj=slots[i].poll();  
+				partions[i].writePartition(obj.id, obj.value);
+			}
+			slots[i].clear();
+		} 
+	}
+
+	@Override
+	public void write(String idStr, byte[] value) { 
+	    access('w', Integer.parseInt(idStr), value); 
+	}
+
+	@Override
+	public byte[] read(String idStr) { 
+	    return access('r', Integer.parseInt(idStr), null); 
+	}
+
+	@Override
+	public void write(int id, byte[] value) { 
+	    access('w', id, value); 
+	}
+
+	@Override
+	public byte[] read(int id) { 
+	    return access('r', id, null);  
+	}
+
+
+}

src/nankai/oram/client/SubCloudThinORAM.java

@@ -0,0 +1,178 @@
+package nankai.oram.client;
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Random;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+
+import nankai.oram.client.ThinORAMClient;
+import nankai.oram.client.common.Position;
+import nankai.oram.client.common.SlotObject;
+import nankai.oram.client.partition.Partition;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.SocketClientUtil;
+import nankai.oram.common.CommandType;
+import nankai.oram.common.ResponseType;
+import nankai.oram.common.SymmetricCypto;
+import nankai.oram.common.Util;
+import nankai.oram.interfaces.MultiCloudORAM;
+import nankai.oram.interfaces.ORAM;
+
+public class SubCloudThinORAM implements MultiCloudORAM {
+
+	int cloud;
+	int n_partitions;
+	int n_capacity;//the max capacity of a partition -- need the top level
+    int n_levels;	 
+	int n_realBlocks_p;//the real number of blocks in a partition  
+	int counter=0;//for sequneceEvict
+	ThinORAMPartition[] partitions;
+	Position pos_map[];//position map
+	SocketClientUtil[] cli;
+
+	private SecretKey userKey; //First onion encryption Layer
+	byte s_buffer[][];
+	
+	public SubCloudThinORAM(int npartitions, int realBlocks_p, int levels, int capacity, int c, Position posMap[], SocketClientUtil[] cLi,byte sBuffer[][])
+	{
+		n_partitions=npartitions;
+		n_realBlocks_p=realBlocks_p;
+		n_levels=levels;
+		n_capacity=capacity;
+		cloud=c;
+		pos_map=posMap;
+		cli=cLi;
+		partitions=new ThinORAMPartition[n_partitions];
+		s_buffer=sBuffer;
+		for (int i=0;i<n_partitions;i++)
+		{
+			partitions[i]=new ThinORAMPartition(realBlocks_p, levels, posMap, cLi[cloud], this,s_buffer);
+			partitions[i].partition=i;
+		}
+
+	    KeyGenerator kg;
+		try {
+			kg = KeyGenerator.getInstance("AES");
+			kg.init(128);
+			userKey = kg.generateKey(); 
+		} catch (NoSuchAlgorithmException e) { 
+			e.printStackTrace();
+		}
+	}
+	
+
+	public void encryptData(byte[] data) {
+//		SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+//		scp.initEnc(this.userKey, null);
+//		scp.enc_decData(data, CommInfo.blockSize);
+	}
+	
+	public void decryptData(byte[] data) {
+//		SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+//		scp.initDec(this.userKey, null);
+//		scp.enc_decData(data, CommInfo.blockSize);
+	}
+
+	public boolean initORAM()
+	{
+		byte cmd[]=new byte[14]; 
+		cmd[0]=CommandType.initORAM; 
+		Util.intToByte(cmd, 1, n_partitions);
+		Util.intToByte(cmd, 5, n_capacity);
+		Util.intToByte(cmd, 9, n_levels);
+		cmd[13] = (byte) this.cloud;
+		
+		cli[cloud].send( cmd, 14, null , 0, null);
+		
+		return cli[cloud].responseType!=ResponseType.wrong;
+	}
+
+	public boolean openORAM()
+	{
+		byte cmd[]=new byte[2]; 
+		cmd[0]=CommandType.openDB; 
+		cmd[1]=(byte) this.cloud; 
+		
+		cli[cloud].send( cmd, 2, null , 0, null);
+		
+		return cli[cloud].responseType!=ResponseType.wrong;
+	}
+	 
+	@Override
+	public void writeCloud(Queue slot) {
+		/*****************
+		 * Random select a partition 
+		 * 
+		 * Select another cloud to do the shuffle operation
+		 * *********************/
+
+		//System.out.println("writeCloud begin");
+    	Random rnd=new Random();  
+		int p = 1;//rnd.nextInt(n_partitions); 
+        if (Util.debug == false){
+        	p = rnd.nextInt(n_partitions);
+        	//not write to the partition with more than the pre-defined real blocks 
+        	while ( partitions[p].realDataNumber >= (partitions[p].top_level_len - 2*MCloudCommInfo.evictConditionSize) )
+            	p = rnd.nextInt(n_partitions);
+        }
+
+		//generate a random cloud to do the shuffle operation
+		int otherCloud = rnd.nextInt(MCloudCommInfo.cloudNumber);
+		if (MCloudCommInfo.cloudNumber > 1){
+		    while (otherCloud == this.cloud)
+			    otherCloud = rnd.nextInt(MCloudCommInfo.cloudNumber);
+		}
+ 
+		
+		partitions[p].writePartition(slot, cli[cloud], otherCloud, cli[otherCloud], userKey, cloud);
+	}
+	
+	public boolean canWrite()
+	{
+		int realnumber = 0;
+		for (int i=0;i<this.n_partitions; i++)
+		{
+			realnumber += this.partitions[i].realDataNumber;
+		}
+		if (realnumber> ( (this.n_realBlocks_p * this.n_partitions * 11)/10 ) )
+			return false;
+		return true;
+	}
+
+
+	@Override
+	public byte[] readCloud(String key) { 
+		return readCloud(Integer.parseInt(key));
+	}
+ 
+
+	@Override
+	public byte[] readCloud(int id) {
+		/*****************
+		 * If it is a dummy Block, random select a partition to read
+		 * **********************/
+		byte[] data = null;
+		int p = 0;
+		if (id<=CommInfo.dummyID)
+		{
+	    	Random rnd=new Random();  
+			p = rnd.nextInt(n_partitions); 
+		}else{
+			p = pos_map[id].partition; 
+		}
+		if (p>=0){
+			data = partitions[p].readPartition(id, userKey); 
+		    return data;	
+		}else{
+			return new byte[CommInfo.blockSize];
+		}
+	}
+
+	 
+ 
+
+}

src/nankai/oram/client/Test/TestReadWrite/ThinInitOram.java

@@ -0,0 +1,37 @@
+package nankai.oram.client.Test.TestReadWrite;
+
+import nankai.oram.client.ThinORAMClient;
+import nankai.oram.client.PartitionClient;
+
+/**
+ * This is the init oram program
+ * Each test should after the initilization of ORAM
+ * @author Dell
+ *
+ */
+
+public class ThinInitOram {
+
+	public static void main(String[] args) {   
+		
+		
+		ThinORAMClient oram=new ThinORAMClient(); 
+
+		//initialize the client
+		oram.init(40000);
+		oram.openConnection(); 
+
+		long testTime = -1; 
+    	long testDoneTime = -1; 
+        testTime = System.currentTimeMillis(); //ms  
+		//initalize the server
+		oram.initORAM(); 
+
+        testDoneTime = System.currentTimeMillis();  
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0;
+        System.out.println("totalElapsedTime:"+totalElapsedTime);  
+		
+		oram.closeConnection();
+		
+	}
+}

src/nankai/oram/client/Test/TestReadWrite/ThinReadAndWrite.java

@@ -0,0 +1,391 @@
+package nankai.oram.client.Test.TestReadWrite;
+
+import java.util.Random;
+
+import nankai.oram.client.ThinORAMClient;
+import nankai.oram.client.PartitionClient;
+import nankai.oram.client.MCloudCommInfo;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.Util;
+
+public class ThinReadAndWrite {
+	
+	public static int N = 40000;
+
+	public static void main(String[] args) {  
+
+
+		//testRead();
+		
+		
+		//testMultiWrite();
+
+		//testSameAccess();
+		testRandomAccess();
+	}
+
+	private static void testMultiWrite() {
+		//testWrite(5);
+		testWrite(10); 
+		testWrite(50); 
+		testWrite(100); 
+		testWrite(1000); 
+	}
+
+	private static void testRead() {
+		ThinORAMClient oram=new ThinORAMClient();
+		//initialize the client
+		oram.init(N);
+		oram.openConnection();
+		//initalize the server
+		oram.openORAM();
+		
+		writeTheBlocksToApartition(oram, 1000);
+		 
+		
+		readABlock(oram, 10);
+		readABlock(oram, 50);
+		readABlock(oram, 100);
+		readABlock(oram, 150);
+//		readABlock(oram, 40);
+//		readABlock(oram, 50);
+//		readABlock(oram, 60);
+//		readABlock(oram, 70);
+//		readABlock(oram, 80);
+//		readABlock(oram, 90);
+		//readABlock(oram, 70); 
+		//readABlock(oram, 100); 
+		//readABlock(oram, 150); 
+		readABlock(oram, 250); 
+		readABlock(oram, 500); 
+		
+		oram.closeConnection();
+	}
+
+	/************************
+	 * After the initOram 
+	 * This test can be performed
+	 * 
+	 * This test is used to test the execution time of random access, the number of shuffle between clouds and the write operation
+	 **********************/
+	private static void testRandomAccess() {
+		ThinORAMClient oram=new ThinORAMClient();
+		//initialize the client
+		oram.init(N);
+		oram.openConnection();
+		//initalize the server
+		oram.openORAM();
+
+		Util.debug = false; 
+		 
+		writeTheBlocks(oram, N); 
+   
+		accessWithRandomStatus(oram, 50); 
+		accessWithRandomStatus(oram, 100);   
+		accessWithRandomStatus(oram, 500);  	accessWithRandomStatus(oram, 1000);  
+//		
+		
+		oram.closeConnection();
+	}
+	private static void testSameAccess() {
+		ThinORAMClient oram=new ThinORAMClient();
+		//initialize the client
+		oram.init(N);
+		oram.openConnection();
+		//initalize the server
+		oram.openORAM();
+
+		Util.debug = false; 
+		
+		writeTheBlocks(oram, 10000);
+  
+
+//		//accessWithSameStatus(oram, 5); 
+//		accessWithSameStatus(oram, 10); 
+//		//accessWithSameStatus(oram, 25); 
+//		accessWithSameStatus(oram, 50); 
+//		//accessWithSameStatus(oram, 75); 
+		accessWithSameStatus(oram, 100); 
+//		//accessWithSameStatus(oram, 150);  
+//		accessWithSameStatus(oram, 200); 
+		
+		accessWithSameStatus(oram, 500); 
+		//accessWithSameStatus(oram, 500); 
+		accessWithSameStatus(oram, 1000); 
+		//accessWithSameStatus(oram, 2500); 
+		accessWithSameStatus(oram, 5000);  
+//		accessWithSameStatus(oram, 7500); 		accessWithSameStatus(oram, 10000); 
+		
+//		writeTheBlocks(oram, 10000);
+//		   
+//		accessWithSameStatus(oram, 5000); 
+//		
+		
+		oram.closeConnection();
+	}
+
+	private static void writeTheBlocks(ThinORAMClient oram, int number) {
+		//write some data 
+        
+		byte[] bData = new byte[CommInfo.blockSize];
+		for (int id = 0; id < number; id++) {
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = (byte) (i % 100);
+			//Util.intToByte(bData, 0, id);
+			oram.write(id, bData);
+		} 
+		
+		bData = oram.read( 2 );
+		System.out.println(" read 2:"+bData[2]);
+	}
+	
+
+	private static void accessWithRandomStatus(ThinORAMClient oram, int number)
+	{ 
+		
+
+		oram.clearSlot();
+		
+
+		Util.writeNumber = 0;
+		Util.readbandwidth =0;
+		Util.cloudcloudbandwidth =0;
+		Util.readNumber =0;
+		Util.bandwidth =0;
+		Util.cloudtocloud=0;
+		
+		long testTime = -1; 
+    	long testDoneTime = -1; 
+        testTime = System.currentTimeMillis(); //ms  
+		byte[] bData = new byte[CommInfo.blockSize];
+		Random rnd=new Random();
+		for (int id = 0; id < number ; id++) { 
+			//System.out.println("read "+id);
+			int _id= rnd.nextInt(N);
+			oram.read(_id);
+			_id= rnd.nextInt(N);
+			oram.read(_id);
+			_id= rnd.nextInt(N);
+			//write to the cloud
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = (byte) ((_id) % 100);
+			//System.out.println("write "+ (id+1) );
+			oram.write(_id, bData); 
+		}
+        testDoneTime = System.currentTimeMillis();  
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0;
+        System.out.println("number is:"+number);
+        System.out.println("totalElapsedTime:"+totalElapsedTime);  
+//		System.out.println("-----Shuffle numeber-----!"+Util.writeNumber+"  Util.cloudtocloud:"+ Util.cloudtocloud); 
+//		System.out.println("-----ORAM CACHE-----!"+ oram.getCacheSlotSize()); 
+        System.out.println("-----writeNumb r  ----  "+Util.writeNumber );
+        System.out.println("-----cloudtocloud  ----  "+Util.cloudtocloud );
+        System.out.println("-----readNumber  ----  "+Util.readNumber );
+        System.out.println("-----bandwidth  ----  "+  Util.bandwidth  );
+        System.out.println("-----cloudcloudbandwidth  ----  "+Util.cloudcloudbandwidth );
+        System.out.println("-----readbandwidth  ----  "+Util.readbandwidth ); 
+        
+        
+		
+
+		bData = oram.read( 2 );
+		System.out.println(" read 2:"+bData[2]);
+		bData = oram.read( 8 );
+		System.out.println(" read 8:"+bData[2]);
+		 
+	}
+	
+	private static void accessWithSameStatus(ThinORAMClient oram, int number)
+	{ 
+		
+
+		oram.clearSlot();
+		
+
+		Util.writeNumber = 0;
+		Util.readbandwidth =0;
+		Util.cloudcloudbandwidth =0;
+		Util.readNumber =0;
+		Util.bandwidth =0;
+		Util.cloudtocloud=0;
+		
+		long testTime = -1; 
+    	long testDoneTime = -1; 
+        testTime = System.currentTimeMillis(); //ms  
+		byte[] bData = new byte[CommInfo.blockSize];
+		for (int id = 0; id < number -10 ; id++) { 
+			//System.out.println("read "+id);
+			oram.read(id);
+			//write to the cloud
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = (byte) ((id+1) % 100);
+			//System.out.println("write "+ (id+1) );
+			oram.write(id+1, bData); 
+		}
+        testDoneTime = System.currentTimeMillis();  
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0;
+        System.out.println("number is:"+number);
+        System.out.println("totalElapsedTime:"+totalElapsedTime);  
+//		System.out.println("-----Shuffle numeber-----!"+Util.writeNumber+"  Util.cloudtocloud:"+ Util.cloudtocloud); 
+//		System.out.println("-----ORAM CACHE-----!"+ oram.getCacheSlotSize()); 
+        System.out.println("-----writeNumber  ----  "+Util.writeNumber );
+        System.out.println("-----cloudtocloud  ----  "+Util.cloudtocloud );
+        System.out.println("-----readNumber  ----  "+Util.readNumber );
+        System.out.println("-----bandwidth  ----  "+  Util.bandwidth  );
+        System.out.println("-----cloudcloudbandwidth  ----  "+Util.cloudcloudbandwidth );
+        System.out.println("-----readbandwidth  ----  "+Util.readbandwidth ); 
+        
+        
+		
+
+		bData = oram.read( 2 );
+		System.out.println(" read 2:"+bData[2]);
+		bData = oram.read( 8 );
+		System.out.println(" read 8:"+bData[2]);
+		 
+	}
+
+	private static void writeTheBlocksToApartition(ThinORAMClient oram, int number) { 
+		 
+		Util.debug = true; //debug is ture, to write into a fix partiton
+		
+		Util.writeNumber = 0;
+		
+		long testTime = -1; 
+    	long testDoneTime = -1; 
+
+        testTime = System.currentTimeMillis(); //ms   
+		byte[] bData = new byte[CommInfo.blockSize];
+		for (int id = 0; id < number; id++) {
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = (byte) (i % 128);
+			Util.intToByte(bData, 0, id);
+			oram.write(id, bData);
+		}
+        testDoneTime = System.currentTimeMillis();  
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0; 
+        System.out.println("totalElapsedTime:"+totalElapsedTime);   
+		System.out.println("-----Shuffle numeber---- -"+Util.writeNumber+"  cache size:"+oram.getCacheSlotSize()); 
+
+		byte[] bdata = oram.read(2);
+		System.out.println(" data :"+bdata[8]);
+	}
+	private static void readABlock(ThinORAMClient oram, int number) { 
+		 
+		Util.debug = true; 
+		
+		Util.writeNumber = 0;
+		
+		long testTime = -1; 
+    	long testDoneTime = -1; 
+
+        testTime = System.currentTimeMillis(); //ms   
+
+        for (int i=0; i<number;i++)
+        {
+            oram.read(oram.getIDinDB() );
+        }
+
+        testDoneTime = System.currentTimeMillis();  
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0; 
+        System.out.println("number is:"+number);
+        System.out.println("totalElapsedTime:"+totalElapsedTime);   
+		System.out.println("-----Shuffle numeber---- -"+Util.writeNumber+"  cache size:"+oram.getCacheSlotSize()); 
+		  
+		byte[] bdata = oram.read(2);
+		System.out.println(" data :"+bdata[8]);
+	}
+	
+	
+	private static void access(int number)
+	{
+		ThinORAMClient oram=new ThinORAMClient();
+		//initialize the client
+		oram.init(N);
+		oram.openConnection();
+		//initalize the server
+		oram.openORAM();
+		
+
+		long testTime = -1; 
+    	long testDoneTime = -1; 
+        testTime = System.currentTimeMillis(); //ms  
+		byte[] bData = new byte[CommInfo.blockSize];
+		for (int id = 0; id < number; id++) { 
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = (byte) (i % 128);
+			oram.read(id);
+			oram.write(id+1, bData);
+		}
+        testDoneTime = System.currentTimeMillis();  
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0;
+        System.out.println("totalElapsedTime:"+totalElapsedTime);  
+		System.out.println("-----Shuffle numeber---- -"+Util.writeNumber+"  cache size:"+oram.getCacheSlotSize()); 
+		
+		oram.closeConnection(); 
+	}
+
+	/**
+	 * Test the special write to a fix partition 
+	 * 
+	 * if Util.debug set true, fix partition
+	 * For a fix partition, test the number less than 1100
+	 * but if false, random partition
+	 */
+	private static void testWrite(int number) {
+		ThinORAMClient oram=new ThinORAMClient();
+		//initialize the client
+		oram.init(N);
+		oram.openConnection();
+		//initalize the server
+		oram.openORAM();
+		//write some data
+		
+		Util.debug = true;
+		Util.writeNumber = 0;
+		Util.readbandwidth =0;
+		Util.cloudcloudbandwidth =0;
+		Util.readNumber =0;
+		Util.bandwidth =0;
+		Util.cloudtocloud=0;
+
+		byte[] bData = new byte[CommInfo.blockSize];
+		
+        System.out.println("number is:"+number);
+		long testTime = -1; 
+		long testTime1 = -1; 
+    	long testDoneTime = -1; 
+    	long testDoneTime1 = -1; 
+        testTime = System.currentTimeMillis(); //ms  
+        testTime1 = System.nanoTime();//ns 
+        
+		for (int id = 0; id < number; id++) {
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = (byte) (id % 100); 
+			oram.write(id, bData);
+		}
+
+        testDoneTime = System.currentTimeMillis();  
+        testDoneTime1 = System.nanoTime(); 
+        double totalElapsedTime = (testDoneTime - testTime);// / 1000.0;
+        
+        double totalElapsedTime1 = (testDoneTime1 - testTime1);// / 1000.0;
+        System.out.println("totalElapsedTime:"+totalElapsedTime);  
+//        System.out.println("totalElapsedTime222:"+totalElapsedTime1); 
+        
+        System.out.println("-----cloudtocloud  ----  "+Util.cloudtocloud );
+        System.out.println("-----writeNumber  ----  "+Util.writeNumber );
+        System.out.println("-----bandwidth  ----  "+Util.bandwidth );
+        System.out.println("-----cloudcloudbandwidth  ----  "+Util.cloudcloudbandwidth );
+        System.out.println("-----readNumber  ----  "+Util.readNumber );
+        System.out.println("-----readbandwidth  ----  "+Util.readbandwidth ); 
+        
+		byte[] data = oram.read(8);
+		System.out.println("-----read 8--------- : " + data[8]); 
+		data = oram.read(9);
+		System.out.println("-----read 9--------- : " + data[8]); 
+		
+		oram.closeConnection();
+	}
+	 
+}

src/nankai/oram/client/ThinORAMClient.java

@@ -0,0 +1,324 @@
+package nankai.oram.client;
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Random;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+
+import nankai.oram.client.common.Position;
+import nankai.oram.client.common.SlotObject;
+
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.SocketClientUtil;
+import nankai.oram.common.CommandType;
+import nankai.oram.common.ResponseType;
+import nankai.oram.common.SymmetricCypto;
+import nankai.oram.common.Util;
+import nankai.oram.interfaces.MultiCloudORAM;
+import nankai.oram.interfaces.ORAM;
+
+public class ThinORAMClient implements ORAM{
+	
+
+	boolean initFlag;
+	SubCloudThinORAM[] subORAMs;
+	 
+	int N;
+	int n_partitions; //All the partitions, for each cloud, it would be divided
+	int n_partitions_cloud;//the number of partitions for a cloud
+	int n_capacity;//the max capacity of a partition -- need the top level
+    int n_levels;	
+	int n_blocks;
+	int n_realBlocks_p;//the real number of blocks in a partition 
+	int top_level_len;//the number of blocks in the top level	
+	int counter=0;//for sequneceEvict
+	
+	Position pos_map[];//position map
+	
+	/*************************************************/
+	Queue<SlotObject> slots[]; 
+	
+	SocketClientUtil[] cli; 
+	 
+	byte s_buffer[][];
+	public ThinORAMClient()
+	{ 
+		initFlag=false;
+	    cli=new SocketClientUtil[MCloudCommInfo.cloudNumber];
+
+	}
+	
+	/**
+	 * initialize the parameters, storage space and so on
+	 * @param nN
+	 */
+	public boolean init(int nN)
+	{
+		if (initFlag==true)
+		{
+			System.out.println("have inited!");
+			return false;
+		}
+		N=nN; 
+		n_partitions = (int) Math.ceil(Math.sqrt(nN));
+		n_partitions_cloud = (int) Math.ceil(n_partitions/MCloudCommInfo.cloudNumber) ;
+
+		n_realBlocks_p =   (int) Math.ceil(((double) nN) / n_partitions);
+	    n_blocks = n_realBlocks_p * n_partitions;
+	    
+	    n_levels = (int) (Math.log((double) n_realBlocks_p) / Math.log(2.0)) + 1;
+	    n_capacity = (int) Math.ceil(CommInfo.capacity_parameter * n_realBlocks_p);
+		   
+	    pos_map=new Position[n_blocks];
+	    for (int i=0;i<n_blocks; i++)
+	    {
+	    	pos_map[i]=new Position();
+	    }
+	    slots=new Queue[MCloudCommInfo.cloudNumber]; 
+	    subORAMs=new SubCloudThinORAM[MCloudCommInfo.cloudNumber]; 
+	    s_buffer=new byte[MCloudCommInfo.evictConditionSize*3][CommInfo.blockSize];//the real value is evicCondition*2
+	    
+	    //randomly generate the keys for each level of each partition 
+		for (int i = 0; i < MCloudCommInfo.cloudNumber; i++)
+		{
+			slots[i]=new LinkedList<SlotObject>();
+			cli[i]=new SocketClientUtil(MCloudCommInfo.ip[i], MCloudCommInfo.port[i]);
+			subORAMs[i]=new SubCloudThinORAM(n_partitions_cloud, n_realBlocks_p, n_levels, n_capacity, i, pos_map, cli, s_buffer);
+		}
+					
+	    counter = 0; 
+	    
+	    initFlag=true;
+	    return true;
+	}
+	
+	public void openConnection()
+	{ 
+		for (int i = 0; i < MCloudCommInfo.cloudNumber; i++)
+		{
+		    cli[i].connect();
+		}
+	}
+	public void closeConnection()
+	{
+		for (int i = 0; i < MCloudCommInfo.cloudNumber; i++)
+		{
+		    cli[i].disConnect();
+		}
+	}
+	
+	public boolean initORAM()
+	{ 
+		boolean bRet = true;
+		for (int i = 0; i < MCloudCommInfo.cloudNumber; i++)
+		{
+			if (subORAMs[i].initORAM()==false)
+				bRet = false;
+		}
+		
+		return bRet;
+	}
+
+	/**
+	 * Notice the ORAM server to open the database
+	 * @return
+	 */
+	public boolean openORAM()
+	{
+		boolean bRet = true;
+		for (int i = 0; i < MCloudCommInfo.cloudNumber; i++)
+		{
+			if (subORAMs[i].openORAM()==false)
+				bRet = false;
+		}
+		
+		return bRet;
+	}
+	 
+	 
+
+	byte[] access(char op, int block_id, byte[] value)
+    {
+		
+//		try {
+//			Thread.sleep(10);
+//		} catch (InterruptedException e) {
+//			// TODO ×Ô¶¯Éú³ÉµÄ catch ¿é
+//			e.printStackTrace();
+//		}
+		try{
+
+//			System.out.println("access begin");
+
+			byte data[] = new byte[CommInfo.blockSize];
+
+			int r = Util.rand_int(MCloudCommInfo.cloudNumber);
+
+			int c = pos_map[block_id].cloud;
+			int p = pos_map[block_id].partition;
+			/****************
+			 * Read data from slots or the server If it is in the slot
+			 * readAndDel from the slot read a dummy block from server Else read
+			 * the real block from the server
+			 * ******************/
+			if (c >= 0) {
+				boolean isInSlot = false;
+				Iterator itr = slots[c].iterator();
+				SlotObject targetObj = null;
+				while (itr.hasNext()) {
+					targetObj = (SlotObject) itr.next();
+					if (targetObj.id == block_id) {
+						isInSlot = true;
+						break;
+					}
+				}
+
+				if (isInSlot) {
+					// in the slot
+					System.arraycopy(targetObj.value, 0, data, 0,
+							CommInfo.blockSize);
+					slots[c].remove(targetObj);
+//					System.out.println("readdummy block_id " + block_id + " c:"
+//							+ c + " p:" + p);
+					subORAMs[c].readCloud(CommInfo.dummyID);
+//					System.out.println("readdummy end block_id " + block_id
+//							+ " c:" + c + " p:" + p);
+				} else {
+					/**************************
+					 * Here, should send a request to the cloud server to get
+					 * the data
+					 * **************************/
+//					System.out.println("readCloud block_id " + block_id + " c:"
+//							+ c + " p:" + p);
+					System.arraycopy(subORAMs[c].readCloud(block_id), 0, data,
+							0, CommInfo.blockSize);
+//					System.out.println("read end");
+				}
+
+			}
+
+			pos_map[block_id].cloud = r;
+			pos_map[block_id].partition = -1;
+			pos_map[block_id].level = -1;
+			pos_map[block_id].offset = -1;
+
+			if (op == 'w') {
+				System.arraycopy(value, 0, data, 0, CommInfo.blockSize);
+			}
+			writeCache(block_id, data, r);
+
+			//System.out.println("sequentialEvict begin");
+			sequentialEvict(CommInfo.v);
+			//System.out.println("sequentialEvict end");
+
+//			System.out.println("access end");
+			return data;
+		}catch(Exception ex)
+		{
+			ex.printStackTrace();
+		}
+		return null;
+    }
+
+	/****
+	 * Write to the cache. With the first layer onion-encryption
+	 * @param block_id
+	 * @param data
+	 * @param r
+	 */
+	private void writeCache(int block_id, byte[] data, int c) {
+		//should be first onion - encryption 
+		
+		SlotObject newObject = new SlotObject(block_id, data);
+		
+    	slots[c].add(newObject);
+	}
+
+
+    void sequentialEvict(int vNumber)
+    {   
+		for (int i = 0; i < vNumber; i++) {
+			counter = (counter + 1) % MCloudCommInfo.cloudNumber;
+			evict(counter);
+		}
+    }
+    void randomEvict(int vNumber)
+    {   
+    	Random rnd=new Random(); 
+		for (int i = 0; i < vNumber; i++) {
+			int r = rnd.nextInt(MCloudCommInfo.cloudNumber); 
+			evict(r);
+		}
+    }
+	void evict(int c) {
+
+		if (slots[c].size() >= MCloudCommInfo.evictConditionSize)
+		{			
+			if (subORAMs[c].canWrite())
+			    subORAMs[c].writeCloud(slots[c]);
+		}
+	}
+	
+
+	public int getCacheSlotSize()
+	{
+		int ret = 0;
+		for (int i=0; i<slots.length; i++)
+		{
+			ret += slots[i].size();
+		}
+		return ret;
+	}
+	
+	public void clearSlot()
+	{
+		for (int i=0; i<slots.length; i++)
+		{
+			/**************
+			 * Here, do not clear directly
+			 * Just remove from the slot, but the data should always stored in the database
+			 * So, we should update the position map
+			 * 
+			 */
+
+			if (slots[i].size()>0)
+			    subORAMs[i].writeCloud(slots[i]); 
+			 slots[i].clear();
+		} 
+	}
+	
+	public int getIDinDB()
+	{
+		for (int i=0;i<n_blocks; i++)
+		{
+			if (pos_map[i].partition != -1 )
+				return i;
+		}
+		return -1;
+	}
+
+	@Override
+	public void write(String idStr, byte[] value) { 
+	    access('w', Integer.parseInt(idStr), value); 
+	}
+
+	@Override
+	public byte[] read(String idStr) { 
+	    return access('r', Integer.parseInt(idStr), null); 
+	}
+
+	@Override
+	public void write(int id, byte[] value) { 
+	    access('w', id, value); 
+	}
+
+	@Override
+	public byte[] read(int id) { 
+	    return access('r', id, null); 		
+	}
+
+}

src/nankai/oram/client/ThinORAMPartition.java

@@ -0,0 +1,716 @@
+package nankai.oram.client;
+
+/*************
+ * The data in a level of a partition is encrypted by the key for level
+ * 
+ * Each data is included by BID+DATA 
+ * BID = REALBLOCK? BLOCKID : - OFFSET
+ */
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Queue;
+import java.util.Random;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+
+import nankai.oram.client.common.Position;
+import nankai.oram.client.common.SlotObject;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.SocketClientUtil;
+import nankai.oram.common.CommandType;
+import nankai.oram.common.SymmetricCypto;
+import nankai.oram.common.Util;
+
+public class ThinORAMPartition{
+	public static int part=0;
+	int n_levels;
+	 
+	int n_realBlocks_p;//the real number of blocks in a partition 
+	int n_capacity;//the max capacity of a partition -- need the top level
+	int top_level_len;//the number of blocks in the top level
+	
+	int partition = 0;
+	int blockIDs[];//all the blockIDs. When re-shuffle, the dummyIDs will be re-filled
+	int dummyNumbers[];//the dummy block numbers;  When re-shuffle, the dummyIDs will be filled
+	int nextDummy[];//the dummy block counter; 
+	boolean filled[];//filled level flag
+	boolean readFlag[];//read flag
+	SecretKey keys[];//level key for each partition
+	
+	byte s_buffer[][];
+ 
+	Position pos_map[];//position map
+	SocketClientUtil cli;
+
+	SubCloudThinORAM subOram;
+
+	KeyGenerator kg;
+	
+	public int realDataNumber = 0;
+	
+	public ThinORAMPartition(int realBlocks_p, int levels, Position posMap[], SocketClientUtil cLi, SubCloudThinORAM soram,byte sBuffer[][])
+	{  
+		subOram=soram;
+		pos_map=posMap;
+		cli=cLi; 
+		s_buffer = sBuffer;
+		n_realBlocks_p =   realBlocks_p; 
+	    
+	    n_levels = levels;
+	    n_capacity = (int) Math.ceil(CommInfo.capacity_parameter * n_realBlocks_p);
+	    top_level_len = n_capacity - (1 << n_levels) + 2;
+	     
+		readFlag=new boolean[n_capacity]; 
+		keys=new SecretKey[n_levels];
+		blockIDs=new int[n_capacity];
+		nextDummy=new int[n_levels];
+		dummyNumbers=new int[n_levels];
+		filled=new boolean[n_levels];
+
+		for (int i=0;i<n_levels;i++)
+		{
+			dummyNumbers[i]=0;
+			nextDummy[i]=0;
+			filled[i]=false;
+		}
+		for (int i=0;i<n_capacity;i++)
+		{ 
+			readFlag[i]=true;
+			blockIDs[i]=CommInfo.dummyID;
+		}
+		
+		initKeys();
+	}
+	
+	
+	private void initKeys()
+	{ 
+		try {
+			kg = KeyGenerator.getInstance("AES");
+			kg.init(128);
+			for (int j = 0; j < n_levels; j++)
+				keys[j] = kg.generateKey();
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		}
+	} 
+	
+	public byte[] getKey(int pos)
+	{
+		return keys[pos].getEncoded();
+	}
+
+	public byte[] readPartition(int block_id, SecretKey userKey) {
+		
+		/*******************************
+		 * Gnerate the OFFSETs
+		 * 
+		 * Length + ID1 ...... + ID2......
+		 * *****************************/
+		byte[] data = new byte[CommInfo.blockSize]; 
+		byte[] xorZero = new byte[CommInfo.blockSize]; 
+		byte[] ids = new byte[ n_levels * 4 ];  
+		int[] levels = new int[n_levels];
+		int level = -1;
+		if (block_id!=CommInfo.dummyID)
+			level = pos_map[block_id].level;
+		int length = 0;
+		int realDataID = -1;
+		for (int i=MCloudCommInfo.severBeginLevel;i<n_levels;i++)
+		{
+			if (filled[i])
+			{ 
+			    int _id =  (1 << (i + 1)) - 2; 
+				
+				if (level==i && block_id!=CommInfo.dummyID)
+				{
+					_id += pos_map[block_id].offset;
+					realDataID = _id;
+				}else{
+					// not in this level, to read a dummy block, get the dummy offset
+					int dID=nextDummy(0, i);
+					if (dID == -1) // There is no dummy block can be read
+						continue;
+					_id += dID;//nextDummy(i); 
+				}
+				readFlag[_id]=true;
+				Util.intToByte(ids, length*4, _id); 
+				levels[length] = i;
+				length ++; 
+			}
+		}
+		if (length==0)
+			return null;
+		
+		/*************************
+		 * Send to the cloud
+		 * 
+		 * Command: readCloud
+		 * content: partition + length 
+		 * offsets 
+		 * **************************/
+		//System.out.println("read partition length:"+length);
+		byte[] cmd=new byte[9];
+		cmd[0]=CommandType.readCloud;
+		Util.intToByte(cmd, 1, partition);
+		Util.intToByte(cmd, 5, length);
+		 
+		cli.send(cmd, 9, ids, length*4, data);
+		
+		
+
+		Util.readbandwidth += 9+length*4+CommInfo.blockSize; //
+		Util.readNumber ++ ; //
+		/*************************************
+		 * Decrypt Data based on XOR technique
+		 * 
+		 * Enc-level-key and Enc-enc-key
+		 * **********************************/
+		if (block_id != CommInfo.dummyID) {
+			SymmetricCypto scp = new SymmetricCypto(CommInfo.keySize);
+			for (int i = 0; i < length; i++) {
+				// XOR the data 000000
+				int _id = Util.byteToInt(ids, i * 4, 4);
+				if (_id >= 0)
+					continue;
+				byte[] iv = Util.generateIV(_id);
+				for (int j = 0; j < CommInfo.blockSize; j++)
+					xorZero[j] = 0;
+
+//				// first onion encrypt userkey
+//				scp.initEnc(userKey, iv);
+//				scp.enc_decData(xorZero, CommInfo.blockSize);
+//				// second onion encrypt level key
+//				scp.initEnc(keys[levels[i]], null);
+//				scp.enc_decData(xorZero, CommInfo.blockSize);
+
+				// XOR
+				for (int j = 0; j < CommInfo.blockSize; j++)
+					data[j] ^= xorZero[j];
+
+			}
+
+//			// First onion decrypt by level key
+//			scp.initDec(keys[level], null);
+//			scp.enc_decData(data, CommInfo.blockSize);
+			
+			// Second, onion decrypt by the user key
+			subOram.decryptData(data);
+		}
+		
+
+		//update all the real numbers
+		realDataNumber=0;
+		int levelBegin = (1 << (MCloudCommInfo.severBeginLevel + 1)) - 2;
+		for (int i=levelBegin; i<this.n_capacity; i++)
+		{
+			if (blockIDs[i]>0 && readFlag[i]==false)
+				realDataNumber++;
+		} 
+		return data ; 
+	}
+
+	public byte[] generateXORBlock(int p, int _id, SecretKey userKey)
+	{
+		//Encrypt the 0x00 default value by the userkey
+		byte[] data=new byte[CommInfo.blockSize];
+		for (int i=0;i<CommInfo.blockSize;i++)
+		{
+			data[i] = 0;
+		}
+		/****************************
+		 * The first 4 bytes is the dummmyID and the random value, to make sure it is less than 0
+		 * 
+		 * But now, to simplify the implementation, we ignore the random value for the same 0000000
+		 * ******************************/
+		int dummyID = CommInfo.dummyID - Util.rand_int(n_capacity);
+		blockIDs[_id]=dummyID; 
+		
+//		byte[] iv = Util.generateIV(dummyID);
+		
+		//encrypt		
+//		SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+//		scp.initEnc(userKey, iv);
+//		scp.enc_decData(data, CommInfo.blockSize); 
+		return data;
+	}
+	
+	public void writePartition(Queue slot, SocketClientUtil cli, int otherCloud, SocketClientUtil cliOtherCloud, SecretKey userKey, int cloud)
+	{
+		//System.out.println("write begin!!");
+		int evictSize = MCloudCommInfo.evictConditionSize; 
+		if (slot.size()<evictSize) {
+			evictSize = slot.size(); 
+		}
+
+
+		int unfilledLevel = -1;
+		for (int i = MCloudCommInfo.severBeginLevel; i < this.n_levels; i++) {
+			if (!filled[i]) {
+				unfilledLevel = i ;
+				break;
+			}
+		}
+		
+
+		if (unfilledLevel == MCloudCommInfo.severBeginLevel){
+			//CASE 2
+	    	writeCase1(slot, userKey, cloud, evictSize, unfilledLevel); 
+		}else{
+		
+
+			try {
+				writeCase2(slot, cli, otherCloud, cliOtherCloud, userKey,
+						cloud, evictSize, unfilledLevel);
+			} catch (Exception e) {
+				System.out.println("error!!");
+			}
+		}
+
+		//System.out.println("write ok!!");
+		
+  
+	}
+
+
+	private void writeCase2(Queue slot, SocketClientUtil cli, int otherCloud,
+			SocketClientUtil cliOtherCloud, SecretKey userKey, int cloud,
+			int evictSize, int unfilledLevel) {
+		// System.out.println(" writeCase2 ");
+		 
+		byte[] bSessionID = Util.generateSessionData(8);   
+		int unreadRealDataNumber = 0;
+		/***************************************************
+		 * COMPUTE the range of the levels
+		 * ********************************************/
+		int begin =  (1 << (MCloudCommInfo.severBeginLevel + 1)) - 2;
+		int end =  (1 << (unfilledLevel + 1)) - 2;
+		boolean bSpecialCase = false;
+		if (unfilledLevel == -1){
+			bSpecialCase = true;
+			//All Filled levels, special treatment
+			unfilledLevel = n_levels - 1;
+	        end = this.n_capacity;
+		}
+		
+		for (int i=begin; i<end; i++)
+			if (readFlag[i] == false)
+			{ 
+				if (blockIDs[i]>=0)
+					unreadRealDataNumber++;
+			}
+		
+		/**********************************************
+		 * GEI the maxinum number of blocks in this level
+		 * *****************************************/
+        int filledLevelLength = 0; 
+	    if (unfilledLevel != n_levels - 1) {
+	    	filledLevelLength = 2 *(1 << unfilledLevel);
+	    } else filledLevelLength = top_level_len;
+	     
+	    int dataNumber=unreadRealDataNumber;
+
+		byte[] ids=new byte[dataNumber*4];//id in partition , for reading 
+		int[] intIDs=new int[dataNumber];//id 
+		byte[] levels=new byte[dataNumber];//store each id's level, for onion decryption
+	    
+		int pos = 0;
+		for (int level = MCloudCommInfo.severBeginLevel; level < this.n_levels; level++) {
+			if (filled[level]) {
+
+				begin = (1 << (level + 1)) - 2;
+				int datalen = 0;
+				if (level != n_levels - 1) {
+					datalen = 2 * (1 << level);
+				} else
+					datalen = top_level_len;
+
+				for (int _id = begin; _id < begin + datalen; _id++) {
+					if (this.readFlag[_id] == false  && blockIDs[_id]>=0 ) {
+						Util.intToByte(ids, pos * 4, _id);
+						levels[pos] = (byte) level;
+						intIDs[pos++] = blockIDs[_id]; 
+					}
+				}
+			} else {
+				break;
+			}
+		}
+		
+		if (pos!=unreadRealDataNumber)
+		    System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+		
+		/****************************************
+		 * (1)Notice Shuffle , Send All the data, onionkeys in slots to the otherCloud 
+		 * 
+		 * CommandType: noticeShuffle
+		 * Content: session ID | unfilled levels number | 
+		 *          onion keys and slots data  
+		 *          
+		 * (2)Notice this cloud to send the data to the otherCloud for shuffling
+		 * CommandType: writeCloud
+		 * content: session ID | unfilled - partition | other cloud for shuffling | length of ids
+		 * 
+		 *          
+		 * (3)Send back the shuffled Data  -- cloud to cloud, but not the client
+		 * CommandType: backData
+		 * ************************************/
+
+		//System.out.println("write partition filledLevelLength:"+filledLevelLength+" dataNumber:"+dataNumber+" unreadRealDataNumber:"+unreadRealDataNumber+" bSessionID:"+bSessionID[0]);
+ 
+
+		int rndLength = filledLevelLength - dataNumber - 2*evictSize; 
+		if (rndLength<0){
+			//System.out.println(" rndLength "+ rndLength +" filledLevelLength "+filledLevelLength+" dataNumber "+dataNumber+" evictSize "+evictSize );
+			return;
+		}
+		
+		
+		/***********************  First command:  noticeShuffle  ***************************/
+		byte[] cmd=new byte[29];
+		cmd[0]=CommandType.noticeShuffle;
+		System.arraycopy(bSessionID, 0, cmd, 1, 8); 
+		Util.intToByte(cmd, 9, partition);
+		Util.intToByte(cmd, 13, unfilledLevel);
+		Util.intToByte(cmd, 17, filledLevelLength);
+		Util.intToByte(cmd, 21, dataNumber);
+		Util.intToByte(cmd, 25, evictSize);
+		
+
+
+		cliOtherCloud.send(cmd, 29);
+		
+ 
+		//send the ids to notice how to onion decryption and encryption
+		cliOtherCloud.send(  levels, dataNumber );
+		
+//		if (dataNumber*4>512)
+//			System.out.println("----512-----");
+		/****************************************************
+		 * Send the data blocks to the shuffled cloud
+		 * We sends them directly here, in fact, we can permute them before sending them
+		 *********************************************/
+		//send the slots data, the number is filled
+		for (int _id=0;_id<evictSize;_id++)
+		{
+		    SlotObject targetObj = (SlotObject)slot.poll(); 
+		    blockIDs[_id]=targetObj.id;
+		    subOram.encryptData(targetObj.value); 
+		    cliOtherCloud.send( targetObj.value, CommInfo.blockSize );
+		    //System.out.println(" _id:"+_id+"  value:"+targetObj.value[0]);
+		}
+
+		for (int _id = evictSize; _id < 2*evictSize; _id++) {
+			byte[] bDummyData = generateXORBlock(partition, _id, userKey);
+		    cliOtherCloud.send( bDummyData, CommInfo.blockSize ); 
+		}
+ 
+
+		/****************************
+		 * generate random value for dummy blocks 
+		 * **************************************/	
+		//generate random value
+		Random rnd=new Random();
+		
+		int[] rnds=new int[rndLength];
+		byte[] rndBytes=new byte[rndLength*4];
+		for (int i=0; i<rndLength; i++)
+		{
+			rnds[i]= - rnd.nextInt( this.n_capacity ); //
+			blockIDs[ i+2*evictSize ] = rnds[i];
+			Util.intToByte(rndBytes, i*4, rnds[i]);
+		}
+		for (int _id=0;_id<dataNumber;_id++)
+		{ 
+			blockIDs[_id+2*evictSize+rndLength]=intIDs[_id];  
+		}
+		
+ 
+		cliOtherCloud.send(rndBytes, rndLength*4);
+		
+		//send the onion keys
+		/********************************************************************
+		 * Notice that: must send the unfilledlevel key to the server, 
+		 * because the special case, the unfilled level is the top level, the onion decryption will be used
+		 ****************************************************************/
+
+		Util.bandwidth +=  rndLength*4 + MCloudCommInfo.evictConditionSize*CommInfo.blockSize + (unfilledLevel-MCloudCommInfo.severBeginLevel+1)*CommInfo.keySize;
+		
+		Util.writeNumber ++;
+
+		Util.cloudtocloud++;
+		Util.cloudcloudbandwidth += (filledLevelLength) * CommInfo.blockSize +  dataNumber*CommInfo.blockSize; 
+
+
+		
+		for (int i=MCloudCommInfo.severBeginLevel; i<=unfilledLevel; i++)
+		{
+			byte[] bkeyData = getKey(i);
+			cliOtherCloud.send( bkeyData, CommInfo.keySize );
+		}
+		
+		//send the shuffle key and wait for the response
+		/******************************
+		 * Here, the client can receive the shffule key 
+		 * But, in our implmenetation, we generate the key in the client
+		 * it is also OK
+		 * ************************************
+		 * 
+		 * The client must wait for the response of the cloud
+		 * and cloud should finish the shuffle operation 
+		 *
+		 * Notice, we use the onion key as the shuffle key, it is also OK
+		 * *********************************/
+
+		//reset some status in the unfilled level
+	    keys[unfilledLevel]=kg.generateKey(); 
+	    nextDummy[unfilledLevel]=0;
+		filled[unfilledLevel]=true;
+		
+		byte[] shufflekey = getKey(unfilledLevel);//Util.generateDummyData(MCloudCommInfo.keySize); 
+		cliOtherCloud.sendAndReceive(shufflekey, 16); 
+		
+		//System.out.println("noticeshufule ok cloud: "+cloud+" session "+ bSessionID[0]+"  dataNumber "+dataNumber+" filledLevelLength:"+filledLevelLength);
+		
+
+		/***********************  Second command:  noticeWriteCloud  ***************************/
+		/////////////////////////First, command and keys
+		byte[] cmd1=new byte[22];
+		cmd1[0]=CommandType.noticeWriteCloud;
+		System.arraycopy(bSessionID, 0, cmd1, 1, 8);
+		Util.intToByte(cmd1, 9, partition);
+		Util.intToByte(cmd1, 13, unfilledLevel);
+		cmd1[17] =  (byte) otherCloud;
+		Util.intToByte(cmd1, 18, dataNumber);
+
+		cli.send(cmd1, 22, ids, dataNumber*4, null);
+
+ 	
+		/***************************
+		 *  Final, reset the status in the client
+		 *  (1) shuffle the blockIDs
+		 *  (2) reset the filled and read flag
+		 * *******************************/
+	    psuedo_random_permute( shufflekey, filledLevelLength);
+	    
+	    for (int i=MCloudCommInfo.severBeginLevel;i<unfilledLevel; i++)
+	    {
+	    	nextDummy[i]=0;
+	    	filled[i]=false; 
+	    }
+	    //update the status in the un-filled level
+	    /******************
+	     * Save to a temp int array
+	     * For the worst case
+	     * ******************/
+	    int[] bIDS = new int[filledLevelLength];
+	    for (int i=0; i<filledLevelLength; i++)
+	    {
+	    	bIDS[i]=blockIDs[i];
+	    }
+	    int levelBegin = (1 << (unfilledLevel + 1)) - 2;
+	    for (int i=0;i<filledLevelLength;i++)
+		{
+			int bID=bIDS[i];
+			int _id = i+levelBegin;
+			blockIDs[_id] = bID;
+			readFlag[_id]=false;
+			if (bID>=0)
+			{
+				//update the position map
+				pos_map[bID].cloud = cloud;
+				pos_map[bID].partition = this.partition;
+				pos_map[bID].level = unfilledLevel;
+				pos_map[bID].offset = i;
+			}
+		}
+		/*for (int i=filledLevelLength-1;i>=0;i--)
+		{
+			int bID=blockIDs[i];
+			int _id = i+levelBegin;
+			if (bID>=0)
+			{
+				//update the position map
+				pos_map[bID].cloud = cloud;
+				pos_map[bID].partition = this.partition;
+				pos_map[bID].level = unfilledLevel;
+				pos_map[bID].offset = i;
+			}
+			blockIDs[_id] = bID;
+			readFlag[_id]=false;
+		}*/
+		//update the status of consecutive levels
+		for (int i=0; i<levelBegin; i++)
+		{
+			blockIDs[i] = CommInfo.dummyID;
+			readFlag[i]=true;
+		}
+		//update all the real numbers
+		realDataNumber=0;
+		for (int i=levelBegin; i<this.n_capacity; i++)
+		{
+			if (blockIDs[i]>0 && readFlag[i]==false)
+				realDataNumber++;
+		}
+		
+
+		if (realDataNumber > this.n_realBlocks_p)
+			realDataNumber=realDataNumber;
+	}
+
+
+	private void writeCase1(Queue slot, SecretKey userKey, int cloud,
+			int evictSize, int unfilledLevel) {
+		
+		
+		int filledLevelLength = 2 * (1 << unfilledLevel);
+
+		// System.out.println(" writeCase1 ");
+		if (evictSize > filledLevelLength )
+			 System.out.println(" !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ");
+		// shuffle in client and then write to cloud rightly
+		for (int _id = 0; _id < evictSize; _id++) {
+			SlotObject targetObj = (SlotObject) slot.poll();
+			blockIDs[_id] = targetObj.id;
+			subOram.encryptData(targetObj.value);
+			System.arraycopy(targetObj.value, 0, s_buffer[_id], 0,
+					CommInfo.blockSize);
+			// System.out.println(" _id:"+_id+"  value:"+targetObj.value[0]);
+		}
+		for (int _id = evictSize; _id < filledLevelLength; _id++) {
+			byte[] bDummyData = generateXORBlock(partition, _id, userKey);
+			System.arraycopy(bDummyData, 0, s_buffer[_id], 0,
+					CommInfo.blockSize);
+			// System.out.println(" _id:"+_id+"  value:"+bDummyData[0]);
+		}
+		// shuffle first and then send them to the clouds
+		psuedo_random_permute(s_buffer, filledLevelLength);
+
+		keys[unfilledLevel] = kg.generateKey();
+		nextDummy[unfilledLevel] = 0;
+		filled[unfilledLevel] = true;
+
+		// onion encrypt them using the level key
+
+	    int[] bIDS = new int[filledLevelLength];
+	    for (int i=0; i<filledLevelLength; i++)
+	    {
+	    	bIDS[i]=blockIDs[i];
+	    }
+		// reset the status
+		int levelBegin = (1 << (unfilledLevel + 1)) - 2;
+		for (int i = 0; i< filledLevelLength; i++ ) {
+			int bID = bIDS[i];
+			int _id = i + levelBegin;
+			if (bID >= 0) {
+				// update the position map
+				pos_map[bID].cloud = cloud;
+				pos_map[bID].partition = this.partition;
+				pos_map[bID].level = unfilledLevel;
+				pos_map[bID].offset = i;
+			}
+			blockIDs[_id] = bID;
+			readFlag[_id] = false;
+		}
+		
+		// update the status of consecutive levels
+		for (int i = 0; i < levelBegin; i++) {
+			blockIDs[i] = CommInfo.dummyID;
+			readFlag[i] = true;
+		}
+
+		Util.writeNumber ++;
+		Util.bandwidth +=  filledLevelLength*CommInfo.blockSize ;
+		
+		//write to cloud
+		byte[] cmd1=new byte[13];
+		cmd1[0]=CommandType.directWriteCloud; 
+		Util.intToByte(cmd1, 1, partition);
+		Util.intToByte(cmd1, 5, unfilledLevel); 
+		Util.intToByte(cmd1, 9, filledLevelLength);
+
+		cli.send(cmd1, 13);
+		
+
+		for (int _id = 0; _id < filledLevelLength; _id++) {
+			cli.send( s_buffer[_id], CommInfo.blockSize );
+		}
+		//send over and receive
+		cmd1[0]=0;
+		cmd1[1]=0;
+		cli.sendAndReceive(cmd1, 2); 
+
+		//update all the real numbers
+		realDataNumber=0;
+		for (int i=levelBegin; i<this.n_capacity; i++)
+		{
+			if (blockIDs[i]>0 && readFlag[i]==false)
+				realDataNumber++;
+		} 
+	}
+	
+
+
+	 private void psuedo_random_permute(byte[][] sBuffer, int len) {			
+		 Random rnd=new Random();
+		 int id =0;
+		 byte[] bData=new byte[CommInfo.blockSize];
+	        for (int i = len- 1; i > 0; --i) {
+	            int j = rnd.nextInt(i);
+
+	            System.arraycopy(sBuffer[i], 0, bData, 0, CommInfo.blockSize);
+	            id=blockIDs[i];
+	            System.arraycopy(sBuffer[j], 0, sBuffer[i], 0, CommInfo.blockSize);
+	            blockIDs[i] =blockIDs[j];
+	            System.arraycopy(bData, 0, sBuffer[j], 0, CommInfo.blockSize); 
+	            blockIDs[j]=id;
+	        }
+	    }
+
+	/***
+	 * Permute the blockIDs in the client based on the key
+	 * @param shufflekey
+	 */
+	private  void psuedo_random_permute(byte[] shufflekey, int filledLevelLength) {
+		Util.writeNumber = Util.writeNumber+1;
+		
+
+//		for (int i = 0; i < filledLevelLength; i++) {
+//			System.out.println("i: "+i+"  "+blockIDs[i]); 
+//		}
+		
+		SecretKey sfk = new SecretKeySpec(shufflekey, "AES"); 
+
+		for (int i = 0; i < filledLevelLength; i++) {
+			int j = Util.fpeForPermution(i, sfk, filledLevelLength);
+			int t = blockIDs[i];
+			blockIDs[i] = blockIDs[j];
+			blockIDs[j] = t; 
+			
+//			System.out.println("permute: "+i+"  "+j);
+		}
+	}
+ 
+
+	public int nextDummy(int type, int level)
+	{ 
+	    int begin =  (1 << (level + 1)) - 2;
+	    int end=0;
+	    if (level != n_levels - 1) {
+	        end = 2 *(1 << level);
+	    } else end = top_level_len;
+		//compute the position in the position map
+	    for (int i=nextDummy[level];i<end;i++)
+		    if (blockIDs[begin+i]<= CommInfo.dummyID)
+		    {
+		    	nextDummy[level]=i+1;
+		    	return i;
+		    }
+	    
+	    //Notice that, there is no dummy blocks
+//	    System.out.println("No dummy !!!!!! return 0!!!!!p:"+this.partition+"  !!!type:"+type+" level:"+level+" nextDummy[level]"+nextDummy[level]);
+	    return -1;
+	}
+}

src/nankai/oram/client/common/Position.java

@@ -0,0 +1,24 @@
+package nankai.oram.client.common;
+
+public class Position{
+	/**********************
+	 * BLockID is maintained by the client
+	 * But id is stored in the server, the record ID of the data u with ID of BLockID
+	 * 
+	 * The same sequence in the client is denoted as the BLockIDs
+	 * but the real sequence in the server will be the different ids
+	 * ********************/
+	public int partition;
+	public int level;
+	public int offset;
+	public int rndNumber;//random value 
+	public int cloud;//random value 
+	public Position()
+	{
+		partition=-1;
+		level=-1;
+		offset=-1;
+		rndNumber=0;
+		cloud=-1;
+	}
+}

src/nankai/oram/client/common/SlotObject.java

@@ -0,0 +1,19 @@
+package nankai.oram.client.common;
+
+import nankai.oram.common.CommInfo;
+
+public class SlotObject{
+	public int id;
+	public byte[] value;
+	public SlotObject()
+	{
+		id=0;
+		value=new byte[CommInfo.blockSize];
+	}
+	public SlotObject(int _id, byte[] _value)
+	{
+		id=_id;
+		value=new byte[CommInfo.blockSize];
+		System.arraycopy(_value, 0, value, 0, CommInfo.blockSize);
+	}
+}

src/nankai/oram/client/partition/Partition.java

@@ -0,0 +1,349 @@
+package nankai.oram.client.partition;
+
+/*************
+ * The data in a level of a partition is encrypted by the key for level
+ * 
+ * Each data is included by BID+DATA 
+ * BID = REALBLOCK? BLOCKID : - OFFSET
+ */
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Random;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+
+import nankai.oram.client.common.Position;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.SocketClientUtil;
+import nankai.oram.common.CommandType;
+import nankai.oram.common.SymmetricCypto;
+import nankai.oram.common.Util;
+
+public class Partition{ 
+	public static int part=0;
+	int n_levels;
+	
+	int n_blocks;
+	int n_realBlocks_p;//the real number of blocks in a partition 
+	int n_capacity;//the max capacity of a partition -- need the top level
+	int top_level_len;//the number of blocks in the top level
+	
+	int p = 0;
+	int blockIDs[];//all the blockIDs. When re-shuffle, the dummyIDs will be re-filled
+	int dummyNumbers[];//the dummy block numbers;  When re-shuffle, the dummyIDs will be filled
+	int nextDummy[];//the dummy block counter; 
+	boolean filled[];//filled level flag
+	boolean flag[];//read flag
+	SecretKey keys[];//level key for each partition
+	
+
+	byte s_buffer[][];//shuffule buffer - a large memory 
+	Position pos_map[];//position map
+	SocketClientUtil cli;
+
+	byte cmdData[] = new byte[13]; 
+
+	public int realDataNumber = 0;
+	KeyGenerator kg;
+	public Partition(int nN, int n_partitions, Position posMap[], byte sBuffer[][], SocketClientUtil cLi)
+	{ 
+		s_buffer=sBuffer;
+		pos_map=posMap;
+		cli=cLi; 
+		
+		n_realBlocks_p =   (int) Math.ceil(((double) nN) / n_partitions);
+	    n_blocks = n_realBlocks_p * n_partitions;
+	    
+	    n_levels = (int) (Math.log((double) n_realBlocks_p) / Math.log(2.0)) + 1;
+	    n_capacity = (int) Math.ceil(CommInfo.capacity_parameter * n_realBlocks_p);
+	    top_level_len = n_capacity - (1 << n_levels) + 2;
+	    
+		p = part++;
+		flag=new boolean[n_capacity]; 
+		keys=new SecretKey[n_levels];
+		blockIDs=new int[n_capacity];
+		nextDummy=new int[n_levels];
+		dummyNumbers=new int[n_levels];
+		filled=new boolean[n_levels];
+
+		for (int i=0;i<n_levels;i++)
+		{
+			dummyNumbers[i]=0;
+			nextDummy[i]=0;
+			filled[i]=false;
+		}
+		for (int i=0;i<n_capacity;i++)
+		{ 
+			flag[i]=true;
+			blockIDs[i]=CommInfo.dummyID;
+		}
+		
+		initKeys();
+	}
+	
+	
+	private void initKeys()
+	{ 
+		try {
+			kg = KeyGenerator.getInstance("AES");
+			kg.init(128);
+			for (int j = 0; j < n_levels; j++)
+				keys[j] = kg.generateKey();
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		}
+	} 
+
+	public byte[] readPartition(int block_id) {
+		
+
+		/*******************************
+		 * From Each filled level, to read a block
+		 * if it is in this level, read the only one real block
+		 * else, read a dummy block			 * 
+		 * *****************************/
+		int readNumber = 0;
+		byte[] data = new byte[CommInfo.blockSize]; 
+		int level=-1;
+		if (block_id!=CommInfo.dummyID)
+			level = pos_map[block_id].level;
+		for (int i=0;i<n_levels;i++)
+		{
+			if (filled[i])
+			{
+				if (level==i && block_id!=CommInfo.dummyID)
+				{
+					readNumber++;
+					// in this level, to read a real block. get the offset
+					readBlock(p, i, pos_map[block_id].offset, data);
+					/*****************************
+					 * Decrypt the data
+					 * *************************/ 
+					SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+					scp.initDec(keys[i], null);
+					scp.enc_decData(data, CommInfo.blockSize); 
+					
+				}else{
+					readNumber++;
+					// not in this level, to read a dummy block, get the dummy offset
+
+					int dID=nextDummy(i);
+					if (dID == -1) // There is no dummy block can be read
+						continue; 
+					
+					readBlock(p, i, dID, null);
+				}
+			}
+		}
+		
+
+		Util.readNumber ++;
+		Util.readbandwidth += CommInfo.blockSize + readNumber*4;
+		Util.cloudcloudbandwidth += readNumber * CommInfo.blockSize *1.2 + readNumber*4;
+		Util.cloudtocloud ++;
+		
+		return data ; 
+	}
+	
+	public void writePartition(int block_id, byte[] bData)
+	{
+
+		int level=-1;
+		for (int i=0;i<this.n_levels;i++)
+		{
+			if (!filled[i])
+			{
+				level=i-1;
+				break;
+			}
+		}
+		
+		/***************************************
+		 * fetch all the unread blocks from the server
+		 * ***************************************/
+		int realNumber=0;
+		if (level != -1) { 
+			for (int i = 0; i <= level; i++) {
+				realNumber = fetchLevel(i, realNumber);
+				filled[i]=false;
+			}
+			Util.cloudtocloud = Util.cloudtocloud+1;
+		}
+		/******************************************
+		 * If block_id is dummy block
+		 *    It will not be add into the shffule buffer 
+		 * ***************************************/
+		if (block_id!=CommInfo.dummyID)
+		    System.arraycopy(bData, 0, s_buffer[realNumber++], 0, CommInfo.blockSize);
+
+		/***********************
+		 * Treate the special level, i.e., the top level
+		 * ************************/
+	    if (level != n_levels - 1) ++level;
+	    else{
+	    	System.out.println(" Filled!!!¡¡¡¡¡¡¡¡");
+	    }
+		/******************************************
+		 * Generate the dummy blocks and add them into the buffer 
+		 * ***************************************/    
+		int begin =  (1 << (level + 1)) - 2;
+		int sbuffer_len=0; 
+	    if (level != n_levels - 1) {
+	        sbuffer_len = 2 *(1 << level);
+	    } else sbuffer_len = top_level_len;
+		
+	    for (int i=realNumber;i<sbuffer_len;i++)
+	    {
+	    	//generate the data
+	    	Util.intToByte(s_buffer[i], 0, CommInfo.dummyID);
+	    	byte[] bDummy=Util.generateDummyData(CommInfo.blockSize-4);
+	    	System.arraycopy(bDummy, 0, s_buffer[i], 4, CommInfo.blockSize-4);
+	    }
+		/******************************************
+		 * Shuffle the plian data in the shufflebuffer
+		 * Then encrypt Them using the level key
+		 * ***************************************/
+	    psuedo_random_permute(s_buffer, sbuffer_len);
+	    //Reset the key and dummyID
+	    keys[level]=kg.generateKey(); 
+	    nextDummy[level]=0;
+		/******************************************
+		 * re-encrypt all the data
+		 * ***************************************/
+	    int bID=0;
+
+		SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+		scp.initEnc(keys[level], null); 
+		filled[level]=true;
+
+	    for (int i=0;i<sbuffer_len;i++)
+	    {
+	    	//set the flag and blockIDs
+	    	bID=Util.byteToInt(s_buffer[i], 0, 4);
+	    	int _id = begin+i;
+	    	if (bID==CommInfo.dummyID)
+	    		bID=CommInfo.dummyID-i;
+	    	else{ 
+				//update position map
+	    		pos_map[bID].partition=p;
+	    		pos_map[bID].level=level;
+	    		pos_map[bID].offset=i;
+	    	}
+			blockIDs[_id]=bID;
+	    	Util.intToByte(s_buffer[i], 0, bID);
+	    	flag[_id]=false;
+	    	
+	    	//encrypt 
+			scp.enc_decData(s_buffer[i], CommInfo.blockSize);
+			//partition + ID (_id) 
+			cmdData[0]=CommandType.writeBlock;
+			Util.intToByte(cmdData, 1, p);
+			Util.intToByte(cmdData, 5, _id);
+			Util.intToByte(cmdData, 9, CommInfo.blockSize);
+			//store into the database
+			cli.send(cmdData, 13, s_buffer[i], CommInfo.blockSize, null); 
+	    }
+	    for (int i=0;i<begin;i++)
+	    {
+			blockIDs[i]=CommInfo.dummyID; 
+	    	flag[i]=true;
+	    }
+	    realDataNumber=0;
+	    for (int i=begin;i<this.n_capacity;i++)
+	    {
+			if (blockIDs[i]>=0)
+				realDataNumber++;
+	    }
+    	
+	    Util.cloudcloudbandwidth += sbuffer_len*CommInfo.blockSize;
+
+		Util.writeNumber ++;
+		Util.bandwidth += CommInfo.blockSize + sbuffer_len*4;
+		Util.cloudtocloud ++;
+	}
+
+	 private void psuedo_random_permute(byte[][] sBuffer, int len) {
+		Util.writeNumber = Util.writeNumber+1;
+			
+		 Random rnd=new Random();
+		 byte[] bData=new byte[CommInfo.blockSize];
+	        for (int i = len- 1; i > 0; --i) {
+	            int j = rnd.nextInt(i);
+/*	            bData=sBuffer[i].clone();
+	            sBuffer[i] = sBuffer[j].clone();
+	            sBuffer[j] = bData.clone();*/ 
+	            System.arraycopy(sBuffer[i], 0, bData, 0, CommInfo.blockSize);
+	            System.arraycopy(sBuffer[j], 0, sBuffer[i], 0, CommInfo.blockSize);
+	            System.arraycopy(bData, 0, sBuffer[j], 0, CommInfo.blockSize); 
+	        }
+	    }
+
+	private int fetchLevel(int level, int length) { 
+		/******************************
+		 * Compute the position of begin and end
+		 * **********************************/
+		SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+		scp.initDec(keys[level], null);
+
+		int begin =  (1 << (level + 1)) - 2;
+		int level_len=0; 
+	    if (level != n_levels - 1) {
+	    	level_len = 2 *(1 << level);
+	    } else level_len = top_level_len;
+	    
+	    int _id=0;
+		
+		for (int j=0; j<level_len; j++)
+		{
+			_id=begin+j;
+			if (!flag[_id] && blockIDs[_id]>=0)
+			{
+				readBlock(p, level, j, s_buffer[length]);
+				/**************************
+				 * Decrypt it and judge whether it is a dummy block
+				 * *************************/
+				scp.enc_decData(s_buffer[length], CommInfo.blockSize);
+				length++;
+			} 
+			
+			//reset the flag
+			flag[_id]=true;
+		}
+		return length;
+	}
+
+	private void readBlock(int p, int level, int offset, byte[] recData) {  
+	    int begin =  (1 << (level + 1)) - 2;
+	    int _id = begin+offset;
+		cmdData[0]=CommandType.readBlock;
+		Util.intToByte(cmdData, 1, p);
+
+		//reset the read flag as true
+		flag[_id]=true;
+		Util.intToByte(cmdData, 5, _id); 
+			
+		cli.send(cmdData, 9,  null, 0, recData); 
+		
+	}
+	
+	public int nextDummy(int level)
+	{ 
+	    int begin =  (1 << (level + 1)) - 2;
+	    int end=0;
+	    if (level != n_levels - 1) {
+	        end = 2 *(1 << level);
+	    } else end = top_level_len;
+		//compute the position in the position map
+	    for (int i=nextDummy[level];i<end;i++)
+		    if (blockIDs[begin+i] <= CommInfo.dummyID)
+		    {
+		    	nextDummy[level]=i+1;
+		    	return i;
+		    }
+	    
+	    //Notice that, there is no dummy blocks
+	    //System.out.println("No dummy !!!!!! return 0!!!!!!!!");
+	    return -1;
+	}
+}

src/nankai/oram/common/CommInfo.java

@@ -0,0 +1,10 @@
+package nankai.oram.common;
+
+public interface CommInfo {
+
+	public static int dummyID=-1;
+	public static int keySize=16;//the length of a key   byte
+	public static int v=2;//the rate of evict operation 
+	public static int blockSize=128;//the length of a block    byte
+	public static double capacity_parameter=4.6;//4.6*N, the parameter of max capacity of partition
+}

src/nankai/oram/common/CommandType.java

@@ -0,0 +1,23 @@
+package nankai.oram.common;
+
+public interface CommandType {
+
+	public static byte initORAM=1; 
+	public static byte readBlock=2; 
+	public static byte writeBlock=3; 
+	public static byte readCloud=4; 
+	public static byte noticeWriteCloud=5; //client notices the cloud to be ready for the write operation
+	public static byte noticeShuffle=6; //client notices the cloud to be read for the shuffle operation
+	public static byte shuffleData=7; //cloud sends the shuffle data to the other cloud
+	public static byte backData=8;//the other cloud sends back the shuffled data
+	public static byte directWriteCloud=9; //client write to cloud the unfilled level directly
+	
+ 
+	
+
+	public static byte testTime=112;//the other cloud sends back the shuffled data
+	public static byte closeThread=111; 
+	
+
+	public static byte openDB=113;//the other cloud sends back the shuffled data
+}

src/nankai/oram/common/MongDBUtil.java

@@ -0,0 +1,66 @@
+package nankai.oram.common;
+
+import com.mongodb.*;
+import com.mongodb.client.*;
+
+public class MongDBUtil {
+	MongoClient conn;
+	MongoDatabase db;
+	
+	public void connect(String ip, int port, String dbName)
+	{
+		conn = new MongoClient(ip, port); 
+		db = conn.getDatabase(dbName);
+	}
+	public void connect(String ip, int port )
+	{
+		conn = new MongoClient(ip, port);  
+	} 
+	public boolean createDB(String dbName)
+	{
+		if (conn==null)
+		{
+			System.out.println("no connection");
+			return false;
+		} 
+		System.out.println("createDB "+dbName);
+		//first, drop it if exists
+		conn.dropDatabase(dbName);
+		//then, create 
+		db = conn.getDatabase(dbName);
+		return true;
+	}
+	public boolean openDB(String dbName)
+	{
+		if (conn==null)
+		{
+			System.out.println("no connection");
+			return false;
+		}   
+		System.out.println("openDB "+dbName);
+		db = conn.getDatabase(dbName);
+		return true;
+	}
+	/**
+	 * create table / collection 
+	 * use the default index '__id' as the unique index
+	 * @param collectioName
+	 * @return
+	 */
+	public boolean createCollection(String collectioName)
+	{
+		if (db==null)
+		{
+			System.out.println("no db");
+			return false;
+		}
+		db.createCollection(collectioName); 
+		return true;
+	}
+	
+	public MongoCollection getCollection(String collectioName)
+	{
+		return db.getCollection(collectioName);
+	}
+
+}

src/nankai/oram/common/ResponseType.java

@@ -0,0 +1,8 @@
+package nankai.oram.common;
+
+public interface ResponseType {
+
+	public static int wrong=0; 
+	public static int normal=1; //without value
+	public static int normalWithValue=2; //right run and some returned value   + LEN +DATA 
+}

src/nankai/oram/common/SocketClientUtil.java

@@ -0,0 +1,224 @@
+package nankai.oram.common;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+public class SocketClientUtil {
+	String ip;
+	int port;
+	
+	Socket socket;
+	DataInputStream  in;  
+	DataOutputStream out; 
+
+    byte recvMsg[];
+    byte sendMsg[];
+    
+    public static int responseType;//the returned value from the cloud server
+
+	public SocketClientUtil(String ip, int port) {
+		this.ip = ip;
+		this.port = port;
+		recvMsg=new byte[1024];//1k
+		sendMsg=new byte[4];//100k
+		responseType=0;
+	}
+	 
+
+	public boolean connect() {
+		try {
+			// 向本机的2121端口发出客户请求
+			socket = new Socket(ip, port);
+//			System.out.println("Established a connection...");   
+			
+			socket.setKeepAlive(true);
+			out = new DataOutputStream(socket.getOutputStream()); 
+			in = new DataInputStream(socket.getInputStream());
+			// 由Socket对象得到输出流,并构造PrintWriter对象
+		} catch (Exception e) {
+			System.out.println("Error connect.  " + e);
+			return false;
+		}
+//		System.out.println("success for connection. " );
+		return true;
+	}
+
+	public void disConnect() {
+		try { 			
+			out.write(CommandType.closeThread);
+			out.flush();
+			out.close(); // 关闭Socket输出流
+			in.close(); // 关闭Socket输入流
+			socket.close(); // 关闭Socket 
+		} catch (Exception e) {
+			System.out.println("Error. " + e);
+		}
+	}
+	
+
+	/**
+	 * 
+	 * @param type  request command type
+	 * @param cmdInfo some information for specific command 
+	 * @param cmdLen the length of the cmdInfo
+	 * @param sendData  the data which contains the concrete command information
+	 * @param dataLen   the data length
+	 * @param receiveData TODO
+	 * @param retValue the returned data
+	 * @return
+	 */
+	public void send(byte[] cmdInfo, int cmdLen, byte[] sendData, int dataLen, byte[] receiveData) {
+		try { 
+			/************************
+			 * Send 
+			 * (1) the request - command
+			 * CommandType | len | data
+			 * And (2) the message content
+			 * *************************/  
+			
+			out.write(cmdInfo, 0, cmdLen);  
+			out.flush();
+			if (dataLen > 0) {
+//			    out.write(sendData, 0, dataLen);  
+//			    out.flush();
+ 	    
+				if (dataLen<512)
+				{
+				    out.write(sendData, 0, dataLen);  
+				    out.flush();
+				}else{ 
+					int num = dataLen / 512  ;
+					int leftLen = dataLen % 512;
+					int hasSend = 0;
+					for (int i=0;i<num;i++)
+					{ 
+						out.write(sendData, hasSend, 512);
+						out.flush();
+						hasSend += 512;
+					}
+					if (leftLen>0){
+					    out.write(sendData, hasSend, leftLen);
+					    out.flush();
+					}
+				}
+				/*********************
+				 * Send them with different block
+				 * *********************/
+			}
+  
+			/*************************
+			 * Receive the response
+			 * ResponseType | len | data
+			 * *********************/
+			while (in.read(recvMsg, 0, 1024)  > 0) {
+				break;
+			}
+			responseType=recvMsg[0]; 
+		    //System.out.println("server return：" + responseType); 
+			if (responseType==ResponseType.wrong){
+				System.out.println(cmdInfo[0]+"  "+cmdLen+"  "+dataLen+"........");
+
+				for (int i=0;i<cmdLen;i++)
+					System.out.print(cmdInfo[i]+" "); 
+				System.out.println();
+				
+				for (int i=0;i<3;i++)
+					System.out.print(sendData[i]+" "); 
+				System.out.println();
+				
+				
+			    System.out.println("Return error value!");
+			}else{
+			    //System.out.println("server return success：" + responseType); 
+				if (responseType == ResponseType.normalWithValue)
+				{ 
+					int retLen=0;
+					while ( (retLen = in.read(recvMsg, 0, 1024))  > 0) {
+						break;
+					}
+					
+					if (retLen != CommInfo.blockSize)
+					    System.out.println("Wrong length" ); 
+					
+					if (receiveData!=null && retLen == CommInfo.blockSize)
+					    System.arraycopy(recvMsg, 0, receiveData, 0, retLen);  
+				}
+			}
+		} catch (IOException e) {
+			e.printStackTrace(); 
+		}
+	}
+	
+
+	public void send(byte[] sendData, int dataLen) {
+		try { 
+//		    out.write(sendData, 0, dataLen);  
+//		    out.flush(); 
+			if (dataLen<512)
+			{
+			    out.write(sendData, 0, dataLen);  
+			    out.flush();
+			}else{ 
+				int length = dataLen / 512;
+				int leftLen = dataLen % 512;
+				int pos = 0;
+
+				for (int i = 0; i < length; i++) {
+					out.write(sendData, pos, 512);
+					out.flush();
+					pos += 512;
+				}
+				if (leftLen > 0) {
+					out.write(sendData, pos, leftLen);
+					out.flush();
+				}
+			}
+		} catch (IOException e) {
+			e.printStackTrace(); 
+		}
+	}
+	
+
+	public int receiving(byte[] recvData, int len) {
+		int retLen = -1;
+		try {   
+			retLen = in.read(recvData, 0, len) ;
+		} catch (IOException e) {
+			e.printStackTrace(); 
+		}
+		return retLen;
+	}
+	
+
+	public void sendAndReceive(byte[] cmdInfo, int cmdLen) {
+		try {  
+
+			out.write(cmdInfo, 0, cmdLen);  
+			out.flush();
+			
+			/*************************
+			 * Receive the response
+			 * ResponseType | len | data
+			 * *********************/
+			while (in.read(recvMsg, 0, 1024)  > 0) {
+				break;
+			}
+			responseType=recvMsg[0]; 
+		    //System.out.println("server return：" + responseType); 
+			if (responseType==ResponseType.wrong){
+				System.out.println(cmdInfo[0]+"  "+cmdLen+"........");
+			}
+		} catch (IOException e) {
+			e.printStackTrace(); 
+		}
+	}
+
+}

src/nankai/oram/common/SymmetricCypto.java

@@ -0,0 +1,65 @@
+package nankai.oram.common;
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.IvParameterSpec;
+
+public class SymmetricCypto {
+	  Cipher cp;
+	  int keySize; 
+	  static final String CIPHER_ALGORITHM_CBC_NoPadding = "AES/CBC/NoPadding";  
+	  
+	  byte[] iv;
+	  public SymmetricCypto(int keysize)
+	  {
+	      try {
+			cp=Cipher.getInstance(CIPHER_ALGORITHM_CBC_NoPadding);
+			keySize=keysize; 
+			iv=new byte[16];
+			for (int i=0;i<16;i++)
+				iv[i]=0;
+		} catch (NoSuchAlgorithmException e) { 
+			e.printStackTrace();
+		} catch (NoSuchPaddingException e) { 
+			e.printStackTrace();
+		}
+	  }
+	  
+	  
+	public void initEnc(SecretKey sk, byte[] IV) {
+		try {
+			cp.init(Cipher.ENCRYPT_MODE, sk, new IvParameterSpec( (IV==null)?iv:IV ));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	  public void initDec(SecretKey sk, byte[] IV)
+	  {
+		try {
+			cp.init(Cipher.DECRYPT_MODE, sk, new IvParameterSpec( (IV==null)?iv:IV ));
+		} catch (Exception e) { 
+			e.printStackTrace();
+		}
+	  }
+	  
+	  public void enc_decData(byte[] bData, int len)
+	  {
+		  int blockNumber = len/keySize;
+		  for (int i=0;i<blockNumber;i++)
+		  {
+			  try {  
+				cp.doFinal(bData, i*keySize, keySize, bData, i*keySize);
+			} catch (Exception e) { 
+				e.printStackTrace();
+			}
+		  }
+	  } 
+
+}

src/nankai/oram/common/Util.java

@@ -0,0 +1,120 @@
+package nankai.oram.common;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.Random; 
+
+import javax.crypto.SecretKey;
+
+import nankai.oram.client.MCloudCommInfo;
+
+
+public class Util {
+	
+	public static boolean debug = false;
+	public static int writeNumber = 0; //
+	public static int cloudtocloud = 0; //
+	public static long bandwidth = 0; //
+	public static long cloudcloudbandwidth = 0; //
+	public static long readbandwidth = 0; //
+	public static int readNumber = 0; //
+
+	public static int byteToInt(byte[] src, int pos, int len)
+	{
+		int ret = 0;
+		for(int i =0; i< len; i++){
+			ret += (src[pos+i]&0xff) << (24-8*i);
+		}
+		return ret;
+	}
+
+	public static void intToByte(byte[] dest, int pos, int value) { 
+		dest[pos+3] = (byte) (value & 0xff);
+		dest[pos+2] = (byte) (value >> 8 & 0xff);
+		dest[pos+1] = (byte) (value >> 16 & 0xff);
+		dest[pos+0] = (byte) (value >> 24 & 0xff);
+	}
+	
+	public static int rand_int(int maxNum)
+	{
+		Random rnd=new Random(); 
+		if (maxNum<=0) maxNum=1;
+		return Math.abs(rnd.nextInt(maxNum)); 
+	}
+	
+	public static byte[] generateDummyData( int len)
+	{
+		byte[] bData=new byte[len];
+//		Random rnd=new Random();
+//		rnd.nextBytes(bData);
+		for (int i=0;i<len;i++)
+			bData[i]=-1;
+		return bData;
+	}
+
+	public static byte[] generateSessionData( int len)
+	{
+		byte[] bData=new byte[len];
+		Random rnd=new Random();
+		rnd.nextBytes(bData); 
+		return bData;
+	}
+
+	public static byte[] generateIV(int dummyID) {
+		byte[] iv=new byte[16];
+		Util.intToByte(iv, 0, dummyID); 
+		for (int i=4;i<16;i++)
+		{
+			iv[i] = 0;
+		}
+		return iv;
+	}
+	
+	public static int fpeForPermution(int inData, SecretKey sfk, int modular)
+	{
+		SymmetricCypto scp =new SymmetricCypto(CommInfo.keySize);
+		scp.initEnc(sfk, null);	
+		byte[] bData = new byte[CommInfo.keySize];
+		for (int j=0; j<CommInfo.keySize; j++)
+			bData[j]=(byte) inData;
+		scp.enc_decData(bData, CommInfo.keySize);
+		int ret = Math.abs(  Util.byteToInt(bData, 0, 4) );
+		return ret % modular; 
+	}
+	 
+//	public static byte[] hexStringToByte(String hex) {   
+//	    int len = (hex.length() / 2);   
+//	    byte[] result = new byte[len];   
+//	    char[] achar = hex.toCharArray();   
+//	    for (int i = 0; i < len; i++) {   
+//	     int pos = i * 2;   
+//	     result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));   
+//	    }   
+//	    return result;   
+//	}  
+//	  
+//	private static byte toByte(char c) {   
+//	    byte b = (byte) "0123456789ABCDEF".indexOf(c);   
+//	    return b;   
+//	}  
+//	  
+//	/** *//**  
+//	    * 把字节数组转换成16进制字符串  
+//	    * @param bArray  
+//	    * @return  
+//	    */   
+//	public static final String bytesToHexString(byte[] bArray) {   
+//	    StringBuffer sb = new StringBuffer(bArray.length);   
+//	    String sTemp;   
+//	    for (int i = 0; i < bArray.length; i++) {   
+//	     sTemp = Integer.toHexString(0xFF & bArray[i]);   
+//	     if (sTemp.length() < 2)   
+//	      sb.append(0);   
+//	      sb.append(sTemp.toUpperCase());   
+//	    }   
+//	    return sb.toString();   
+//	}  
+}

src/nankai/oram/interfaces/MultiCloudORAM.java

@@ -0,0 +1,14 @@
+package nankai.oram.interfaces;
+
+import java.util.Queue;
+
+import nankai.oram.client.common.SlotObject;
+
+public interface MultiCloudORAM {
+	 
+	public byte[] readCloud(String key);
+
+	public void writeCloud(Queue slot);
+	public byte[] readCloud(int key);
+
+}

src/nankai/oram/interfaces/ORAM.java

@@ -0,0 +1,10 @@
+package nankai.oram.interfaces;
+
+public interface ORAM {
+
+	public void write(String idStr, byte[] value);
+	public byte[] read(String idStr);
+	public void write(int id, byte[] value);
+	public byte[] read(int id);
+
+}

src/nankai/oram/server/SessionManager.java

@@ -0,0 +1,45 @@
+package nankai.oram.server;
+
+import java.util.Vector;
+
+public class SessionManager {
+	public static SessionManager instance;
+	
+	public Vector objects ;
+	public synchronized static SessionManager getInstance()
+	{
+		if (instance==null)
+			instance=new SessionManager();
+		return instance;
+	}
+	
+	private SessionManager()
+	{
+		objects = new Vector();
+	}
+	
+	public synchronized  SessionObject getObject(byte[] sessionID)
+	{
+		SessionObject obj = null;
+		int size = objects.size(); 
+		for (int i=0; i<size; i++)
+		{
+			obj = (SessionObject) objects.get(i);
+			if (obj.isEqual(sessionID) )
+				return obj;
+		}
+		return null;
+	}
+
+	public synchronized void addObject(SessionObject obj)
+	{
+		objects.add(obj);
+		//System.out.println("2. add --------------------size: "+objects.size());
+	}
+	public synchronized void removeObject(SessionObject obj)
+	{
+		objects.remove(obj);
+		//System.out.println("4. remove -----------------size: "+objects.size());
+	}
+
+}

src/nankai/oram/server/SessionObject.java

@@ -0,0 +1,132 @@
+package nankai.oram.server;
+
+import java.util.Random;
+
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+
+import nankai.oram.client.MCloudCommInfo;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.SymmetricCypto;
+import nankai.oram.common.Util;
+
+public class SessionObject {
+	
+	public byte[] sessionID;
+	public byte[] levels;
+	public int idsLen = 0; 
+	byte[][] shffule;
+	public int filledLevelLength;
+	public SecretKey key[];
+	public int unfilledLevel;
+	SecretKey sfk; //onion level key and shuffle key
+	SymmetricCypto scp;
+	
+	int bPos =0;
+	
+	public SessionObject(byte[] sid)
+	{
+		scp =new SymmetricCypto(CommInfo.keySize);
+		//System.out.print("2. add session ");
+		sessionID = new byte[8];
+		for(int i=0;i<8;i++){
+			//System.out.print(sid[i]+" ");
+			sessionID[i]=sid[i];
+		}
+		//System.out.println();
+	}
+	
+	public void setLevels(byte[] ls, int len)
+	{
+		if (ls!=null)
+			;//System.out.println("has received IDs and levels Data!!");
+		idsLen=len; 
+		levels=new byte[idsLen]; 
+		System.arraycopy(ls, 0, levels, 0, len); 
+	}
+	
+	public boolean isEqual(byte[] sid)
+	{
+		for(int i=0;i<8;i++)
+		{
+			if (sessionID[i]!=sid[i])
+				return false;
+		}
+		return true;
+	}
+	
+	public void createShuffle(int filledLevelLength)
+	{
+		this.filledLevelLength = filledLevelLength; 
+        shffule=new byte[filledLevelLength][CommInfo.blockSize]; 
+        bPos = 0;
+	}
+	
+	public void createkey(int unfilledLevel)
+	{
+		this.unfilledLevel = unfilledLevel;
+		key = new SecretKey[unfilledLevel+1];
+	}
+	
+	public void setKey(int level, byte[] bdata)
+	{
+		key[level] = new SecretKeySpec(bdata, "AES");
+	}
+	
+	public void setSFKey( byte[] bdata)
+	{
+
+//		System.out.print("setSFKey   " );
+//		for (int i=0;i<6;i++)
+//			System.out.print ( bdata[i]+" " );
+//		System.out.println(  );
+		
+		sfk = new SecretKeySpec(bdata, "AES");
+	}
+	
+	public void setBlockData(int pos, byte[] bdata)
+	{
+		bPos++;
+		System.arraycopy(bdata, 0, shffule[pos], 0, CommInfo.blockSize);
+	}
+	
+	public void setBlockData( byte[] bdata)
+	{ 
+		System.arraycopy(bdata, 0, shffule[bPos++], 0, CommInfo.blockSize);
+	}
+	public void setBlockDataWithOnionDecryption(int pos, byte[] bdata, int level)
+	{
+//		System.out.println("shuffleData: onion decryption: -> level:"+level+" pos:"+pos);
+//		scp.initDec(key[level], null);
+//		scp.enc_decData(bdata, CommInfo.blockSize); 
+		
+		System.arraycopy(bdata, 0, shffule[pos], 0, CommInfo.blockSize);
+	}
+
+	public void psuedo_random_permute() { 
+		byte[] bData = new byte[CommInfo.blockSize];
+		
+
+//		for (int i = 0; i < filledLevelLength; i++) {
+//			System.out.println("i: "+i+"  "+shffule[i][0]); 
+//		}
+		
+		for (int i = 0; i <filledLevelLength; i++) { 
+			
+			int j = Util.fpeForPermution(i, sfk, filledLevelLength); 
+			System.arraycopy(shffule[i], 0, bData, 0, CommInfo.blockSize);
+			System.arraycopy(shffule[j], 0, shffule[i], 0, CommInfo.blockSize);
+			System.arraycopy(bData, 0, shffule[j], 0, CommInfo.blockSize);
+
+//			System.out.println("permute: "+i+"  "+j);
+		}
+	}
+	 
+
+	public void onionEncryption() {  
+//		for (int i = 0; i <filledLevelLength; i++) {  
+//			scp.initEnc(sfk, null);	
+//			scp.enc_decData(shffule[i], CommInfo.blockSize);
+//		}
+	}
+}

src/nankai/oram/server/ThinORAMserver.java

@@ -0,0 +1,152 @@
+package nankai.oram.server;
+
+import java.io.UnsupportedEncodingException;
+
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.MongDBUtil;
+import nankai.oram.server.partition.PartitionORAMServer;
+
+import org.bson.Document;
+
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoCursor;
+
+public class ThinORAMserver {
+		public static ThinORAMserver instance;
+		byte cloud;
+		boolean initFlag;
+		int N;
+		int n_levels;
+		int n_partitions;
+		int n_blocks;
+		int n_realBlocks_p;//the real number of blocks in a partition 
+		int n_capacity;//the max capacity of a partition -- need the top level 
+		public MongDBUtil dbUtil;
+		byte[] bBlockData;
+		
+
+		byte s_buffer[][];//shuffule buffer - a large memory 
+
+		private ThinORAMserver()
+		{
+			bBlockData=new byte[CommInfo.blockSize];
+		    initFlag=false;
+			dbUtil=new MongDBUtil();
+		    dbUtil.connect("localhost", 27017);
+		    cloud = 0;
+		}
+		public static ThinORAMserver getInstance()
+		{
+			if (instance==null)
+				instance=new ThinORAMserver();
+			return instance;		
+		}
+		/**
+		 * This function will create the database for the ORAM
+		 */
+		public boolean init(int paritions, int capacity, int levels, byte cloud)
+		{
+			if (initFlag)
+				return false; 
+			n_partitions = paritions; 
+		    n_capacity = capacity; 
+		    n_levels = levels;
+		    this.cloud = cloud;
+		    
+		    //Create DB and open DB
+		    if (!dbUtil.createDB("ThinPartitionORAM"+cloud))
+		    	return false;
+		    //init partitions: create the table/collection for the partitions
+		    try {
+				initPartitions();
+			} catch (UnsupportedEncodingException e) {
+				// TODO ×Ô¶¯Éú³ÉµÄ catch ¿é
+				e.printStackTrace();
+			    return false;
+			}
+		    
+		    initFlag=true;
+		    return true;
+		}
+		
+
+		public boolean openDB(byte cloud)
+		{ 
+			this.cloud=cloud;
+		    if (!dbUtil.openDB("ThinPartitionORAM"+cloud))
+		    	return false;
+		    return true;
+		}
+		
+		public boolean writeBlock(int p, int _id, byte[] blockData, int pos) throws UnsupportedEncodingException
+		{
+			System.arraycopy(blockData, pos, bBlockData, 0, CommInfo.blockSize);
+
+			MongoCollection<Document> collection = dbUtil.getCollection("part_"+p);  
+			
+			String str=new String(bBlockData, "ISO-8859-1"); 
+
+	        collection.findOneAndReplace(new Document("_id", _id), new Document("_id", _id).append("data", str));
+	        
+			return true;
+		}
+		
+
+		public boolean readBlock(int p, int _id, byte[] receiveData)  {
+			boolean bError = false;
+			try{
+			MongoCollection<Document> collection = dbUtil
+					.getCollection("part_" + p);
+			// Find the data and return them
+
+			FindIterable<Document> findIterable = collection.find(new Document(
+					"_id", _id));
+			MongoCursor<Document> mongoCursor = findIterable.iterator();
+			if (mongoCursor.hasNext()) {
+				Document doc1 = mongoCursor.next(); 
+	 
+				String bData = (String) doc1.get("data");
+				
+				byte[] bs = bData.getBytes("ISO-8859-1"); 
+
+				System.arraycopy(bs, 0, receiveData, 0, CommInfo.blockSize);
+				return true;
+			}
+			}catch(Exception ex)
+			{
+				bError=true;
+				ex.printStackTrace();
+			}finally{
+				if (bError) 
+					System.out.println("!!!!!!!!!!!!!!!!!readBlock mongdbError,p:"+p+"  _id:"+_id);
+			}
+
+			return false;
+		}
+		
+		private void initPartitions() throws UnsupportedEncodingException
+		{
+			int i=0;
+			for (i=0;i<n_partitions;i++)
+			{
+				dbUtil.createCollection("part_"+i);
+				
+				//insert all the data records into the collection
+
+				MongoCollection<Document> collection = dbUtil.getCollection("part_"+i);
+				//Each level, there are max 2^i real blocks, but more than 2^i dummy blocks
+				for (int j = 0; j < n_capacity; j++) {
+					/*collection.insertOne(new Document("_id", j).append("data",
+							new String(bBlockData, "ISO-8859-1")));*/
+					collection.insertOne(new Document("_id", j).append("data",
+							bBlockData ));
+				}
+				/***************************************
+				 * Each level, there are 2^(i+1) blocks
+				 * ***********************************/
+	 
+			}
+			
+		}
+	}

src/nankai/oram/server/ThinPartitionServerThread.java

@@ -0,0 +1,640 @@
+package nankai.oram.server;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.Socket;
+
+import javax.crypto.SecretKey;
+
+import nankai.oram.client.MCloudCommInfo;
+import nankai.oram.common.CommInfo;
+import nankai.oram.common.CommandType;
+import nankai.oram.common.ResponseType;
+import nankai.oram.common.SocketClientUtil;
+import nankai.oram.common.Util;
+
+public class ThinPartitionServerThread extends Thread {
+
+	Socket socket = null; // 保存与本线程相关的Socket对象
+	byte recvCmd[];
+	byte recvMsg[];
+	byte sendMsg[];
+	ThinORAMserver oram;
+
+	public ThinPartitionServerThread(Socket socket) {
+		this.socket = socket;
+		recvCmd = new byte[29];
+		recvMsg = new byte[1024];
+		sendMsg = new byte[1024];
+		oram = ThinORAMserver.getInstance();
+		//System.out.println(" new connection ......... ");
+	}
+
+	public void run() {
+		DataInputStream in = null;
+		DataOutputStream out = null;
+		try {
+
+			in = new DataInputStream(socket.getInputStream());
+			out = new DataOutputStream(socket.getOutputStream());
+
+			byte type = 0;
+			int len = 0;
+
+			while (true) {
+				type = 0;
+				len = 0;
+				while ((len = in.read(recvCmd, 0, 1)) > 0) {
+					type = recvCmd[0];
+//					System.out
+//							.println("-----------------------------------------------------------");
+//					System.out.println("receive a command type:" + type + "  len  "
+//							+ len);
+					break;
+				}
+				
+				//close the thread
+				if (type == CommandType.closeThread)
+					break;
+
+				switch (type) {
+				case CommandType.openDB:
+				{
+					in.read(recvCmd, 1, 1);
+					oram.openDB(recvCmd[1]);
+					out.writeByte(ResponseType.normal);
+					out.flush(); 
+					
+					break;
+				}
+				case CommandType.initORAM: {
+					len = in.read(recvCmd, 1, 13);
+					if (len != 13) {
+						System.out.println("initORAM　error data!　" + len);
+						out.writeByte(ResponseType.wrong);
+						out.flush();
+					} else
+						initORAM(out);
+					break;
+				}
+				case CommandType.readCloud: {
+					len = in.read(recvCmd, 1, 8);
+					if (len != 8) {
+						System.out.println("readCloud　error data!　" + len);
+						out.writeByte(ResponseType.wrong);
+						out.flush();
+					} else {
+						/**************************************
+						 * partition+_id
+						 * **********************************/
+						readCloud(out, in);
+					}
+					break;
+				}
+				case CommandType.noticeWriteCloud: {
+					len = in.read(recvCmd, 1, 21);
+					// content: session ID | unfilled - partition | other cloud for shuffling | length of ids
+					if (len != 21) {
+						System.out.println("noticeWriteCloud　error data!　" + len);
+						out.writeByte(ResponseType.wrong);
+						out.flush();
+					} else {
+						/**************************************
+						 * partition+_id
+						 * **********************************/
+						noticeWriteCloud(out, in);
+					}
+					
+					break; 
+				}
+				case CommandType.directWriteCloud:
+				{
+					len = in.read(recvCmd, 1, 12);
+					// content: session ID | unfilled - partition | other cloud for shuffling | length of ids
+					if (len != 12) {
+						System.out.println("directWriteCloud　error data!　" + len);
+						out.writeByte(ResponseType.wrong);
+						out.flush();
+					} else {
+						/**************************************
+						 * partition+_id
+						 * **********************************/
+						directWriteCloud(out, in);
+					}
+					break;					
+				}
+				case CommandType.noticeShuffle: {
+					len = in.read(recvCmd, 1, 28);
+					// content: session ID | unfilled - partition | other cloud for shuffling | length of ids
+					if (len != 28) {
+						System.out.println("noticeWriteCloud　error data!　" + len);
+						out.writeByte(ResponseType.wrong);
+						out.flush();
+					} else {
+						/**************************************
+						 * partition+_id
+						 * **********************************/
+						noticeShuffle(out, in);
+					}
+					
+					break; 
+				}
+				case CommandType.shuffleData:{
+					len = in.read(recvCmd, 1, 12);
+					if (len != 12) {
+						System.out.println("shuffleData　error data!　" + len);
+						for (int i=0;i<len;i++)
+							System.out.print(recvCmd[i]+" ");
+						out.writeByte(ResponseType.wrong);
+						out.flush();
+					} else {
+						/**************************************
+						 * partition+_id
+						 * **********************************/
+						shuffleData(out, in);
+					}
+					
+					break; 
+				} 
+				}
+
+			}
+
+		} catch (Exception e) {
+			System.out.println("Error.?>>>>> " + e);
+			e.printStackTrace();
+		} finally {
+			try {
+				out.close(); // 关闭Socket输出流
+				in.close();// 关闭Socket输入流
+				socket.close(); // 关闭Socket
+			} catch (IOException e1) {
+				e1.printStackTrace();
+			}
+		}
+		//System.out.println("closing............................ ");
+	}
+
+	private void initORAM(DataOutputStream out) throws IOException {
+		/*********
+		 * CMD 9, CMDTYPE | PARTITIONS | CAPACITY
+		 * *********/
+//		System.out.println("init oram");
+
+		int paritions = Util.byteToInt(recvCmd, 1, 4);
+		int capacity = Util.byteToInt(recvCmd, 5, 4);
+		int levels = Util.byteToInt(recvCmd, 9, 4);
+		byte cloud = recvCmd[13];
+//		System.out.println("init paritions capacity:" + paritions + "  "
+//				+ capacity);
+		oram.init(paritions, capacity, levels, cloud);
+
+//		System.out.println("init OK.");
+		out.writeByte(ResponseType.normal);
+		out.flush();
+	}
+	
+	/**
+	 * When receive this data,  the cloud would read data and send them to the other cloud
+	 * @param out
+	 * @param in
+	 * @throws IOException
+	 */
+	private void shuffleData(DataOutputStream out, DataInputStream in)
+			throws IOException {
+		/**************************************** 
+		 * (2)Send All the data, onionkeys in slots to the otherCloud 
+		 * 
+		 * CommandType: shuffleData
+		 * Content: session ID | unfilled levels number | 
+		 *          onion keys and slots data  
+		 * ************************************/
+		
+		byte[] sessionID = new byte[8];
+
+		System.arraycopy(recvCmd, 1, sessionID, 0, 8); 
+		int idsLen = Util.byteToInt(recvCmd, 9, 4);  
+
+		//System.out.println("4. shuffleData " + sessionID[0]);
+		/**************************************************************
+		 * Get the session Object, must be received, because client first send noticeShuffle, 
+		 * and then the target cloud sends the shuffled data
+		 *************************************************************/ 
+		SessionManager manager=SessionManager.getInstance();
+		SessionObject session = manager.getObject(sessionID);
+		if (session==null)
+		{
+			//create it 
+			System.out.println("Cannot find the session OBJECT!!!!!!!!!!!!!!!!!!!!!!!"+sessionID[0]+"  "+sessionID[5]);
+			return;
+			//session=new SessionObject(sessionID);
+		}
+		//verify the length
+		if (idsLen != session.idsLen)
+			System.out.println("wrong ID number!!!!!!!!!!!!!!!!!!!!!!! idsLen:"+idsLen+"  "+session.idsLen);
+
+		//System.out.println("shuffleData: idsLen "+idsLen);
+		
+		int filledLevelLength = session.filledLevelLength;
+		/***********************************************
+		 * Receive the block data from other cloud 
+		 * 
+		 * Firstly, onion decrypt them
+		 *******************************************/
+		byte[] recBlcokData = new byte[CommInfo.blockSize];
+		for (int i=0;i<idsLen; i++)
+		{ 
+			if (in.read(recBlcokData, 0, CommInfo.blockSize) <= 0) {
+				System.out.println("shuffleData: ERROR id block data!!!!!!!!!!!!!!!!!!!!!!!!");
+			}
+			/********************  do the onion decryption ********************************/ 
+			session.setBlockDataWithOnionDecryption(filledLevelLength - idsLen + i, recBlcokData, session.levels[i]);
+		}
+		 
+		/*****************************************
+		 * Finally, shuffule them
+		 *******************************************/
+//		System.out.println("begin psuedo_random_permute ");
+		session.psuedo_random_permute();
+		//re-encrypt them and send backs
+		session.onionEncryption();
+		 
+		/***********************
+		 * return back the data 
+		 * ********************************/ 
+		byte[] backCmd=new byte[5];
+		backCmd[0]=CommandType.backData;
+		Util.intToByte(backCmd, 1, session.filledLevelLength);
+		
+		out.write(backCmd, 0, 5);
+		out.flush(); 
+		for (int i=0;i<session.filledLevelLength;i++)
+		{
+			out.write(session.shffule[i], 0, CommInfo.blockSize);
+			out.flush(); 
+		}
+		
+		//The end of the session
+		manager.removeObject(session);
+	}
+	
+
+	private void directWriteCloud(DataOutputStream out, DataInputStream in)
+			throws IOException {
+		/**************************************** 
+		 * (1)Send All the data, onionkeys in slots to the otherCloud 
+		 * 
+		 * CommandType: shuffleData
+		 * Content: session ID | unfilled levels number | 
+		 *          onion keys and slots data  
+		 * ************************************/
+		
+		//System.out.println("directWriteCloud"); 
+ 
+		int partition = Util.byteToInt(recvCmd, 1, 4);
+		int unfilledLevel = Util.byteToInt(recvCmd, 5, 4); 
+		int filledLevelLength = Util.byteToInt(recvCmd, 9, 4);   ;
+		
+		/*******************
+		 * Has received the write operation command?
+		 * If not, create the session object
+		 * *********************/  
+		byte[] recBlcokData = new byte[CommInfo.blockSize];
+		int beginID=(1 << (unfilledLevel + 1)) - 2;
+		for (int i=0;i<filledLevelLength;i++)
+		{
+			if (in.read(recBlcokData, 0, CommInfo.blockSize) <= 0) {
+				System.out.println("ERROR read data!!!!!!!!!!!!!!!!!!!!!!!!");
+			}else{ 
+				oram.writeBlock(partition, beginID+i, recBlcokData, 0);
+			}
+			//System.out.println("i: "+i+ "  "+recBlcokData[0]); 
+		}
+		 
+		//read the sfk 
+		byte[] sfk=new byte[2];
+		if (in.read(sfk, 0, 2) <= 0) {
+			System.out.println("ERROR read key data!!!!!!!!!!!!!!!!!!!!!!!!");
+		} 
+		out.writeByte(ResponseType.normal);
+		out.flush(); 
+		 
+	}
+	/**
+	 * When receive this data,  the cloud would read data and send them to the other cloud
+	 * @param out
+	 * @param in
+	 * @throws IOException
+	 */
+	private void noticeShuffle(DataOutputStream out, DataInputStream in)
+			throws IOException {
+		/**************************************** 
+		 * (1)Send All the data, onionkeys in slots to the otherCloud 
+		 * 
+		 * CommandType: shuffleData
+		 * Content: session ID | unfilled levels number | 
+		 *          onion keys and slots data  
+		 * ************************************/
+		
+		//System.out.println("1. noticeShuffle");
+		byte[] sessionID = new byte[8];
+
+		System.arraycopy(recvCmd, 1, sessionID, 0, 8);
+		int partition = Util.byteToInt(recvCmd, 9, 4);
+		int unfilledLevel = Util.byteToInt(recvCmd, 13, 4); 
+		int filledLevelLength = Util.byteToInt(recvCmd, 17, 4); 
+		int idsLen = Util.byteToInt(recvCmd, 21, 4);  
+		int evictSize = Util.byteToInt(recvCmd, 25, 4);
+//		System.out.println(" partition "+ partition +" unfilledLevel "+ unfilledLevel+" filledLevelLength "+filledLevelLength+" idsLen "+idsLen );
+		int rndLength = filledLevelLength - idsLen - 2*evictSize;
+		if (rndLength<0)
+			System.out.println(" rndLength "+ rndLength +" filledLevelLength "+filledLevelLength+" idsLen "+idsLen+" evictSize "+evictSize );
+			
+		
+		if (filledLevelLength <=0 )
+			;//System.out.println("ERROR!!!!!!!!!!!!!!!!!!!!!!!!");
+		
+		/*******************
+		 * Has received the write operation command?
+		 * If not, create the session object
+		 * *********************/
+		SessionManager manager=SessionManager.getInstance();
+		SessionObject session = manager.getObject(sessionID);
+		if (session==null)
+		{
+			//create it 
+			session=new SessionObject(sessionID);
+		}
+		
+		//receive the IDs
+		byte[] levels = new byte[idsLen];
+		if (idsLen>0){
+			// read all the ids
+//			if (in.read(levels, 0, idsLen) <= 0)
+//				System.out.println("ERROR read IDs data!!!!!!!!!!!!!!!!!!!!!!!!");
+			 
+			readSocketLongData(in, idsLen, levels); 
+			
+			
+		}else{
+			;//System.out.println("ids Len is 0!!");
+		}
+		session.setLevels(levels, idsLen);
+		
+		
+		//receive each data and buffer them
+		session.createShuffle(filledLevelLength); 
+		byte[] recBlcokData = new byte[CommInfo.blockSize];
+		for (int i=0;i< 2*evictSize ;i++)
+		{
+			if (in.read(recBlcokData, 0, CommInfo.blockSize) <= 0) {
+				System.out.println("ERROR read data!!!!!!!!!!!!!!!!!!!!!!!!");
+			}
+			//System.out.println("i: "+i+ "  "+recBlcokData[0]);
+			session.setBlockData(i, recBlcokData);
+		}
+		
+		/*******************************************************
+		 * read the random value and generate the dummy data 
+		 ******************************************************/
+		byte[] rnds=new byte[rndLength*4];
+		{
+
+
+			readSocketLongData(in, rndLength*4, rnds);
+			 
+			for (int i=0;i<rndLength;i++)
+			{
+				int did=Util.byteToInt(rnds, i*4, 4);
+				//add the dummy block into the buffer
+				session.setBlockData(i+2*evictSize, this.generateXORBlock(did));
+			}
+			
+		}
+		
+		//receive the onion keys
+		session.createkey(unfilledLevel);
+		byte[] bkeyData = new byte[CommInfo.keySize];
+		for (int i=MCloudCommInfo.severBeginLevel; i<=unfilledLevel; i++)
+		{
+			if (in.read(bkeyData, 0, CommInfo.keySize) <= 0) {
+				System.out.println("ERROR read key data!!!!!!!!!!!!!!!!!!!!!!!!");
+			}
+			session.setKey(i, bkeyData);
+		}
+		
+		//read the sfk 
+		byte[] sfk=new byte[16];
+		if (in.read(sfk, 0, 16) <= 0) {
+			System.out.println("ERROR read key data!!!!!!!!!!!!!!!!!!!!!!!!");
+		}
+		
+		session.setSFKey(sfk);
+		manager.addObject(session);
+		
+		out.writeByte(ResponseType.normal);
+		out.flush(); 
+		
+	}
+	
+
+	public byte[] generateXORBlock(int dummyID)
+	{
+		//Encrypt the 0x00 default value by the userkey
+		byte[] data=new byte[CommInfo.blockSize];
+		for (int i=0;i<CommInfo.blockSize;i++)
+		{
+			data[i] = 0;
+		}
+		
+//		SecretKey userKey;
+//		/****************************
+//		 * The first 4 bytes is the dummmyID and the random value, to make sure it is less than 0
+//		 * 
+//		 * But now, to simplify the implementation, we ignore the random value for the same 0000000
+//		 * ******************************/
+//		
+//		byte[] iv = Util.generateIV(dummyID);
+		
+		//encrypt		
+//		SymmetricCypto scp=new SymmetricCypto(CommInfo.keySize);
+//		scp.initEnc(userKey, iv);
+//		scp.enc_decData(data, CommInfo.blockSize); 
+		return data;
+	}
+	
+	/**
+	 * When receive this data,  the cloud would read data and send them to the other cloud
+	 * @param out
+	 * @param in
+	 * @throws IOException
+	 */
+	private void noticeWriteCloud(DataOutputStream out, DataInputStream in)
+			throws IOException {
+		/****************************************
+		 * (1)Notice this cloud to send the data to the otherCloud for shuffling
+		 * CommandType: writeCloud
+		 * content: session ID | unfilled - partition | other cloud for shuffling | length of ids 
+		 * 
+		 *  When receive this data,  the cloud would read data and send them to the other cloud
+		 * ************************************/
+		
+		//System.out.println("3. noticeWriteCloud "+recvCmd[1]);
+		byte[] sessionID = new byte[8];
+
+		System.arraycopy(recvCmd, 1, sessionID, 0, 8);
+		int partition = Util.byteToInt(recvCmd, 9, 4);
+		int unfilledLevel = Util.byteToInt(recvCmd, 13, 4);
+		int cloud = recvCmd[17];
+		int idsLen = Util.byteToInt(recvCmd, 18, 4); 
+		  
+		byte[] ids = null;  
+		// 4 ID + 1 level 
+		if (idsLen > 0) {
+
+			ids = new byte[idsLen*4];
+
+//		    if (in.read(ids, 0, idsLen*4)!=idsLen*4)
+//		    	System.out.println("ids Error!!!");
+		     
+			readSocketLongData(in, idsLen*4, ids);
+			
+			  
+			 
+		}else{ 
+			;//System.out.println("data length is 0!"); 
+		} 
+
+		
+		/************************
+		 * SEND COMMAND TO OTHER CLOUD
+		 * ***************************/
+		byte[] cmd=new byte[13];
+		cmd[0]=CommandType.shuffleData;
+		System.arraycopy(sessionID, 0, cmd, 1, 8);//session ID
+		Util.intToByte(cmd, 9, idsLen);//idsLen 
+		
+		SocketClientUtil SCU=new SocketClientUtil(MCloudCommInfo.ip[cloud], MCloudCommInfo.port[cloud]);
+		SCU.connect();
+
+//		System.out.println("Ready for shuffle data command sending!"); 
+//		for (int i=0;i<13;i++)
+//			System.out.print(cmd[i]+" ");
+		SCU.send(cmd, 13);
+		byte[] bData = new byte[CommInfo.blockSize];
+		for (int i = 0; i < idsLen; i++) {
+			int _id = Util.byteToInt(ids, i * 4, 4);
+//			System.out.println("read _id: "+_id+" partition: "+partition);
+			//IDS 4 id | 1 level
+
+//			if (_id == 0) {
+//				System.out
+//						.println("noticeWriteCloud :!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!idsLen!!!!!!"
+//								+ idsLen);
+//				for (int z = 0; z < idsLen * 4; z++)
+//					System.out.print(ids[z] + " ");
+// 
+//				for (int z = 0; z < idsLen ; z++)
+//				{
+//					int _did = Util.byteToInt(ids, z * 4, 4);
+//					System.out.print(_did + " ");
+//				}
+//			}
+			
+			oram.readBlock(partition, _id, bData);
+			SCU.send(bData, CommInfo.blockSize); 
+		}
+		
+		//Then, waiting for the response
+		byte[] backCmd=new byte[5];
+		if (SCU.receiving(backCmd, 5)!=5 || backCmd[0]!=CommandType.backData)
+			System.out.println("wrong back command!");
+		int length=Util.byteToInt(backCmd, 1, 4);
+		int beginID=(1 << (unfilledLevel + 1)) - 2;
+		for (int i=0;i<length; i++)
+		{
+			if (SCU.receiving(bData, CommInfo.blockSize)!=CommInfo.blockSize)
+				System.out.println("wrong back data!");
+			else{
+				//System.out.println("write _id: "+(beginID+i)+" beginID: "+beginID);
+				//store it in the database 
+				oram.writeBlock(partition, beginID+i, bData, 0);
+			}
+		}
+		
+		SCU.disConnect();
+
+		out.writeByte(ResponseType.normal);
+		out.flush(); 
+	}
+
+	private void readSocketLongData(DataInputStream in, int dataLen, byte[] ids)
+			throws IOException { 
+		if (dataLen<512){
+		    if (in.read(ids, 0, dataLen)!=dataLen)
+		    	System.out.println("ids Error!!!");
+		}else{ 
+			int num = dataLen / 512  ;
+			int leftLen = dataLen % 512;
+			int hasRead = 0;
+			for (int i=0;i<num;i++)
+			{ 
+
+			    if (in.read(ids, hasRead, 512)!=512)
+			    	System.out.println("noticeWriteCloud 512 Error!!!"); 
+			    hasRead += 512;
+			}
+			if (leftLen>0){
+			    if (in.read(ids, hasRead, leftLen)!=leftLen)
+			    	System.out.println("noticeWriteCloud leftLen Error!!!"); 
+			}
+		}
+	}
+	
+
+	private void readCloud(DataOutputStream out, DataInputStream in)
+			throws IOException {
+		/*********
+		 * P + ID
+		 * *********/
+//		System.out.println("readCloud");
+
+		int p = Util.byteToInt(recvCmd, 1, 4);
+		int len = Util.byteToInt(recvCmd, 5, 4); // the next length of all the
+													// IDs
+		//System.out.println("readCloud p _id :" + p + "  len:  " + len);
+
+		byte[] bData = new byte[CommInfo.blockSize];
+	 
+		if (len>0){
+			byte[] ids = new byte[len * 4];
+
+			// read all the ids 
+			while (in.read(ids, 0, len * 4) > 0) {
+				break;
+			}
+
+			for (int i = 0; i < CommInfo.blockSize; i++)
+				bData[i] = 0;
+
+			byte[] bRnd = new byte[CommInfo.blockSize];
+			for (int i = 0; i < len; i++) {
+				int _id = Util.byteToInt(ids, i * 4, 4);
+				if (_id == 0)
+					System.out
+							.println("readCloud :!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+				oram.readBlock(p, _id, bRnd);
+				for (int j = 0; j < CommInfo.blockSize; j++)
+					bData[j] ^= bRnd[j];
+			}
+		}
+
+		out.writeByte(ResponseType.normalWithValue);
+		out.flush();
+		out.write(bData, 0, CommInfo.blockSize); 
+		out.flush();
+	}
+
+
+}

src/nankai/oram/server/ThinServer.java

@@ -0,0 +1,59 @@
+package nankai.oram.server;
+
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+
+import nankai.oram.client.MCloudCommInfo;
+
+
+public class ThinServer {
+	    private int queueSize = 100;  
+	    private static int port = 2121;  
+		public ThinServer() {
+			try {  
+				boolean listening = true; // 是否对客户端进行监听 
+				ServerSocket serverSocket = null; // 服务器端Socket对象 
+				try {
+					// 创建一个ServerSocket在端口2121监听客户请求
+					serverSocket = new ServerSocket(); 
+					
+					 //关闭serverSocket时，立即释放serverSocket绑定端口以便端口重用，默认为false  
+		            serverSocket.setReuseAddress(true);  
+		            //accept等待连接超时时间为1000毫秒，默认为0，永不超时  
+		            //serverSocket.setSoTimeout(10000);  
+		            //为所有accept方法返回的socket对象设置接收缓存区大小，单位为字节，默认值和操作系统有关  
+		            serverSocket.setReceiveBufferSize(128*1024);  
+		            //设置性能参数，可设置任意整数，数值越大，相应的参数重要性越高（连接时间，延迟，带宽）  
+		            serverSocket.setPerformancePreferences(3, 2, 1);  
+		            //服务端绑定至端口，10为服务端连接请求队列长度  
+		            serverSocket.bind(new InetSocketAddress(port), queueSize); 
+					System.out.println("Server starts..." + port);
+				} catch (Exception e) {
+					System.out.println("Can not listen to. " + e);
+				}
+
+				while (listening) { 
+					// 监听到客户请求,根据得到的Socket对象和客户计数创建服务线程,并启动之
+					//new ServerThread(server.accept()).start();
+					new ThinPartitionServerThread(serverSocket.accept()).start(); 
+				}
+			} catch (Exception e) {
+				System.out.println("Error.... " + e);
+			}
+		}
+
+		public static void main(String[] args) {
+			/**
+			 * To run in a computer to simulate the multiple servers, we use the parameters of main to tell the socket bind port 
+			 */
+			if (args.length>0){
+				//the pos is cloud - 1
+				int cloud = Integer.parseInt(args[0]);
+				ThinServer.port=MCloudCommInfo.port[cloud-1];
+				System.out.println("cloud "+cloud+" port:"+ThinServer.port);
+			}
+			new ThinServer();
+		}
+	
+
+}