summaryrefslogtreecommitdiffstats
path: root/moon-abe/libbswabe-0.9/misc.c
diff options
context:
space:
mode:
Diffstat (limited to 'moon-abe/libbswabe-0.9/misc.c')
-rw-r--r--moon-abe/libbswabe-0.9/misc.c532
1 files changed, 532 insertions, 0 deletions
diff --git a/moon-abe/libbswabe-0.9/misc.c b/moon-abe/libbswabe-0.9/misc.c
new file mode 100644
index 00000000..d6574ee8
--- /dev/null
+++ b/moon-abe/libbswabe-0.9/misc.c
@@ -0,0 +1,532 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+#include <pbc.h>
+
+#include "bswabe.h"
+#include "private.h"
+/* Serialize a 32 bit int
+ is used to serialize the lenght of the element
+ for each element first there its lenght on 32 bits then the element */
+void
+serialize_uint32( GByteArray* b, uint32_t k )
+{
+ int i;
+ guint8 byte;
+
+ for( i = 3; i >= 0; i-- )
+ {
+ byte = (k & 0xff<<(i*8))>>(i*8);
+ g_byte_array_append(b, &byte, 1);
+ }
+}
+
+uint32_t
+unserialize_uint32( GByteArray* b, int* offset )
+{
+ int i;
+ uint32_t r;
+
+ r = 0;
+ for( i = 3; i >= 0; i-- )
+ r |= (b->data[(*offset)++])<<(i*8);
+
+ return r;
+}
+
+/* First stores the length of the element then the bytes of the element
+ Knowing the length of the element is necessary in order to unserialize it */
+void
+serialize_element( GByteArray* b, element_t e )
+{
+ uint32_t len;
+ unsigned char* buf;
+
+ len = element_length_in_bytes(e);
+ serialize_uint32(b, len);
+
+ buf = (unsigned char*) malloc(len);
+ element_to_bytes(buf, e);
+ g_byte_array_append(b, buf, len);
+ free(buf);
+}
+
+void
+unserialize_element( GByteArray* b, int* offset, element_t e )
+{
+ uint32_t len;
+ unsigned char* buf;
+
+ len = unserialize_uint32(b, offset);
+
+ buf = (unsigned char*) malloc(len);
+ memcpy(buf, b->data + *offset, len);
+ *offset += len;
+
+ element_from_bytes(e, buf);
+ free(buf);
+}
+
+void
+serialize_string( GByteArray* b, char* s )
+{
+ g_byte_array_append(b, (unsigned char*) s, strlen(s) + 1);
+}
+
+char*
+unserialize_string( GByteArray* b, int* offset )
+{
+ GString* s;
+ char* r;
+ char c;
+
+ s = g_string_sized_new(32);
+ while( 1 )
+ {
+ c = b->data[(*offset)++];
+ if( c && c != EOF )
+ g_string_append_c(s, c);
+ else
+ break;
+ }
+
+ r = s->str;
+ g_string_free(s, 0);
+
+ return r;
+}
+
+GByteArray*
+bswabe_pub_serialize( bswabe_pub_t* pub )
+{
+ GByteArray* b;
+
+ b = g_byte_array_new();
+ serialize_string(b, pub->pairing_desc);
+ serialize_element(b, pub->g);
+ serialize_element(b, pub->h);
+ serialize_element(b, pub->gp);
+ serialize_element(b, pub->g_hat_alpha);
+
+ return b;
+}
+
+bswabe_pub_t*
+bswabe_pub_unserialize( GByteArray* b, int free )
+{
+ bswabe_pub_t* pub;
+ int offset;
+
+ pub = (bswabe_pub_t*) malloc(sizeof(bswabe_pub_t));
+ offset = 0;
+
+ pub->pairing_desc = unserialize_string(b, &offset);
+ pairing_init_set_buf(pub->p, pub->pairing_desc, strlen(pub->pairing_desc));
+
+ element_init_G1(pub->g, pub->p);
+ element_init_G1(pub->h, pub->p);
+ element_init_G2(pub->gp, pub->p);
+ element_init_GT(pub->g_hat_alpha, pub->p);
+
+ unserialize_element(b, &offset, pub->g);
+ unserialize_element(b, &offset, pub->h);
+ unserialize_element(b, &offset, pub->gp);
+ unserialize_element(b, &offset, pub->g_hat_alpha);
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return pub;
+}
+
+GByteArray*
+bswabe_msk_serialize( bswabe_msk_t* msk )
+{
+ GByteArray* b;
+
+ b = g_byte_array_new();
+ serialize_element(b, msk->beta);
+ serialize_element(b, msk->g_alpha);
+
+ return b;
+}
+
+bswabe_msk_t*
+bswabe_msk_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ bswabe_msk_t* msk;
+ int offset;
+
+ msk = (bswabe_msk_t*) malloc(sizeof(bswabe_msk_t));
+ offset = 0;
+
+ element_init_Zr(msk->beta, pub->p);
+ element_init_G2(msk->g_alpha, pub->p);
+
+ unserialize_element(b, &offset, msk->beta);
+ unserialize_element(b, &offset, msk->g_alpha);
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return msk;
+}
+
+GByteArray*
+bswabe_prv_serialize( bswabe_prv_t* prv )
+{
+ GByteArray* b;
+ int i;
+
+ b = g_byte_array_new();
+
+ serialize_element(b, prv->d);
+ serialize_uint32( b, prv->comps->len);
+
+ for( i = 0; i < prv->comps->len; i++ )
+ {
+ serialize_string( b, g_array_index(prv->comps, bswabe_prv_comp_t, i).attr);
+ serialize_element(b, g_array_index(prv->comps, bswabe_prv_comp_t, i).d);
+ serialize_element(b, g_array_index(prv->comps, bswabe_prv_comp_t, i).dp);
+ }
+
+ return b;
+}
+
+bswabe_prv_t*
+bswabe_prv_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ bswabe_prv_t* prv;
+ int i;
+ int len;
+ int offset;
+
+ prv = (bswabe_prv_t*) malloc(sizeof(bswabe_prv_t));
+ offset = 0;
+
+ element_init_G2(prv->d, pub->p);
+ unserialize_element(b, &offset, prv->d);
+
+ prv->comps = g_array_new(0, 1, sizeof(bswabe_prv_comp_t));
+ len = unserialize_uint32(b, &offset);
+
+ for( i = 0; i < len; i++ )
+ {
+ bswabe_prv_comp_t c;
+
+ c.attr = unserialize_string(b, &offset);
+
+ element_init_G2(c.d, pub->p);
+ element_init_G2(c.dp, pub->p);
+
+ unserialize_element(b, &offset, c.d);
+ unserialize_element(b, &offset, c.dp);
+
+ g_array_append_val(prv->comps, c);
+ }
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return prv;
+}
+/*
+GByteArray*
+peks_trap_serialize( peks_trap_t* trap )
+{
+ GByteArray* b;
+
+ b = g_byte_array_new();
+
+ serialize_element(b, trap->T);
+
+ return b;
+}
+peks_trap_t*
+peks_trap_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ peks_trap_t* trap;
+ int offset;
+
+ trap = (peks_trap_t*) malloc(sizeof(peks_trap_t));
+ offset = 0;
+
+ unserialize_element(b, &offset, trap->T);
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return trap;
+}
+
+*/
+GByteArray*
+peks_ind_serialize( peks_ind_t* ind )
+{
+ GByteArray* b;
+ int i;
+
+ b = g_byte_array_new();
+
+ /* First serialize the number of components */
+ serialize_uint32( b, ind->comps->len);
+
+ for( i = 0; i < ind->comps->len; i++ )
+ {
+ serialize_element(b, g_array_index(ind->comps, peks_sew_t, i).A );
+ serialize_element(b, g_array_index(ind->comps, peks_sew_t, i).B );
+ }
+
+ return b;
+}
+
+peks_ind_t*
+peks_ind_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ peks_ind_t* ind;
+ int i;
+ int len;
+ int offset;
+
+ ind = (peks_ind_t*) malloc(sizeof(peks_ind_t));
+ offset = 0;
+
+ ind->comps = g_array_new(0, 1, sizeof(peks_sew_t));
+ len = unserialize_uint32(b, &offset);
+
+ for( i = 0; i < len; i++ )
+ {
+ peks_sew_t sew;
+
+
+ element_init_G1(sew.A, pub->p);
+ element_init_GT(sew.B, pub->p);
+
+ unserialize_element(b, &offset, sew.A);
+ unserialize_element(b, &offset, sew.B);
+
+ g_array_append_val(ind->comps, sew);
+ }
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return ind;
+}
+
+void
+serialize_policy( GByteArray* b, bswabe_policy_t* p )
+{
+ int i;
+
+ serialize_uint32(b, (uint32_t) p->k);
+
+ serialize_uint32(b, (uint32_t) p->children->len);
+ if( p->children->len == 0 )
+ {
+ serialize_string( b, p->attr);
+ serialize_element(b, p->c);
+ serialize_element(b, p->cp);
+ }
+ else
+ for( i = 0; i < p->children->len; i++ )
+ serialize_policy(b, g_ptr_array_index(p->children, i));
+}
+
+bswabe_policy_t*
+unserialize_policy( bswabe_pub_t* pub, GByteArray* b, int* offset )
+{
+ int i;
+ int n;
+ bswabe_policy_t* p;
+
+ p = (bswabe_policy_t*) malloc(sizeof(bswabe_policy_t));
+
+ p->k = (int) unserialize_uint32(b, offset);
+ p->attr = 0;
+ p->children = g_ptr_array_new();
+
+ n = unserialize_uint32(b, offset);
+ if( n == 0 )
+ {
+ p->attr = unserialize_string(b, offset);
+ element_init_G1(p->c, pub->p);
+ element_init_G1(p->cp, pub->p);
+ unserialize_element(b, offset, p->c);
+ unserialize_element(b, offset, p->cp);
+ }
+ else
+ for( i = 0; i < n; i++ )
+ g_ptr_array_add(p->children, unserialize_policy(pub, b, offset));
+
+ return p;
+}
+
+GByteArray*
+bswabe_cph_serialize( bswabe_cph_t* cph )
+{
+ GByteArray* b;
+
+ b = g_byte_array_new();
+ serialize_element(b, cph->cs);
+ serialize_element(b, cph->c);
+ serialize_policy( b, cph->p);
+ serialize_string( b, cph->policy);
+
+ return b;
+}
+
+bswabe_cph_t*
+bswabe_cph_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ bswabe_cph_t* cph;
+ int offset;
+
+ cph = (bswabe_cph_t*) malloc(sizeof(bswabe_cph_t));
+ offset = 0;
+
+ element_init_GT(cph->cs, pub->p);
+ element_init_G1(cph->c, pub->p);
+ unserialize_element(b, &offset, cph->cs);
+ unserialize_element(b, &offset, cph->c);
+ cph->p = unserialize_policy(pub, b, &offset);
+ cph->policy = unserialize_string(b, &offset);
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return cph;
+}
+
+GByteArray*
+peks_sew_serialize( peks_sew_t* sew )
+{
+ GByteArray* b;
+
+ b = g_byte_array_new();
+ serialize_element(b, sew->A);
+ serialize_element(b, sew->B);
+
+ return b;
+}
+
+peks_sew_t*
+peks_sew_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ peks_sew_t* sew;
+ int offset;
+
+ sew = (peks_sew_t*) malloc(sizeof(peks_sew_t));
+ offset = 0;
+
+ element_init_G1(sew->A, pub->p);
+ element_init_GT(sew->B, pub->p);
+
+ unserialize_element(b, &offset, sew->A);
+ unserialize_element(b, &offset, sew->B);
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return sew;
+}
+
+GByteArray*
+peks_trap_serialize( peks_trap_t* trap )
+{
+ GByteArray* b;
+
+ b = g_byte_array_new();
+ serialize_element(b, trap->T);
+
+ return b;
+}
+
+peks_trap_t*
+peks_trap_unserialize( bswabe_pub_t* pub, GByteArray* b, int free )
+{
+ peks_trap_t* trap;
+ int offset;
+
+ trap = (peks_trap_t*) malloc(sizeof(peks_trap_t));
+ offset = 0;
+
+ element_init_G1(trap->T, pub->p);
+
+ unserialize_element(b, &offset, trap->T);
+
+ if( free )
+ g_byte_array_free(b, 1);
+
+ return trap;
+}
+
+void
+bswabe_pub_free( bswabe_pub_t* pub )
+{
+ element_clear(pub->g);
+ element_clear(pub->h);
+ element_clear(pub->gp);
+ element_clear(pub->g_hat_alpha);
+ pairing_clear(pub->p);
+ free(pub->pairing_desc);
+ free(pub);
+}
+
+void
+bswabe_msk_free( bswabe_msk_t* msk )
+{
+ element_clear(msk->beta);
+ element_clear(msk->g_alpha);
+ free(msk);
+}
+
+void
+bswabe_prv_free( bswabe_prv_t* prv )
+{
+ int i;
+
+ element_clear(prv->d);
+
+ for( i = 0; i < prv->comps->len; i++ )
+ {
+ bswabe_prv_comp_t c;
+
+ c = g_array_index(prv->comps, bswabe_prv_comp_t, i);
+ free(c.attr);
+ element_clear(c.d);
+ element_clear(c.dp);
+ }
+
+ g_array_free(prv->comps, 1);
+
+ free(prv);
+}
+
+void
+bswabe_policy_free( bswabe_policy_t* p )
+{
+ int i;
+
+ if( p->attr )
+ {
+ free(p->attr);
+ element_clear(p->c);
+ element_clear(p->cp);
+ }
+
+ for( i = 0; i < p->children->len; i++ )
+ bswabe_policy_free(g_ptr_array_index(p->children, i));
+
+ g_ptr_array_free(p->children, 1);
+
+ free(p);
+}
+
+void
+bswabe_cph_free( bswabe_cph_t* cph )
+{
+ element_clear(cph->cs);
+ element_clear(cph->c);
+ bswabe_policy_free(cph->p);
+}