StarMirror/PSI
1
0
Fork 0
mirror of https://github.com/encryptogroup/PSI.git synced 2024-03-22 13:30:44 +08:00
Code Issues Projects Releases Wiki Activity

Cleaning

Browse Source
This commit is contained in:
Michael Zohner 2015-05-21 18:39:59 +02:00
parent d07f0fc7fa
commit 89f56664ed
14 changed files with 11 additions and 791 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Makefile
View File

@ -44,8 +44,8 @@ OBJECTS_NAIVE=${SRC}/naive-hashing/*.o
SOURCES_DHPSI=${SRC}/pk-based/*.cpp SOURCES_DHPSI=${SRC}/pk-based/*.cpp
OBJECTS_DHPSI=${SRC}/pk-based/*.o OBJECTS_DHPSI=${SRC}/pk-based/*.o
# third-party-based PSI # third-party-based PSI
SOURCES_THIRDPARTY=${SRC}/thirdparty-based/*.cpp SOURCES_SERVERAIDED=${SRC}/server-aided/*.cpp
OBJECTS_THIRDPARTY=${SRC}/thirdparty-based/*.o OBJECTS_SERVERAIDED=${SRC}/server-aided/*.o
# OT-based PSI # OT-based PSI
SOURCES_OTPSI=${SRC}/ot-based/*.cpp SOURCES_OTPSI=${SRC}/ot-based/*.cpp
OBJECTS_OTPSI=${SRC}/ot-based/*.o OBJECTS_OTPSI=${SRC}/ot-based/*.o
@ -67,10 +67,10 @@ core: ${OBJECTS_CORE}
${CC} $< ${COMPILER_OPTIONS} -c ${INCLUDE} ${LIBRARIES} ${CFLAGS} ${BATCH} -o $@ ${CC} $< ${COMPILER_OPTIONS} -c ${INCLUDE} ${LIBRARIES} ${CFLAGS} ${BATCH} -o $@
bench: bench:
${CC} -o psi.exe ${SRC}/mains/bench_psi.cpp ${OBJECTS_DHPSI} ${OBJECTS_OTPSI} ${OBJECTS_NAIVE} ${OBJECTS_THIRDPARTY} ${OBJECTS_UTIL} ${OBJECTS_HASHING} ${OBJECTS_CRYPTO} ${OBJECTS_OT} ${OBJECTS_MIRACL} ${CFLAGS} ${DEBUG_OPTIONS} ${LIBRARIES} ${MIRACL_LIB} ${INCLUDE} ${COMPILER_OPTIONS} ${CC} -o psi.exe ${SRC}/mains/bench_psi.cpp ${OBJECTS_DHPSI} ${OBJECTS_OTPSI} ${OBJECTS_NAIVE} ${OBJECTS_SERVERAIDED} ${OBJECTS_UTIL} ${OBJECTS_HASHING} ${OBJECTS_CRYPTO} ${OBJECTS_OT} ${OBJECTS_MIRACL} ${CFLAGS} ${DEBUG_OPTIONS} ${LIBRARIES} ${MIRACL_LIB} ${INCLUDE} ${COMPILER_OPTIONS}
demo: demo:
${CC} -o demo.exe ${SRC}/mains/psi_demo.cpp ${OBJECTS_DHPSI} ${OBJECTS_OTPSI} ${OBJECTS_NAIVE} ${OBJECTS_THIRDPARTY} ${OBJECTS_UTIL} ${OBJECTS_HASHING} ${OBJECTS_CRYPTO} ${OBJECTS_OT} ${OBJECTS_MIRACL} ${CFLAGS} ${DEBUG_OPTIONS} ${LIBRARIES} ${MIRACL_LIB} ${INCLUDE} ${COMPILER_OPTIONS} ${CC} -o demo.exe ${SRC}/mains/psi_demo.cpp ${OBJECTS_DHPSI} ${OBJECTS_OTPSI} ${OBJECTS_NAIVE} ${OBJECTS_SERVERAIDED} ${OBJECTS_UTIL} ${OBJECTS_HASHING} ${OBJECTS_CRYPTO} ${OBJECTS_OT} ${OBJECTS_MIRACL} ${CFLAGS} ${DEBUG_OPTIONS} ${LIBRARIES} ${MIRACL_LIB} ${INCLUDE} ${COMPILER_OPTIONS}
# this will create a copy of the files in ${SOURCES_MIRACL} and its sub-directories and put them into ${MIRACL_LIB_DIR} without sub-directories, then compile it # this will create a copy of the files in ${SOURCES_MIRACL} and its sub-directories and put them into ${MIRACL_LIB_DIR} without sub-directories, then compile it
@ -83,7 +83,7 @@ ${MIRACL_LIB_DIR}/miracl.a: ${SOURCES_MIRACL}
# only clean example objects, test object and binaries # only clean example objects, test object and binaries
clean: clean:
rm -f ${OBJECTS_EXAMPLE} ${OBJECTS_TEST} *.exe ${OBJECTS_DHPSI} ${OBJECTS_OTPSI} ${OBJECTS_NAIVE} ${OBJECTS_THIRDPARTY} ${OBJECTS_UTIL} ${OBJECTS_CRYPTO} ${OBJECTS_OT} rm -f ${OBJECTS_EXAMPLE} ${OBJECTS_TEST} *.exe ${OBJECTS_DHPSI} ${OBJECTS_OTPSI} ${OBJECTS_NAIVE} ${OBJECTS_SERVERAIDED} ${OBJECTS_UTIL} ${OBJECTS_CRYPTO} ${OBJECTS_OT}
# this will clean everything: example objects, test object and binaries and the Miracl library # this will clean everything: example objects, test object and binaries and the Miracl library
cleanall: clean cleanall: clean

4
README.md
View File

@ -60,9 +60,9 @@ This should print the following output in the second terminal:
These commands will run the naive hashing protocol and compute the intersection on the randomly generated emails in sample_sets/emails_alice.txt and sample_sets/emails_bob.txt (where 3 intersecting elements were altered). To use a different protocol, the ['-p'] option can be varied as follows: These commands will run the naive hashing protocol and compute the intersection on the 1024 randomly generated emails in sample_sets/emails_alice.txt and sample_sets/emails_bob.txt (where 3 intersecting elements were altered). To use a different protocol, the ['-p'] option can be varied as follows:
* `-p 0`: the naive hashing protocol * `-p 0`: the naive hashing protocol
* `-p 1`: the server-aided protocol of [2] (CURRENTLY NOT WORKING) * `-p 1`: the server-aided protocol of [2]. CURRENTLY NOT WORKING
* `-p 2`: the Diffie-Hellman-based PSI protocol of [3] * `-p 2`: the Diffie-Hellman-based PSI protocol of [3]
* `-p 3`: the OT-based PSI protocol of [1] * `-p 3`: the OT-based PSI protocol of [1]

19
src/hashing/cuckoo.cpp
View File

@ -34,23 +34,9 @@ uint8_t* cuckoo_hashing(uint8_t* elements, uint32_t neles, uint32_t nbins, uint3
entry_gen_tasks = (pthread_t*) malloc(sizeof(pthread_t) * ntasks); entry_gen_tasks = (pthread_t*) malloc(sizeof(pthread_t) * ntasks);
ctx = (cuckoo_entry_gen_ctx*) malloc(sizeof(cuckoo_entry_gen_ctx) * ntasks); ctx = (cuckoo_entry_gen_ctx*) malloc(sizeof(cuckoo_entry_gen_ctx) * ntasks);
//use the number of bins as address bits
//addr_bits = ceil_log2(nbins);
//cout << "Using addr_bits: " << hs.addrbitlen << endl;
//cout << "number of bins: " << nbins << ", address bits = " << addr_bits << endl;
//the remaining bits form the size of the values
//inbytelen = ceil_divide(bitlen, 8);
//outbytelen = ceil_divide(outbitlen, 8);
//dummy_ele = (uint8_t*) malloc(ceil_divide(bitlen, 8));
for(i = 0; i < ntasks; i++) { for(i = 0; i < ntasks; i++) {
ctx[i].elements = elements; ctx[i].elements = elements;
ctx[i].cuckoo_entries = cuckoo_entries; ctx[i].cuckoo_entries = cuckoo_entries;
//ctx[i].inbitlen = bitlen;
// ctx[i].addr_bitlen = addr_bits;
//ctx[i].outbitlen = outbitlen;
//ctx[i].nbins = nbins;
ctx[i].hs = &hs; ctx[i].hs = &hs;
ctx[i].startpos = i * ceil_divide(neles, ntasks); ctx[i].startpos = i * ceil_divide(neles, ntasks);
ctx[i].endpos = min(ctx[i].startpos + ceil_divide(neles, ntasks), neles); ctx[i].endpos = min(ctx[i].startpos + ceil_divide(neles, ntasks), neles);
@ -61,11 +47,6 @@ uint8_t* cuckoo_hashing(uint8_t* elements, uint32_t neles, uint32_t nbins, uint3
} }
} }
//generate the cuckoo entries for all elements
//for(i = 0; i < neles; i++) {
// gen_cuckoo_entry(elements + inbytelen * i, bitlen, addr_bits, cuckoo_entries + i, outbitlen, nbins, i);
//}
for(i = 0; i < ntasks; i++) { for(i = 0; i < ntasks; i++) {
if(pthread_join(entry_gen_tasks[i], NULL)) { if(pthread_join(entry_gen_tasks[i], NULL)) {
cerr << "Error in joining pthread at cuckoo hashing!" << endl; cerr << "Error in joining pthread at cuckoo hashing!" << endl;

154
src/hashing/kcuckoo3a.C
View File

@ -1,154 +0,0 @@
// K-ary cuckoo hashing (c) 2002-2003 by Peter Sanders
// this is a simple implementation for the purposes
// of measuring the performance of cuckoo hashing in abstract
// terms (number of probes per insert, storage efficiency)
// usage: compile using g++ or another ISO C++ compiler
// a.out <K> <n> <r> <repeat> <seed for rng>
// there is also a constant tMax that defines the maximum number
// of trials for an insertion
// allocates space for n elements in K subtables, and repeats
// the follwing measurements repeat time:
// - find a hash function by filling full lookup tables
// with pseudo-random numbers.
// - insert elements i=0..n-1 into the table until this fails
// for the first time. (The cost of these insertions is not
// measured.)
// Every n/r successfully inserted elements, the follwing
// measurement is repeated n/r times:
// * a random element i2 is removed
// * the hash table entries for i2 are filled with new random values
// * i2 is reinserted.
// Note that this is equivalent to removing a random element
// inserting a new element that
// has never been in the table before.
// The output is a table that gives
// - x the number of elements in the table at each measuremnt interval
// - the average number of probes for an insertion during the measruements
// for the given number of inserted elements
// - K
// - n
// - repeat
// - seed
#define DEBUGLEVEL 1
#include <iostream>
#include <stdlib.h>
#include "util.h"
#include "mt-real.c"
#include <assert.h>
#define split 1
using namespace std;
const int tMax = 10000; // max number of random walk trials
int K; // number of probes
int n; // number of elements
int m; // number of elements per table
int **hash; // K times n array
int **table; // K times m array
// generate random int in 0..x-1
inline int rand0K(int x) { return int(genrand()*x); }
// insert element i into table
// return value:
// -1 failure
// otherwise number of hash function evaluation
int insert(int i) {
int forbidden = -1;
int j = rand0K(K);
for (int t = 1; t <= tMax; t++) {
int p = hash [j][i];
int newI = table[j][p];
table[j][p] = i; // play the cuckoo
if (newI == -1) return t; // done
forbidden = j;
i = newI; // find new home for cuckoo victim
j = rand0K(K-1);
if (j == forbidden) j = K-1;
}
return tMax + 1; // insertion failed
}
// remove element i from the table
void remove(int i) {
for (int j = 0; j < K; j++) {
int p = hash[j][i];
if (table[j][p] == i) {
table[j][p] = -1;
return;
}
}
}
/*int main(int argc, char **argv) {
int i, j;
assert(argc == 6);
K = atoi(argv[1]); // number of probes
n = atoi(argv[2]); // number of elements
// double eps = atof(argv[3]); // space slack
m = int(n/K + 0.5);
int r = atoi(argv[3]); // number of measured densities
int step = n/r;
int repeat = atoi(argv[4]); // how often to start from scratch
int seed = atoi(argv[5]);
sgenrand(seed);
cout << "# x tAvg(x) K N repeat seed" << endl;
// allocate hash function and table
// and an empty table
hash = (int**) malloc(sizeof(int*) * K);
table = (int**) malloc(sizeof(int*) * K);
for (j = 0; j < K; j++) {
hash [j] = new int[n];
table[j] = new int[m];
}
// initialize statistics
// sumT[i] is the average time for size i*step
double *sumT = new double[r+1];
int *cf = new int[r+1];
for (int i = 0; i < r; i++) {
sumT[i] = 0;
cf[i] = 0;
}
// main loop
for (int rep = 0; rep < repeat; rep++) {
// init hash function and empty table
for (j = 0; j < K; j++) {
for (i = 0; i < n; i++) { hash [j][i] = rand0K(m); }
for (i = 0; i < m; i++) { table[j][i] = -1; }
}
// fill table and keep measuring from time to time
for (i = 0; i < n; i++) {
if (insert(i) > tMax) break; // table is full
if (((i+1) % step) == 0) { // measure in detail here
for (int i1 = 0; i1 < step; i1++) {
// remove and reinsert a random element
int i2 = rand0K(i);
remove(i2);
for (j = 0; j < K; j++) hash[j][i2] = rand0K(m);
int t = insert(i2);
cf[i/step] += (t > tMax);
//cout << t << endl;
sumT[i/step] += t;
}
}
}
}
for (int rep = 0; rep < r; rep++) {
cout << rep*step + step << " "
<< sumT[rep]/step/repeat << " "
<< K << " "
<< n << " "
<< repeat << " "
<< seed << " "
<< cf[rep] << endl;
}
}
*/

90
src/hashing/mt-real.c
View File

@ -1,90 +0,0 @@
/* A C-program for MT19937B: Real number version */
/* genrand() generate one pseudorandom number with double precision */
/* which is uniformly distributed on [0,1]-interval for each call. */
/* sgenrand(seed) set initial values to the working area of 624 words.*/
/* sgenrand(seed) must be called once before calling genrand() */
/* (seed is any integer except 0). */
/*
LICENCE CONDITIONS:
Matsumoto and Nishimura consent to GNU General
Public Licence
NOTE:
When you use it in your program, please let Matsumoto
<matumoto@math.keio.ac.jp> know it.
Because of a machine-trouble, Matsumoto lost emails
which arrived during May 28-29.
*/
#include<stdio.h>
/* Period parameters */
#define N 624
#define M 397
#define MATRIX_A 0x9908b0df /* constant vector a */
#define UPPER_MASK 0x80000000 /* most significant w-r bits */
#define LOWER_MASK 0x7fffffff /* least significant r bits */
/* for tempering */
#define TEMPERING_MASK_B 0x9d2c5680
#define TEMPERING_MASK_C 0xefc60000
#define TEMPERING_SHIFT_U(y) (y >> 11)
#define TEMPERING_SHIFT_S(y) (y << 7)
#define TEMPERING_SHIFT_T(y) (y << 15)
#define TEMPERING_SHIFT_L(y) (y >> 18)
static unsigned long ptgfsr[N]; /* set initial seeds: N = 624 words */
void
sgenrand(unsigned long seed) /* seed should not be 0 */
{
int k;
/* setting initial seeds to ptgfsr[N] using */
/* the generator Line 25 of Table 1 in */
/* [KNUTH 1981, The Art of Computer Programming */
/* Vol. 2 (2nd Ed.), pp102] */
ptgfsr[0]= seed & 0xffffffff;
for (k=1; k<N; k++)
ptgfsr[k] = (69069 * ptgfsr[k-1]) & 0xffffffff;
}
double
genrand()
{
unsigned long y;
static int k = 1;
static unsigned long mag01[2]={0x0, MATRIX_A};
/* mag01[x] = x * MATRIX_A for x=0,1 */
if(k == N){ /* generate N words at one time */
int kk;
for (kk=0;kk<N-M;kk++) {
y = (ptgfsr[kk]&UPPER_MASK)|(ptgfsr[kk+1]&LOWER_MASK);
ptgfsr[kk] = ptgfsr[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
}
for (;kk<N-1;kk++) {
y = (ptgfsr[kk]&UPPER_MASK)|(ptgfsr[kk+1]&LOWER_MASK);
ptgfsr[kk] = ptgfsr[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
}
y = (ptgfsr[N-1]&UPPER_MASK)|(ptgfsr[0]&LOWER_MASK);
ptgfsr[N-1] = ptgfsr[M-1] ^ (y >> 1) ^ mag01[y & 0x1];
k = 0;
}
y = ptgfsr[k++];
y ^= TEMPERING_SHIFT_U(y);
y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
y &= 0xffffffff; /* you may delete this line if word size = 32 */
y ^= TEMPERING_SHIFT_L(y);
return ( (double)y / (unsigned long)0xffffffff );
}

103
src/hashing/util.h
View File

@ -1,103 +0,0 @@
// this files contains all the application independent little
// functions and macros used for the optimizer.
// In particular Peters debug macros and Dags stuff
// from dbasic.h cdefs, random,...
//////////////// stuff originally from debug.h ///////////////////////////////
// (c) 1997 Peter Sanders
// some little utilities for debugging adapted
// to the paros conventions
#ifndef UTIL
#define UTIL
// default debug level. will be overidden e.g. if debug.h is included
#ifndef DEBUGLEVEL
#define DEBUGLEVEL 3
#endif
#if DEBUGLEVEL >= 0
#define Debug0(A) A
#else
#define Debug0(A)
#endif
#if DEBUGLEVEL >= 1
#define Debug1(A) A
#else
#define Debug1(A)
#endif
#if DEBUGLEVEL >= 2
#define Debug2(A) A
#else
#define Debug2(A)
#endif
#if DEBUGLEVEL >= 3
#define Debug3(A) A
#else
#define Debug3(A)
#endif
#if DEBUGLEVEL >= 4
#define Debug4(A) A
#else
#define Debug4(A)
#endif
#if DEBUGLEVEL >= 5
#define Debug5(A) A
#else
#define Debug5(A)
#endif
#if DEBUGLEVEL >= 6
#define Debug6(A) A
#else
#define Debug6(A)
#endif
#define Assert(c) if(!(c))\
{cout << "\nAssertion violation " << __FILE__ << ":" << __LINE__ << endl;}
#define Assert0(C) Debug0(Assert(C))
#define Assert1(C) Debug1(Assert(C))
#define Assert2(C) Debug2(Assert(C))
#define Assert3(C) Debug3(Assert(C))
#define Assert4(C) Debug4(Assert(C))
#define Assert5(C) Debug5(Assert(C))
#define Error(s) {cout << "\nError:" << s << " " << __FILE__ << ":" << __LINE__ << endl;}
////////////// min, max etc. //////////////////////////////////////
#ifndef Max
#define Max(x,y) ((x)>=(y)?(x):(y))
#endif
#ifndef Min
#define Min(x,y) ((x)<=(y)?(x):(y))
#endif
#ifndef Abs
#define Abs(x) ((x) < 0 ? -(x) : (x))
#endif
#ifndef PI
#define PI 3.1415927
#endif
// is this the right definition of limit?
inline double limit(double x, double bound)
{
if (x > bound) { return bound; }
else if (x < -bound) { return -bound; }
else return x;
}
/////////////////////// timing /////////////////////
#include <time.h>
// elapsed CPU time see also /usr/include/sys/time.h
inline double cpuTime()
{
return clock() * 1e-6;
}
#endif

2
src/mains/bench_psi.h
View File

@ -10,7 +10,7 @@
#include "../pk-based/dh-psi.h" #include "../pk-based/dh-psi.h"
#include "../ot-based/ot-psi.h" #include "../ot-based/ot-psi.h"
#include "../thirdparty-based/shpsi.h" #include "../server-aided/sapsi.h"
#include "../naive-hashing/naive-psi.h" #include "../naive-hashing/naive-psi.h"
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>

2
src/mains/psi_demo.h
View File

@ -10,7 +10,7 @@
#include "../pk-based/dh-psi.h" #include "../pk-based/dh-psi.h"
#include "../ot-based/ot-psi.h" #include "../ot-based/ot-psi.h"
#include "../thirdparty-based/shpsi.h" #include "../server-aided/sapsi.h"
#include "../naive-hashing/naive-psi.h" #include "../naive-hashing/naive-psi.h"
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>

114
src/naive-hashing/naive-psi.cpp
View File

@ -55,16 +55,12 @@ uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx
maskbytelen = ceil_divide(crypt_env->get_seclvl().statbits + ceil_log2(neles) + ceil_log2(pneles), 8); maskbytelen = ceil_divide(crypt_env->get_seclvl().statbits + ceil_log2(neles) + ceil_log2(pneles), 8);
//permeles = (uint8_t*) malloc(sizeof(uint8_t) * neles * elebytelen);
hashes = (uint8_t*) malloc(sizeof(uint8_t) * neles * maskbytelen); hashes = (uint8_t*) malloc(sizeof(uint8_t) * neles * maskbytelen);
perm = (uint32_t*) malloc(sizeof(uint32_t) * neles); perm = (uint32_t*) malloc(sizeof(uint32_t) * neles);
/* Generate the random permutation the elements */ /* Generate the random permutation the elements */
crypt_env->gen_rnd_perm(perm, neles); crypt_env->gen_rnd_perm(perm, neles);
//for(i = 0; i < neles; i++) {
// memcpy(permeles + perm[i] * elebytelen, elements + i * elebytelen, elebytelen);
//}
/* Hash and permute elements */ /* Hash and permute elements */
#ifdef DEBUG #ifdef DEBUG
@ -124,113 +120,3 @@ uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx
} }
/*uint32_t find_intersection_naive(uint8_t* hashes, uint32_t neles, uint8_t* phashes, uint32_t pneles,
uint32_t hashbytelen, uint32_t* perm, uint32_t* matches) {
uint32_t* invperm = (uint32_t*) malloc(sizeof(uint32_t) * neles);
//uint32_t* matches = (uint32_t*) malloc(sizeof(uint32_t) * neles);
uint64_t* tmpval;
uint32_t size_intersect, i, intersect_ctr;
for(i = 0; i < neles; i++) {
invperm[perm[i]] = i;
}
//cout << "My number of elements. " << neles << ", partner number of elements: " << pneles << ", maskbytelen: " << hashbytelen << endl;
GHashTable *map= g_hash_table_new_full(g_int64_hash, g_int64_equal, NULL, NULL);
for(i = 0; i < neles; i++) {
g_hash_table_insert(map,(void*) ((uint64_t*) &(hashes[i*hashbytelen])), &(invperm[i]));
}
//for(i = 0; i < pneles; i++) {
// ((uint64_t*) &(phashes[i*hashbytelen]))[0]++;
//}
for(i = 0, intersect_ctr = 0; i < pneles; i++) {
if(g_hash_table_lookup_extended(map, (void*) ((uint64_t*) &(phashes[i*hashbytelen])),
NULL, (void**) &tmpval)) {
matches[intersect_ctr] = tmpval[0];
intersect_ctr++;
assert(intersect_ctr <= min(neles, pneles));
}
}
size_intersect = intersect_ctr;
//result = (uint8_t**) malloc(sizeof(uint8_t*));
//(*result) = (uint8_t*) malloc(sizeof(uint8_t) * size_intersect * elebytelen);
//for(i = 0; i < size_intersect; i++) {
// memcpy((*result) + i * elebytelen, elements + matches[i] * elebytelen, elebytelen);
//}
free(invperm);
//free(matches);
return size_intersect;
}*/
/*void snd_and_rcv_naive(uint8_t* snd_buf, uint32_t snd_bytes, uint8_t* rcv_buf, uint32_t rcv_bytes, CSocket* sock) {
pthread_t snd_task;
bool created, joined;
snd_ctx ctx;
//Start new sender thread
ctx.sock = sock;
ctx.snd_buf = snd_buf;
ctx.snd_bytes = snd_bytes;
created = !pthread_create(&snd_task, NULL, send_data, (void*) &(ctx));
//receive
sock->Receive(rcv_buf, rcv_bytes);
assert(created);
joined = !pthread_join(snd_task, NULL);
assert(joined);
}*/
/*void run_task_naive(uint32_t nthreads, task_ctx context, void* (*func)(void*) ) {
task_ctx* contexts = (task_ctx*) malloc(sizeof(task_ctx) * nthreads);
pthread_t* threads = (pthread_t*) malloc(sizeof(pthread_t) * nthreads);
uint32_t i, neles_thread, electr, neles_cur;
bool created, joined;
neles_thread = ceil_divide(context.eles.nelements, nthreads);
for(i = 0, electr = 0; i < nthreads; i++) {
neles_cur = min(context.eles.nelements - electr, neles_thread);
memcpy(contexts + i, &context, sizeof(task_ctx));
//contexts[i].eles.nelements = neles_cur;
contexts[i].eles.startelement = electr;
contexts[i].eles.endelement = electr + neles_cur;
//contexts[i].eles.input = context.eles.input + (context.eles.inbytelen * electr);
//contexts[i].eles.output = context.eles.output + (context.eles.outbytelen * electr);
electr += neles_cur;
}
for(i = 0; i < nthreads; i++) {
created = !pthread_create(threads + i, NULL, func, (void*) &(contexts[i]));
}
assert(created);
for(i = 0; i < nthreads; i++) {
joined = !pthread_join(threads[i], NULL);
}
assert(joined);
free(threads);
free(contexts);
}*/
/*void *send_data_naive(void* context) {
snd_ctx_naive *ctx = (snd_ctx_naive*) context;
ctx->sock->Send(ctx->snd_buf, ctx->snd_bytes);
return 0;
}*/

49
src/naive-hashing/naive-psi.h
View File

@ -17,42 +17,6 @@
#include "../util/helpers.h" #include "../util/helpers.h"
/*struct element_ctx_naive {
uint32_t nelements;
union {
uint32_t fixed;
uint32_t* var;
} inbytelen;
union {
uint8_t* onedim;
uint8_t** twodim;
} inputs;
uint32_t outbytelen;
uint8_t* output;
uint32_t* perm;
bool varbytelen;
};
struct hash_ctx_naive {
crypto* symcrypt;
uint32_t startelement;
uint32_t endelement;
};*/
/*struct task_ctx_naive {
element_ctx_naive eles;
hash_ctx_naive hctx;
};*/
/*struct snd_ctx_naive {
uint8_t* snd_buf;
uint32_t snd_bytes;
CSocket* sock;
};*/
//TODO merge with dhpsi
void print_naive_psi_usage(); void print_naive_psi_usage();
uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, uint32_t* elebytelens, uint8_t** elements, uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, uint32_t* elebytelens, uint8_t** elements,
uint8_t*** result, uint32_t** resbytelens, crypto* crypt_env, CSocket* sock, uint32_t ntasks); uint8_t*** result, uint32_t** resbytelens, crypto* crypt_env, CSocket* sock, uint32_t ntasks);
@ -61,18 +25,5 @@ uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, uint32_t eleb
uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, uint32_t naivepsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx,
crypto* crypt_env, CSocket* sock, uint32_t ntasks, uint32_t* matches); crypto* crypt_env, CSocket* sock, uint32_t ntasks, uint32_t* matches);
//void run_task_naive(uint32_t nthreads, task_ctx context, void* (*func)(void*) );
//void permute_naive(uint32_t nelements, uint32_t bytelen, uint8_t* elements, uint8_t* result, uint32_t* perm);
//uint32_t find_intersection_naive(uint8_t* hashes, uint32_t neles, uint8_t* phashes, uint32_t pneles,
// uint32_t hashbytelen, uint32_t* perm, uint32_t* matches);
//void snd_and_rcv_naive(uint8_t* snd_buf, uint32_t snd_bytes, uint8_t* rcv_buf, uint32_t rcv_bytes, CSocket* sock);
//void *hash_naive(void* context);
//void *send_data_naive(void* context);
#endif /* NAIVE_PSI_H_ */ #endif /* NAIVE_PSI_H_ */

162
src/pk-based/dh-psi.cpp
View File

@ -65,9 +65,6 @@ uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, c
/* Generate a random permutation for the elements */ /* Generate a random permutation for the elements */
crypt_env->gen_rnd_perm(perm, neles); crypt_env->gen_rnd_perm(perm, neles);
//for(i = 0; i < neles; i++) {
// memcpy(permeles + perm[i] * elebytelen, elements + i * elebytelen, elebytelen);
//}
/* Hash elements */ /* Hash elements */
ectx.eles.output = hashes; ectx.eles.output = hashes;
@ -106,20 +103,6 @@ uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, c
snd_and_rcv(encrypted_eles, neles * fe_bytes, peles, pneles * fe_bytes, tmpsock); snd_and_rcv(encrypted_eles, neles * fe_bytes, peles, pneles * fe_bytes, tmpsock);
/*if(cardinality) {
//samle permutation, permute elements, and copy back to original array
cardinality_perm = (uint32_t*) malloc(sizeof(uint32_t) * pneles);
crypt_env->gen_rnd_perm(cardinality_perm, pneles);
perm_peles = (uint8_t*) malloc(pneles * fe_bytes);
for(i = 0; i < pneles; i++) {
memcpy(perm_peles + cardinality_perm[i] * fe_bytes, peles + i * fe_bytes, fe_bytes);
}
memcpy(peles, perm_peles, fe_bytes * pneles);
free(cardinality_perm);
free(perm_peles);
}*/
/* Import and Encrypt elements again */ /* Import and Encrypt elements again */
ectx.eles.input1d = peles; ectx.eles.input1d = peles;
ectx.eles.output = peles; ectx.eles.output = peles;
@ -187,7 +170,6 @@ uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, c
cout << "Free-ing allocated memory" << endl; cout << "Free-ing allocated memory" << endl;
#endif #endif
free(perm); free(perm);
//free(permeles);
free(encrypted_eles); free(encrypted_eles);
free(hashes); free(hashes);
free(peles); free(peles);
@ -196,147 +178,3 @@ uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, c
return intersect_size; return intersect_size;
} }
/*uint32_t find_intersection(uint8_t* elements, uint8_t** result, uint32_t elebytelen, uint8_t* hashes,
uint32_t neles, uint8_t* phashes, uint32_t npeles, uint32_t hashbytelen, uint32_t* perm) {
uint32_t* invperm = (uint32_t*) malloc(sizeof(uint32_t) * neles);
uint32_t* matches = (uint32_t*) malloc(sizeof(uint32_t) * neles);
uint64_t* tmpinbuf;
uint64_t* tmpval;
uint32_t size_intersect, i, intersect_ctr, nextrakeysstored, j;
bool success;
nextrakeysstored = ceil_divide(hashbytelen, sizeof(uint64_t))-1;
cout << "hashbytelen = " << hashbytelen << ", nextrakeysstored = " << nextrakeysstored << endl;
//store all the extra keys as well as the
tmpinbuf = (uint64_t*) malloc(neles * (nextrakeysstored+1) * sizeof(uint64_t));
for(i = 0; i < neles; i++) {
memcpy(tmpinbuf + i * (nextrakeysstored+1), hashes + i * hashbytelen + sizeof(uint64_t),
nextrakeysstored*sizeof(uint64_t));
tmpinbuf[perm[i] * (nextrakeysstored+1) + nextrakeysstored] = (uint64_t) i;
//invperm[perm[i]] = i;
}
GHashTable *map= g_hash_table_new_full(g_int64_hash, g_int64_equal, NULL, NULL);
for(i = 0; i < neles; i++) {
// g_hash_table_insert(map,(void*) ((uint64_t*) &(hashes[i*hashbytelen])), &(invperm[i]));
g_hash_table_insert(map,(void*) ((uint64_t*) &(hashes[i*hashbytelen])), &(tmpinbuf[i*(nextrakeysstored+1)]));
}
for(i = 0, intersect_ctr = 0; i < npeles; i++) {
success = true;
if(g_hash_table_lookup_extended(map, (void*) ((uint64_t*) &(phashes[i*hashbytelen])),
NULL, (void**) &tmpval)) {
for(j = 0; j < nextrakeysstored; j++) {
if(((uint64_t*) &(phashes[i*hashbytelen]))[j+1] != tmpval[j]) {
success = false;
}
}
if(success) {
matches[intersect_ctr] = tmpval[nextrakeysstored];
intersect_ctr++;
}
}
}
size_intersect = intersect_ctr;
//result = (uint8_t**) malloc(sizeof(uint8_t*));
(*result) = (uint8_t*) malloc(sizeof(uint8_t) * size_intersect * elebytelen);
for(i = 0; i < size_intersect; i++) {
memcpy((*result) + i * elebytelen, elements + matches[i] * elebytelen, elebytelen);
}
free(invperm);
free(matches);
free(tmpinbuf);
return size_intersect;
}*/
/*void snd_and_rcv(uint8_t* snd_buf, uint32_t snd_bytes, uint8_t* rcv_buf, uint32_t rcv_bytes, CSocket* sock) {
pthread_t snd_task;
bool created, joined;
snd_ctx ctx;
//Start new sender thread
ctx.sock = sock;
ctx.snd_buf = snd_buf;
ctx.snd_bytes = snd_bytes;
created = !pthread_create(&snd_task, NULL, send_data, (void*) &(ctx));
//receive
sock->Receive(rcv_buf, rcv_bytes);
assert(created);
joined = !pthread_join(snd_task, NULL);
assert(joined);
}*/
/*void run_task(uint32_t nthreads, task_ctx context, void* (*func)(void*) ) {
task_ctx* contexts = (task_ctx*) malloc(sizeof(task_ctx) * nthreads);
pthread_t* threads = (pthread_t*) malloc(sizeof(pthread_t) * nthreads);
uint32_t i, neles_thread, electr, neles_cur;
bool created, joined;
neles_thread = ceil_divide(context.eles.nelements, nthreads);
for(i = 0, electr = 0; i < nthreads; i++) {
neles_cur = min(context.eles.nelements - electr, neles_thread);
memcpy(contexts + i, &context, sizeof(task_ctx));
contexts[i].eles.nelements = neles_cur;
//contexts[i].eles.input = context.eles.input + (context.eles.inbytelen * electr);
//contexts[i].eles.output = context.eles.output + (context.eles.outbytelen * electr);
contexts[i].eles.startelement = electr;
contexts[i].eles.endelement = electr + neles_cur;
electr += neles_cur;
}
for(i = 0; i < nthreads; i++) {
created = !pthread_create(threads + i, NULL, func, (void*) &(contexts[i]));
}
assert(created);
for(i = 0; i < nthreads; i++) {
joined = !pthread_join(threads[i], NULL);
}
assert(joined);
free(threads);
free(contexts);
}*/
/*void *hash(void* context) {
#ifdef DEBUG
cout << "Hashing thread started" << endl;
#endif
crypto* crypt_env = ((task_ctx*) context)->hctx.symcrypt;
element_ctx electx = ((task_ctx*) context)->eles;
uint8_t *inptr=electx.input, *outptr=electx.output;
uint32_t i;
for(i = 0; i < electx.nelements; i++, inptr+=electx.inbytelen, outptr+=electx.outbytelen) {
crypt_env->hash(outptr, electx.outbytelen, inptr, electx.inbytelen);
}
return 0;
}*/
/*void *send_data(void* context) {
snd_ctx *ctx = (snd_ctx*) context;
ctx->sock->Send(ctx->snd_buf, ctx->snd_bytes);
return 0;
}*/

45
src/pk-based/dh-psi.h
View File

@ -17,38 +17,6 @@
#include "../util/helpers.h" #include "../util/helpers.h"
/*struct element_ctx {
uint32_t nelements;
uint32_t inbytelen;
uint8_t* input;
uint32_t outbytelen;
uint8_t* output;
};*/
/*struct encrypt_ctx {
num* exponent;
pk_crypto* field;
bool sample;
};*/
//struct hash_ctx {
// crypto* symcrypt;
//};
/*struct task_ctx {
element_ctx eles;
union {
hash_ctx hctx;
encrypt_ctx ectx;
};
};*/
/*struct snd_ctx {
uint8_t* snd_buf;
uint32_t snd_bytes;
CSocket* sock;
};*/
uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, uint32_t* elebytelens, uint8_t** elements, uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, uint32_t* elebytelens, uint8_t** elements,
uint8_t*** result, uint32_t** resbytelens, crypto* crypt_env, CSocket* sock, uint32_t ntasks, uint8_t*** result, uint32_t** resbytelens, crypto* crypt_env, CSocket* sock, uint32_t ntasks,
bool cardinality=false, field_type ftype=ECC_FIELD); bool cardinality=false, field_type ftype=ECC_FIELD);
@ -59,18 +27,7 @@ uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, uint32_t elebyte
uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, crypto* crypt_env, CSocket* sock, uint32_t dhpsi(role_type role, uint32_t neles, uint32_t pneles, task_ctx ectx, crypto* crypt_env, CSocket* sock,
uint32_t ntasks, uint32_t* matches, bool cardinality=false, field_type ftype=ECC_FIELD); uint32_t ntasks, uint32_t* matches, bool cardinality=false, field_type ftype=ECC_FIELD);
//void run_task(uint32_t nthreads, task_ctx context, void* (*func)(void*) );
//void permute(uint32_t nelements, uint32_t bytelen, uint8_t* elements, uint8_t* result, uint32_t* perm);
//uint32_t find_intersection(uint8_t* elements, uint8_t** result, uint32_t elebytelen, uint8_t* hashes,
// uint32_t neles, uint8_t* phashes, uint32_t peles, uint32_t hashbytelen, uint32_t* perm);
//void snd_and_rcv(uint8_t* snd_buf, uint32_t snd_bytes, uint8_t* rcv_buf, uint32_t rcv_bytes, CSocket* sock);
//void *encrypt(void* context);
//void *hash(void* context);
//void *send_data(void* context);
#endif /* DH_PSI_H_ */ #endif /* DH_PSI_H_ */

48
src/thirdparty-based/shpsi.cpp → src/server-aided/sapsi.cpp
View File

@ -1,50 +1,4 @@
#include "shpsi.h" #include "sapsi.h"
/*int32_t main(int32_t argc, char** argv) {
uint32_t pid, nclients, nelements, elebytelen, symsecbits;
uint8_t *elements, *intersection;
const char* address;
uint16_t port;
timeval begin, end;
if(argc < 2) {
print_sh_psi_usage();
} else {
pid = atoi(argv[1]);
if((pid == 0 && argc < 5) || (pid > 0 && argc < 6)) print_sh_psi_usage();
}
if(pid == 0) { // Play as server
nclients = atoi(argv[2]);
address = argv[3];
port = (uint16_t) atoi(argv[4]);
server_routine(nclients, address, port);
} else { // Play as client
nelements = atoi(argv[2]);
elebytelen = atoi(argv[3]);
symsecbits = atoi(argv[4]);
address = argv[5];
port = atoi(argv[6]);
elements = (uint8_t*) malloc(sizeof(uint8_t) * elebytelen * nelements);
crypto crypto(symsecbits);
crypto.gen_rnd(elements, elebytelen * nelements);
#ifdef DEBUG
//Load some dummy-values
for(uint32_t i = 0; i < nelements; i++) {
((uint32_t*) elements)[i] = i+(nelements/pid);
}
#endif
gettimeofday(&begin, NULL);
client_routine(nelements, elebytelen, elements, &intersection, symsecbits, address, port);
gettimeofday(&end, NULL);
cout << "Computing the intersection took " << getMillies(begin, end) << " ms" << endl;
}
cout << "Program execution finished" << endl;
return 0;
}*/
void server_routine(uint32_t nclients, CSocket* socket, bool cardinality) { void server_routine(uint32_t nclients, CSocket* socket, bool cardinality) {
//cout << "Starting server for " << nclients << " clients on address " << address << ":" << port << endl; //cout << "Starting server for " << nclients << " clients on address " << address << ":" << port << endl;

0
src/thirdparty-based/shpsi.h → src/server-aided/sapsi.h
View File