random content forest can be generated

src/oram/Bucket.java

@@ -1,12 +1,18 @@
 package oram;
 
+import java.util.Random;
+
 import exceptions.LengthNotMatchException;
 
 public class Bucket {
 	private Tuple[] tuples;
 
-	public Bucket(int numTuples) {
+	public Bucket(int numTuples, int[] tupleParams, Random rand) {
+		if (tupleParams.length != 4)
+			throw new LengthNotMatchException(tupleParams.length + " != 4");
 		tuples = new Tuple[numTuples];
+		for (int i = 0; i < numTuples; i++)
+			tuples[i] = new Tuple(tupleParams[0], tupleParams[1], tupleParams[2], tupleParams[3], rand);
 	}
 
 	public Bucket(Tuple[] tuples) {

src/oram/Forest.java

@@ -2,6 +2,7 @@ package oram;
 
 import java.math.BigInteger;
 import java.util.HashMap;
+import java.util.Random;
 
 import crypto.OramCrypto;
 import util.Util;
@@ -9,54 +10,28 @@ import util.Util;
 public class Forest {
 	private Tree[] trees;
 
+	// build empty forest and insert records according to config file
 	public Forest() {
 		Metadata md = new Metadata();
-		init(md);
-		insertTuples(md);
+		initTrees(md, null);
+		insertRecords(md);
 	}
 
-	public Forest(Metadata md) {
-		init(md);
-		insertTuples(md);
+	// build empty/random content forest
+	public Forest(Random rand) {
+		Metadata md = new Metadata();
+		initTrees(md, rand);
 	}
 
-	// init an empty forest
-	private void init(Metadata md) {
+	// init trees
+	private void initTrees(Metadata md, Random rand) {
 		trees = new Tree[md.getNumTrees()];
-		// for each tree
-		for (int treeIndex = 0; treeIndex < md.getNumTrees(); treeIndex++) {
-			// init the tree
-			trees[treeIndex] = new Tree(treeIndex, md);
-			// get bytes of tuple in this tree
-			int fBytes = treeIndex == 0 ? 0 : 1;
-			int nBytes = trees[treeIndex].getNBytes();
-			int lBytes = trees[treeIndex].getLBytes();
-			int aBytes = trees[treeIndex].getABytes();
-			// for each level of the tree
-			long numBuckets = 1;
-			for (int i = 0; i < trees[treeIndex].getD(); i++) {
-				// for each bucket
-				for (int j = 0; j < numBuckets; j++) {
-					// calculate bucket index
-					long bucketIndex = j + numBuckets - 1;
-					// get the bucket
-					Bucket bucket = trees[treeIndex].getBucket(bucketIndex);
-					// for each tuple within the bucket
-					for (int k = 0; k < bucket.getNumTuples(); k++) {
-						// create a empty tuple
-						Tuple tuple = new Tuple(fBytes, nBytes, lBytes, aBytes);
-						// add to the bucket
-						bucket.setTuple(k, tuple);
-					}
-				}
-				// numBuckets doubled for next level
-				numBuckets *= 2;
-			}
-		}
+		for (int i = 0; i < trees.length; i++)
+			trees[i] = new Tree(i, md, rand);
 	}
 
 	// insert records into ORAM forest
-	private void insertTuples(Metadata md) {
+	private void insertRecords(Metadata md) {
 		int numTrees = trees.length;
 		int tau = md.getTau();
 		int w = md.getW();
@@ -74,7 +49,7 @@ public class Forest {
 		for (long addr = 0; addr < md.getNumInsertRecords(); addr++) {
 			// for each tree (from last to first)
 			for (int i = numTrees - 1; i >= 0; i--) {
-				long numBuckets = trees[i].getNumBucket();
+				long numBuckets = trees[i].getNumBuckets();
 				// index of bucket that contains the tuple we will insert/update
 				long bucketIndex = 0;
 				// index of tuple within the bucket
@@ -115,7 +90,7 @@ public class Forest {
 						indexN = (int) Util.getSubBits(N[i + 1], tau, 0);
 					int start = indexN * trees[i].getAlBytes();
 					int end = start + trees[i].getAlBytes();
-					targetTuple.setALabel(start, end, Util.rmSignBit(BigInteger.valueOf(L[i + 1]).toByteArray()));
+					targetTuple.setSubA(start, end, Util.rmSignBit(BigInteger.valueOf(L[i + 1]).toByteArray()));
 				}
 				// for the last tree, update the whole A field of the target
 				// tuple
@@ -140,7 +115,7 @@ public class Forest {
 
 		for (int i = 0; i < trees.length; i++) {
 			System.out.println("***** Tree " + i + " *****");
-			for (int j = 0; j < trees[i].getNumBucket(); j++)
+			for (int j = 0; j < trees[i].getNumBuckets(); j++)
 				System.out.println(trees[i].getBucket(j));
 			System.out.println();
 		}

src/oram/Tree.java

@@ -1,6 +1,7 @@
 package oram;
 
 import java.math.BigInteger;
+import java.util.Random;
 
 import exceptions.InvalidPathLabelException;
 import exceptions.LengthNotMatchException;
@@ -23,7 +24,7 @@ public class Tree {
 
 	private Array64<Bucket> buckets;
 
-	public Tree(int index, Metadata md) {
+	public Tree(int index, Metadata md, Random rand) {
 		treeIndex = index;
 		w = md.getW();
 		stashSize = md.getStashSizeOfTree(treeIndex);
@@ -38,10 +39,12 @@ public class Tree {
 		numBuckets = md.getNumBucketsOfTree(treeIndex);
 		d = lBits + 1;
 
+		int fBytes = treeIndex == 0 ? 0 : 1;
+		int[] tupleParams = new int[] { fBytes, nBytes, lBytes, aBytes };
 		buckets = new Array64<Bucket>(numBuckets);
-		buckets.set(0, new Bucket(stashSize));
+		buckets.set(0, new Bucket(stashSize, tupleParams, rand));
 		for (int i = 1; i < numBuckets; i++)
-			buckets.set(i, new Bucket(w));
+			buckets.set(i, new Bucket(w, tupleParams, rand));
 	}
 
 	public int getTreeIndex() {
@@ -88,7 +91,7 @@ public class Tree {
 		return tupleBytes;
 	}
 
-	public long getNumBucket() {
+	public long getNumBuckets() {
 		return numBuckets;
 	}
 
@@ -115,7 +118,6 @@ public class Tree {
 			throw new InvalidPathLabelException(BigInteger.valueOf(L).toString(2));
 		BigInteger biL = BigInteger.valueOf(L);
 		long[] indices = new long[d];
-		indices[0] = 0;
 		for (int i = 1; i < d; i++) {
 			if (biL.testBit(d - i - 1))
 				indices[i] = indices[i - 1] * 2 + 2;

src/oram/Tuple.java

@@ -2,6 +2,7 @@ package oram;
 
 import java.math.BigInteger;
 import java.util.Arrays;
+import java.util.Random;
 
 import exceptions.LengthNotMatchException;
 
@@ -11,14 +12,19 @@ public class Tuple {
 	private byte[] L;
 	private byte[] A;
 
-	public Tuple(int fs, int ns, int ls, int as) {
+	public Tuple(int fs, int ns, int ls, int as, Random rand) {
 		F = new byte[fs];
 		N = new byte[ns];
 		L = new byte[ls];
 		A = new byte[as];
+		if (rand != null) {
+			rand.nextBytes(F);
+			rand.nextBytes(N);
+			rand.nextBytes(L);
+			rand.nextBytes(A);
+		}
 	}
 
-	// shallow copy
 	public Tuple(byte[] f, byte[] n, byte[] l, byte[] a) {
 		F = f;
 		N = n;
@@ -98,11 +104,11 @@ public class Tuple {
 			A = a;
 	}
 
-	public byte[] getALabel(int start, int end) {
+	public byte[] getSubA(int start, int end) {
 		return Arrays.copyOfRange(A, start, end);
 	}
 
-	public void setALabel(int start, int end, byte[] label) {
+	public void setSubA(int start, int end, byte[] label) {
 		if (start < 0)
 			throw new IllegalArgumentException(start + " < 0");
 		if (start > end)

test/misc/HelloWorld.java

@@ -1,7 +1,6 @@
 package misc;
 
 import java.math.BigInteger;
-import java.util.Arrays;
 
 public class HelloWorld {
 
@@ -14,14 +13,15 @@ public class HelloWorld {
 
 		// System.out.println(tmp[3]);
 
-		//System.out.println(Arrays.copyOfRange(tmp, 2, 1).length);
-		
-		byte[] a = new byte[]{0};
+		// System.out.println(Arrays.copyOfRange(tmp, 2, 1).length);
+
+		byte[] a = new byte[] { 0 };
 		byte[] b = a.clone();
 		a[0] = 1;
 		System.out.println(a[0] + " " + b[0]);
 		// throw new ArrayIndexOutOfBoundsException("" + 11);
 
+		System.out.println((new long[3])[0]);
 	}
 
 }

test/oram/TestBucket.java

@@ -0,0 +1,16 @@
+package oram;
+
+import java.util.Random;
+
+public class TestBucket {
+
+	public static void main(String[] args) {
+		int[] tupleParams = new int[] { 1, 2, 3, 4 };
+		Random rand = new Random();
+		Bucket bucket = new Bucket(6, tupleParams, null);
+		System.out.println(bucket);
+		bucket = new Bucket(6, tupleParams, rand);
+		System.out.println(bucket);
+	}
+
+}

test/oram/TestMetadata.java

@@ -5,9 +5,9 @@ public class TestMetadata {
 	public static void main(String[] args) {
 		Metadata md = new Metadata();
 		md.print();
-		//md.write("config/copy.yaml");
-		//Metadata md2 = new Metadata("config/copy.yaml");
-		//md2.write("config/copy2.yaml");
+		// md.write("config/copy.yaml");
+		// Metadata md2 = new Metadata("config/copy.yaml");
+		// md2.write("config/copy2.yaml");
 	}
 
 }

test/oram/TestTree.java

@@ -2,24 +2,19 @@ package oram;
 
 import java.math.BigInteger;
 
+import util.Util;
+
 public class TestTree {
 
 	public static void main(String[] args) {
 		Metadata md = new Metadata();
-		Tree tree = new Tree(2, md);
+		Tree tree = new Tree(2, md, null);
 		long tupleCounter = 0;
-		for (int i = 0; i < tree.getD(); i++) {
-			long numBuckets = (long) Math.pow(2, i);
-			for (int j = 0; j < numBuckets; j++) {
-				long bucketIndex = j + numBuckets - 1;
-				Bucket bucket = tree.getBucket(bucketIndex);
-				for (int k = 0; k < bucket.getNumTuples(); k++) {
-					byte[] fnl = new byte[0];
-					byte[] a = BigInteger.valueOf(tupleCounter).toByteArray();
-					Tuple tuple = new Tuple(fnl, fnl, fnl, a);
-					tupleCounter++;
-					bucket.setTuple(k, tuple);
-				}
+		for (long i = 0; i < tree.getNumBuckets(); i++) {
+			Bucket bucket = tree.getBucket(i);
+			for (int j = 0; j < bucket.getNumTuples(); j++) {
+				bucket.getTuple(j).setA(Util.rmSignBit(BigInteger.valueOf(tupleCounter).toByteArray()));
+				tupleCounter++;
 			}
 		}
 

test/oram/TestTuple.java

@@ -1,24 +1,17 @@
 package oram;
 
-import java.math.BigInteger;
+import java.util.Random;
 
 public class TestTuple {
 
 	public static void main(String[] args) {
-		byte[] F = new byte[] { 1 };
-		byte[] N = new byte[] { 2 };
-		byte[] L = new byte[] { 3 };
-		byte[] A = new byte[] { 4 };
-		Tuple tuple = new Tuple(F, N, L, A);
+		Random rand = new Random();
+		Tuple tuple = new Tuple(1, 2, 3, 4, null);
 		System.out.println(tuple);
-		System.out.println(new BigInteger(1, tuple.toByteArray()).toString(2));
-
-		F = new byte[0];
-		N = new byte[0];
-		L = new byte[0];
-		tuple = new Tuple(F, N, L, A);
+		tuple = new Tuple(1, 2, 3, 4, rand);
+		System.out.println(tuple);
+		tuple = new Tuple(0, 0, 0, 4, rand);
 		System.out.println(tuple);
-		System.out.println(new BigInteger(1, tuple.toByteArray()).toString(2));
 	}
 
 }