IBBE clean-up

Author: stefan-contiu

pbc_ibbe/ibbe.c

@@ -66,14 +66,6 @@ int setup_sgx_safe(PublicKey *puk, ShortPublicKey *spuk, MasterSecretKey *msk, i
         }
         mpz_clear(n);
 
-        // Most likely these commented lines are useless, will keep them until
-        // all tests w/ and w/out SGX are finalized, then remove!
-        /*h ^ r ^ (-1)*/
-        //element_init_G1(hRec[i], pairing);
-        //element_invert(temp1, r);
-        //element_pow_zn(hRec[i], h, temp1);
-        // ---- end commented lines
-
         puk->h = hRec;
         element_init_G1(puk->w, pairing);
         element_init_GT(puk->v, pairing);
@@ -397,11 +389,9 @@ struct exp_part_struct {
     element_t* polyA;
 };
 
-void *exponentiate_by_partition(void *pargs)
+void *decrypt_exponentiate_by_partition(void *pargs)
 {
     struct exp_part_struct *args = (struct exp_part_struct *)pargs;
-//    printf("PART START : %d\n", args->start);
-//    printf("PART END   : %d\n", args->end);
 
     /* old style exponentiation */
     element_t thread_temp2;
@@ -411,36 +401,31 @@ void *exponentiate_by_partition(void *pargs)
     element_set1(*ptemp);
 
     element_init_G1(thread_temp2, pairing);
-    //element_set1(thread_temp1);
 
     int i;
-    int max = 0;
     for (i = args->start; i <= args->end - 3; i+=3)
     {
         element_pow3_zn(thread_temp2,
-            args->key.h[i], args->polyA[i],
-            args->key.h[i+1], args->polyA[i+1],
-            args->key.h[i+2], args->polyA[i+2]);
+            args->key.h[i], args->polyA[i+1],
+            args->key.h[i+1], args->polyA[i+2],
+            args->key.h[i+2], args->polyA[i+3]);
         element_mul(*ptemp, *ptemp, thread_temp2);
-        max = i > max ? i : max;
     }
     // exponentiate and multiply any leftovers
     if (i <= args->end)
     {
         for (int j = i; j <= args->end; j++)
         {
-            element_pow_zn(thread_temp2, args->key.h[j], args->polyA[j]);
+            element_pow_zn(thread_temp2, args->key.h[j], args->polyA[j+1]);
             element_mul(*ptemp, *ptemp, thread_temp2);
-            max = i > max ? i : max;
         }
     }
 
-    printf("Max %d\n", max);
     pthread_exit(ptemp);
     return (void*) ptemp;
 }
 
-int decrypt_user(int sw, BroadcastKey* bKey, Ciphertext cipher, PublicKey key, UserPrivateKey ikey, char* id, char idSet[][MAX_STRING_LENGTH], int idCount)
+int decrypt_user(BroadcastKey* bKey, Ciphertext cipher, PublicKey key, UserPrivateKey ikey, char* id, char idSet[][MAX_STRING_LENGTH], int idCount)
 {
     int i, j;
     int mark = 1;
@@ -511,26 +496,25 @@ int decrypt_user(int sw, BroadcastKey* bKey, Ciphertext cipher, PublicKey key, U
             element_set1(htemp1);
 
             // multithreading
-            if (sw == 1)
             {
                 int idNum = idCount - 2;
-                int exp_per_partition = idNum / THREADS_COUNT;
+                int exp_per_partition = (idNum / THREADS_COUNT) + 1;
 
                 pthread_t tid[THREADS_COUNT];
                 for(int thread_idx = 0; thread_idx < THREADS_COUNT; thread_idx++)
                 {
                     // compute the partition of exponentiations
-                    struct exp_part_struct* args= malloc (sizeof (struct exp_part_struct));
-                    args->start = thread_idx * exp_per_partition;
-                    args->end = args->start + exp_per_partition - 1;
+                    struct exp_part_struct* args = malloc (sizeof (struct exp_part_struct));
                     args->key = key;
                     args->polyA = polyA;
-                    if (thread_idx == THREADS_COUNT - 1)
+                    args->start = thread_idx * exp_per_partition;
+                    args->end = args->start + exp_per_partition - 1;
+                    if (args->end > idNum)
                     {
-                        args->end += 2;
+                        args->end = idNum;
                     }
 
-                    pthread_create(&tid[thread_idx], NULL, exponentiate_by_partition, (void *)args);
+                    pthread_create(&tid[thread_idx], NULL, decrypt_exponentiate_by_partition, (void *)args);
                 }
 
                 element_t result;
@@ -543,17 +527,6 @@ int decrypt_user(int sw, BroadcastKey* bKey, Ciphertext cipher, PublicKey key, U
                     pthread_join(tid[thread_idx], &partition_result);
                     element_mul(htemp1, htemp1, *(element_t*)partition_result);
                 }
-
-                //element_printf("THR TEMP1 : %B\n", result);
-            }
-            else
-            {
-                for (i = 0; i < idCount-1; i++)
-                {
-                    element_pow_zn(htemp2, key.h[i], polyA[i+1]);
-                    element_mul(htemp1, htemp1, htemp2);
-                    printf("USING %d\n", i);
-                }
             }
         }
         /*
@@ -592,208 +565,3 @@ int decrypt_user(int sw, BroadcastKey* bKey, Ciphertext cipher, PublicKey key, U
 
     return 0;
 }
-
-
-int Encrypt(Ciphertext *cipher, PublicKey key, char idSet[][MAX_STRING_LENGTH], int idNum)
-{
-    element_t k;
-    element_t m;
-    element_t c1, c2, c3;
-    element_t temp1, temp2;
-
-    element_init_GT(m, pairing);
-    element_init_G1(c1, pairing);
-    element_init_G1(c2, pairing);
-    element_init_GT(c3, pairing);
-    element_init_G1(temp1, pairing);
-    element_init_G1(temp2, pairing);
-
-    //element_random(k);
-    //element_set_mpz(m, message);
-
-    /*compute c1 = w ^ -k*/
-    {
-        element_pow_zn(c1, key.w, k);
-        element_invert(c1, c1);
-    }
-
-    /*compute c2 = h ^ (k * (r+H(ID)...)*/
-    {
-        /*polynominal multiplication */
-        /***************************************/
-        int i, j;
-        /*
-        element_t hid[idNum + 1];
-        element_t polyA[idNum + 1], polyB[idNum + 1];
-        */
-        element_t *hid;
-        element_t *polyA, *polyB;
-        hid = (element_t*)malloc(sizeof(element_t) * idNum);
-        polyA = (element_t*)malloc(sizeof(element_t) * (idNum+1));
-        polyB = (element_t*)malloc(sizeof(element_t) * (idNum+1));
-
-        clock_t time1, time2;
-
-        /*initialization*/
-        time1 = clock();
-        for (i = 0; i < idNum+1; i++)
-        {
-            element_init_Zr(polyA[i], pairing);
-            element_set0(polyA[i]);
-            element_init_Zr(polyB[i], pairing);
-            element_set0(polyB[i]);
-            element_init_Zr(hid[i], pairing);
-            if (i < idNum)
-            {
-                //printf("Receiver %d: %s\n", i+1, idSet+i*5);
-
-
-                //unsigned char ibuf[] = "compute sha1";
-                unsigned char obuf[20];
-
-                //SHA1(ibuf, strlen(ibuf), obuf);
-                //SHA1(idSet[i], strlen(idSet[i]), obuf);
-
-                element_from_hash(hid[i], idSet[i], strlen(idSet[i]));
-                //element_from_hash(hid[i], obuf, strlen(obuf));
-                //element_random(hid[i]);
-            }
-        }
-        time2 = clock();
-        printf("@Computing hashes : %lfms\n\n ", 1000.0*(time2-time1)/CLOCKS_PER_SEC);
-
-        /*calculation*/
-        time1 = clock();
-        element_set(polyA[0], hid[0]);
-        element_set1(polyA[1]);
-        for (i = 1; i < idNum; i++)
-        {
-            /*i-th polynomial*/
-            /*polyA * (r + H(ID))*/
-            element_set1(polyA[i+1]);
-            for (j = i; j >= 1; j--)
-            {
-                element_mul(polyB[j], polyA[j], hid[i]);
-                element_add(polyA[j], polyA[j-1], polyB[j]);
-                //element_printf("%B\n", polyA[j]);
-            }
-            element_mul(polyA[0], polyA[0], hid[i]);
-        }
-        time2 = clock();
-        printf("@Polynomial expansion : %lfms\n\n ", 1000.0*(time2-time1)/CLOCKS_PER_SEC);
-
-        printf("START COUNTING ... \n");
-        clock_t time_exp = clock();
-        /* old style exponentiation */
-        /*
-        element_t old_temp1, old_temp2;
-        element_init_G1(old_temp1, pairing);
-        element_init_G1(old_temp2, pairing);
-        element_set1(old_temp1);
-        for (i = 0; i < idNum+1; i++)
-        {
-            element_pow_zn(old_temp2, key.h[i], polyA[i]);
-            element_mul(old_temp1, old_temp1, old_temp2);
-        }
-        element_printf("OLD TEMP1 : %B\n", old_temp1);
-        */
-        /* finished old style exponentation */
-
-        /* 3-Batch Exponentation */
-/*        element_set1(temp1);
-        for (i = 0; i < idNum-1; i+=3)
-        {
-            element_pow3_zn(temp2,
-                key.h[i], polyA[i],
-                key.h[i+1], polyA[i+1],
-                key.h[i+2], polyA[i+2]);
-            element_mul(temp1, temp1, temp2);
-        }
-        // exponentiate and multiply any leftovers
-        if (i < idNum + 1)
-        {
-            for (j = i; j < idNum + 1; j++)
-            {
-                element_pow_zn(temp2, key.h[j], polyA[j]);
-                element_mul(temp1, temp1, temp2);
-            }
-        }
-        element_printf("NEW TEMP1 : %B\n", temp1);
-*/
-
-        /* Multithreaded exponentation */
-/*
-        if (idNum > 299)
-        {
-            // it's worth doing parallel once groups get some users
-            int THREADS_COUNT = 8;
-            int exp_per_partition = idNum / THREADS_COUNT;
-
-            pthread_t tid[THREADS_COUNT];
-            for(int thread_idx = 0; thread_idx < THREADS_COUNT; thread_idx++)
-            {
-                // compute the partition of exponentiations
-                struct exp_part_struct* args= malloc (sizeof (struct exp_part_struct));
-                args->start = thread_idx * exp_per_partition;
-                args->end = args->start + exp_per_partition - 1;
-                args->key = key;
-                args->polyA = polyA;
-                if (thread_idx == THREADS_COUNT - 1)
-                {
-                    args->end++;
-                }
-
-                pthread_create(&tid[thread_idx], NULL, exponentiate_by_partition, (void *)args);
-            }
-
-            element_t result;
-            element_init_G1(result, pairing);
-            element_set1(result);
-            // wait that threads are complete
-            for(int thread_idx = 0; thread_idx < THREADS_COUNT; thread_idx++)
-            {
-                void* partition_result;
-                pthread_join(tid[thread_idx], &partition_result);
-                if (partition_result == NULL)
-                {
-                    printf("NULL PASSED !!!!\n");
-                }
-                element_mul(temp1, temp1, *(element_t*)partition_result);
-            }
-
-            //element_printf("THR TEMP1 : %B\n", result);
-        }
-
-        clock_t time_exp_end = clock();
-        printf("@linear exponentiations : %lu\n ", time_exp_end - time_exp);
-*/
-        element_pow_zn(c2, temp1, k);
-    //    printf("c2 second half computed !!!!\n");
-
-        /*
-        free(hid);
-        free(polyA);
-        free(polyB);
-        */
-    }
-
-    /*calculate c3 = v^k * m*/
-    {
-        element_pow_zn(c3, key.v, k);
-        element_mul(c3, c3, m);
-    }
-
-    element_init_G1(cipher->c1, pairing);
-    element_init_G1(cipher->c2, pairing);
-    //element_init_GT(cipher->c3, pairing);
-    element_set(cipher->c1, c1);
-    element_set(cipher->c2, c2);
-    //element_set(cipher->c3, c3);
-
-    element_clear(k);
-    element_clear(m);
-    element_clear(temp1);
-    element_clear(temp2);
-
-    return 0;
-}

pbc_ibbe/ibbe.h

@@ -5,7 +5,7 @@
 #include <time.h>
 #include <string.h>
 
-#define MAX_RECEIVER 100
+#define MAX_RECEIVER 1000
 #define MAX_STRING_LENGTH 20
 #define THREADS_COUNT 8
 
@@ -46,7 +46,7 @@ int decrypt_sgx_safe(BroadcastKey* bKey, Ciphertext cipher,
     char* id, char idSet[][MAX_STRING_LENGTH], int idCount);
 
 /* NON-SGX METHODS - FOR USER USE */
-int decrypt_user(int sw, BroadcastKey* bKey,
+int decrypt_user(BroadcastKey* bKey,
     Ciphertext cipher, PublicKey key, UserPrivateKey ikey,
     char* id, char idSet[][MAX_STRING_LENGTH], int idCount);
 

pbc_ibbe/test.c

@@ -29,7 +29,6 @@ int main(int argc, char** argv)
     PublicKey pubkey;
     MasterSecretKey prvkey;
     ShortPublicKey shortPubKey;
-    //UserPrivateKey idkey[MAX_RECEIVER+1];
 
     setup_sgx_safe(&pubkey, &shortPubKey, &prvkey, argc, argv);
 
@@ -58,7 +57,7 @@ int main(int argc, char** argv)
         print_key(oldStyleBroadcastKey);
 
         BroadcastKey userBroadcastKey;
-        decrypt_user(1, &userBroadcastKey, cipher, pubkey,
+        decrypt_user(&userBroadcastKey, cipher, pubkey,
             usr13PriKey, "[email protected]", S, MAX_RECEIVER);
         printf("USR DECR. KEY : ");
         print_key(userBroadcastKey);