Made changes to highest

.gitignore

@@ -391,6 +391,12 @@
 /test/small2/merge-ar
 /test/small2/libmerge.a
 
+#mutual
+/test/oblivc/mutual/*.oc.*
+/test/oblivc/mutual/*.txt
+
+*.oc.*
+
 
 # /ocamlutil
 /ocamlutil/perfcount.c

README.md

@@ -2,6 +2,9 @@ Obliv-C Compiler (`oblivcc`)
 ============================
 
 This readme is still under construction. But there is already a language tutorial at http://goo.gl/TXzxD0
+
+This requires libgcrypt to run. this can be downloaded on Ubuntu with `sudo apt-get install libgcrypt` then it also requires libgcrypt11-dev, which can be downlaoded with `sudo apt-get install libgcrypt11-dev`.
+
 Once in the source folder, a simple `./configure && make` should build it all. The compiler is a GCC wrapper script found in `bin/oblivcc`. Example codes are in `test/oblivc`
 
 Most of this code was forked from the project CIL (C Intermediate Language). You can diff with the master branch to see which part was added on later.

src/ext/oblivc/obliv_bits.c

@@ -184,8 +184,8 @@ static int sizeCheckSend(ProtocolTransport* pt,int dest,const void* s,size_t n)
 { int sent = osend(&((SizeCheckTransportAdapter*)pt)->pd,dest,s,n);
   if(sent==n) return n;
   else 
-  { fprintf(stderr,"Was going to send %lu bytes to %d, sent %d\n",
-                   n,dest,sent);
+  { fprintf(stderr,"Was going to send bytes to %d, sent %d\n",
+                   dest,sent);
     if(sent<0) fprintf(stderr,"That means %s\n",strerror(sent));
     exit(-1);
   }
@@ -195,8 +195,8 @@ static int sizeCheckRecv(ProtocolTransport* pt,int src,void* s,size_t n)
 { int recv = orecv(&((SizeCheckTransportAdapter*)pt)->pd,src,s,n);
   if(recv==n) return n;
   else 
-  { fprintf(stderr,"Was going to recv %lu bytes from %d, received %d\n",
-                    n,src,recv);
+  { fprintf(stderr,"Was going to recv bytes from %d, received %d\n",
+                  src,recv);
     if(recv<0) fprintf(stderr,"That means %s\n",strerror(recv));
     exit(-1);
   }

src/ext/oblivc/obliv_bits.h

@@ -1,6 +1,6 @@
 #ifndef OBLIV_BITS_H
 #define OBLIV_BITS_H
-void* memset(void* s, int c, unsigned long n); // Hack, had to declare memset
+//void* memset(void* s, int c, unsigned long n); // Hack, had to declare memset
 #include<stddef.h> // size_t
 //#include<stdlib.h> // memset to zero
 #include<stdbool.h>

test/oblivc/average/average.c

@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<obliv.h>
+
+#include "average.h"
+
+int currentParty;
+
+const char* mySide()
+{
+  if(currentParty==1) return "Generator";
+  else return "Evaluator";
+}
+
+int main(int argc,char *argv[])
+{
+  //these variables are used everytime
+  ProtocolDesc pd;
+  protocolIO io;
+
+  //checking that the input has the correct number of variables
+  if(argc<3)
+  { if(argc<2) fprintf(stderr,"Party missing\n");
+    else fprintf(stderr,"string missing\n");
+    fprintf(stderr,"Usage: %s <1|2> <string>\n",argv[0]);
+    return 1;
+  }
+
+  //sets the size of the array
+  io.n = argc-2;
+  //the the values in the array to the input values
+  int j;
+  for(j = 0; j<io.n; j++){
+    io.i[j] = atoi(argv[j+2]);
+  }
+  //these steps are done everytime to set-up the oc file
+  protocolUseStdio(&pd);
+  currentParty = (argv[1][0]=='1'?1:2);
+  setCurrentParty(&pd,currentParty);
+  execYaoProtocol(&pd,highest,&io);
+  cleanupProtocol(&pd);
+  //prints out the result
+  fprintf(stderr,"Result: %d\n",io.res);
+  return 0;
+}

test/oblivc/average/average.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#define MAXN 100
+
+typedef struct protocolIO
+{
+  int i[100];
+  int n;
+  int res;
+
+} protocolIO;
+
+void highest(void* args);
+
+const char* mySide();

test/oblivc/average/average.oc

@@ -0,0 +1,34 @@
+#include<stdio.h>
+#include<obliv.oh>
+
+#include "average.h"
+
+void readValues(obliv int* dest, int n, const int* src,int party)
+{
+  OblivInputs specs[MAXN];
+  int i;
+  for(i=0;i<n;++i) setupOblivInt(specs+i,dest+i,src[i]);
+  feedOblivInputs(specs,n,party);
+}
+
+void highest(void* args){
+     protocolIO *io = args;
+     int n1, n2;
+     int i, j;
+     obliv int sum1 = 0;
+     obliv int sum2 = 0;
+     obliv int i1[MAXN], i2[MAXN];
+     n1 = ocBroadcastInt(1, io->n);
+     n2 = ocBroadcastInt(2, io->n);
+     readValues(i1, n1, io->i, 1);
+     readValues(i2, n2, io->i, 2);
+     //runs the actual algorithm to find average
+     for(i=0; i<n1; i++){
+     	sum1 = i1[i] + sum1;
+     }
+     for(j =0; j<n2; j++){
+     	sum2 = i2[j] + sum2;
+     }
+     obliv int average = (sum1 + sum2)/(n1+n2);
+     revealOblivInt(&io->res,average,0);
+}

test/oblivc/highest/README.txt

@@ -0,0 +1,9 @@
+Prints out the highest value that is entered by two parties on the command line
+
+# compile using our GCC wrapper
+/path/to/oblivcc highest.c highest.oc -I .
+# run: party 1 enters the numbers 1,2, and 3 and party 2 entered the numbers 2,4, and 6
+cycle './a.out 1 1 2 3 | ./a.out 2 2 4 6'
+#this result will be 6
+
+The cycle command is a handy bash script that you can find at https://github.com/samee/cmd

test/oblivc/highest/highest.c

@@ -0,0 +1,44 @@
+#include<stdio.h>
+#include<obliv.h>
+
+#include "highest.h"
+
+int currentParty;
+
+const char* mySide()
+{
+  if(currentParty==1) return "Generator";
+  else return "Evaluator";
+}
+
+int main(int argc,char *argv[])
+{
+  //these variables are used everytime
+  ProtocolDesc pd;
+  protocolIO io;
+
+  //checking that the input has the correct number of variables
+  if(argc<3)
+  { if(argc<2) fprintf(stderr,"Party missing\n");
+    else fprintf(stderr,"string missing\n");
+    fprintf(stderr,"Usage: %s <1|2> <string>\n",argv[0]);
+    return 1;
+  }
+
+  //sets the size of the array
+  io.n = argc-2;
+  //the the values in the array to the input values
+  int j;
+  for(j = 0; j<io.n; j++){
+    io.i[j] = atoi(argv[j+2]);
+  }
+  //these steps are done everytime to set-up the oc file
+  protocolUseStdio(&pd);
+  currentParty = (argv[1][0]=='1'?1:2);
+  setCurrentParty(&pd,currentParty);
+  execYaoProtocol(&pd,highest,&io);
+  cleanupProtocol(&pd);
+  //prints out the result
+  fprintf(stderr,"Result: %d\n",io.res);
+  return 0;
+}

test/oblivc/highest/highest.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#define MAXN 100
+
+typedef struct protocolIO
+{
+  int i[MAXN];
+  int n;
+  int res;
+
+} protocolIO;
+
+void highest(void* args);

test/oblivc/highest/highest.oc

@@ -0,0 +1,38 @@
+#include<stdio.h>
+#include<obliv.oh>
+
+#include "highest.h"
+//dest is the pointer to the array of obliv ints
+//n is the size of the array
+//src is where the data is coming from
+void readValues(obliv int* dest, int n, const int* src,int party)
+{
+  OblivInputs specs[MAXN];
+  int i;
+  for( i = 0;i<n;++i) setupOblivInt(specs+i,dest+i,src[i]);
+  feedOblivInputs(specs,n,party);
+}
+
+void highest(void* args){
+     protocolIO *io = args;
+     obliv int n1, n2;
+     int k, j;
+     obliv int i1[MAXN], i2[MAXN];
+     n1 = feedOblivInt(io->n, 1);
+     n2 = feedOblivInt(io->n, 2);
+     readValues(i1, MAXN, io->i, 1);
+     readValues(i2, MAXN, io->i, 2);
+     //runs the actual algorithm of higher value
+     obliv int high = i1[0];
+     for(k=0; k<MAXN; k++){
+       obliv if(k<n1)
+     	obliv if(i1[k] > high)
+	      high = i1[k];
+     }
+     for(j =0; j<MAXN; j++){
+        obliv if(j<n2)
+     	   obliv if(i2[j] > high)
+	   	 high = i2[j];
+     }
+     revealOblivInt(&io->res,high,0);
+}