diff options
Diffstat (limited to 'src/util/crypto_abe.c')
-rw-r--r-- | src/util/crypto_abe.c | 362 |
1 files changed, 201 insertions, 161 deletions
diff --git a/src/util/crypto_abe.c b/src/util/crypto_abe.c index f84aaf9f9..25d04fba6 100644 --- a/src/util/crypto_abe.c +++ b/src/util/crypto_abe.c | |||
@@ -27,133 +27,139 @@ | |||
27 | 27 | ||
28 | 28 | ||
29 | #include "platform.h" | 29 | #include "platform.h" |
30 | #include <glib.h> | ||
31 | #include <openssl/aes.h> | ||
32 | #include <openssl/sha.h> | ||
33 | #include <pbc/pbc.h> | 30 | #include <pbc/pbc.h> |
34 | #include <bswabe.h> | 31 | #include <gabe.h> |
35 | 32 | ||
36 | #include "gnunet_crypto_lib.h" | 33 | #include "gnunet_crypto_lib.h" |
37 | 34 | ||
38 | struct GNUNET_CRYPTO_AbeMasterKey | 35 | struct GNUNET_CRYPTO_AbeMasterKey |
39 | { | 36 | { |
40 | GByteArray* pub; | 37 | gabe_pub_t* pub; |
41 | 38 | gabe_msk_t* msk; | |
42 | GByteArray* msk; | ||
43 | }; | 39 | }; |
44 | 40 | ||
45 | struct GNUNET_CRYPTO_AbeKey | 41 | struct GNUNET_CRYPTO_AbeKey |
46 | { | 42 | { |
47 | GByteArray* pub; | 43 | gabe_pub_t* pub; |
48 | GByteArray* prv; | 44 | gabe_prv_t* prv; |
49 | }; | 45 | }; |
50 | 46 | ||
51 | static void | 47 | static int |
52 | init_aes( element_t k, int enc, AES_KEY* key, unsigned char* iv ) | 48 | init_aes( element_t k, int enc, |
49 | gcry_cipher_hd_t* handle, | ||
50 | struct GNUNET_CRYPTO_SymmetricSessionKey *key, | ||
51 | unsigned char* iv) | ||
53 | { | 52 | { |
53 | int rc; | ||
54 | int key_len; | 54 | int key_len; |
55 | unsigned char* key_buf; | 55 | unsigned char* key_buf; |
56 | 56 | ||
57 | key_len = element_length_in_bytes(k) < 17 ? 17 : element_length_in_bytes(k); | 57 | key_len = element_length_in_bytes(k) < 33 ? 3 : element_length_in_bytes(k); |
58 | key_buf = (unsigned char*) malloc(key_len); | 58 | key_buf = (unsigned char*) malloc(key_len); |
59 | element_to_bytes(key_buf, k); | 59 | element_to_bytes(key_buf, k); |
60 | 60 | ||
61 | if( enc ) | 61 | memcpy (key->aes_key, key_buf, GNUNET_CRYPTO_AES_KEY_LENGTH); |
62 | AES_set_encrypt_key(key_buf + 1, 128, key); | 62 | GNUNET_assert (0 == |
63 | else | 63 | gcry_cipher_open (handle, GCRY_CIPHER_AES256, |
64 | AES_set_decrypt_key(key_buf + 1, 128, key); | 64 | GCRY_CIPHER_MODE_CFB, 0)); |
65 | free(key_buf); | 65 | rc = gcry_cipher_setkey (*handle, |
66 | key->aes_key, | ||
67 | sizeof (key->aes_key)); | ||
68 | GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY)); | ||
69 | memset (iv, 0, 16); //TODO make reasonable | ||
70 | rc = gcry_cipher_setiv (*handle, | ||
71 | iv, | ||
72 | 16); | ||
73 | GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY)); | ||
66 | 74 | ||
67 | memset(iv, 0, 16); | 75 | free(key_buf); |
76 | return rc; | ||
68 | } | 77 | } |
69 | 78 | ||
70 | static GByteArray* | 79 | static int |
71 | aes_128_cbc_encrypt( GByteArray* pt, element_t k ) | 80 | aes_128_cbc_encrypt( char* pt, |
81 | int size, | ||
82 | element_t k, | ||
83 | char **ct ) | ||
72 | { | 84 | { |
73 | AES_KEY key; | 85 | gcry_cipher_hd_t handle; |
86 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; | ||
74 | unsigned char iv[16]; | 87 | unsigned char iv[16]; |
75 | GByteArray* ct; | 88 | char* buf; |
76 | guint8 len[4]; | 89 | int padding; |
77 | guint8 zero; | 90 | int buf_size; |
78 | 91 | uint8_t len[4]; | |
79 | init_aes(k, 1, &key, iv); | 92 | init_aes(k, 1, &handle, &skey, iv); |
80 | 93 | ||
81 | /* TODO make less crufty */ | 94 | /* TODO make less crufty */ |
82 | 95 | ||
83 | /* stuff in real length (big endian) before padding */ | 96 | /* stuff in real length (big endian) before padding */ |
84 | len[0] = (pt->len & 0xff000000)>>24; | 97 | len[0] = (size & 0xff000000)>>24; |
85 | len[1] = (pt->len & 0xff0000)>>16; | 98 | len[1] = (size & 0xff0000)>>16; |
86 | len[2] = (pt->len & 0xff00)>>8; | 99 | len[2] = (size & 0xff00)>>8; |
87 | len[3] = (pt->len & 0xff)>>0; | 100 | len[3] = (size & 0xff)>>0; |
88 | g_byte_array_prepend(pt, len, 4); | 101 | padding = 16 - ((4+size) % 16); |
89 | 102 | buf_size = 4 + size + padding; | |
90 | /* pad out to multiple of 128 bit (16 byte) blocks */ | 103 | buf = GNUNET_malloc (buf_size); |
91 | zero = 0; | 104 | GNUNET_memcpy (buf, len, 4); |
92 | while( pt->len % 16 ) | 105 | GNUNET_memcpy (buf+4, pt, size); |
93 | g_byte_array_append(pt, &zero, 1); | 106 | *ct = GNUNET_malloc (buf_size); |
94 | 107 | ||
95 | ct = g_byte_array_new(); | 108 | GNUNET_assert (0 == gcry_cipher_encrypt (handle, *ct, buf_size, buf, buf_size)); |
96 | g_byte_array_set_size(ct, pt->len); | 109 | gcry_cipher_close (handle); |
97 | 110 | //AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT); | |
98 | AES_cbc_encrypt(pt->data, ct->data, pt->len, &key, iv, AES_ENCRYPT); | 111 | |
99 | 112 | return buf_size; | |
100 | return ct; | ||
101 | } | 113 | } |
102 | 114 | ||
103 | static GByteArray* | 115 | static int |
104 | aes_128_cbc_decrypt( GByteArray* ct, element_t k ) | 116 | aes_128_cbc_decrypt( char* ct, |
117 | int size, | ||
118 | element_t k, | ||
119 | char **pt ) | ||
105 | { | 120 | { |
106 | AES_KEY key; | 121 | struct GNUNET_CRYPTO_SymmetricSessionKey skey; |
122 | gcry_cipher_hd_t handle; | ||
107 | unsigned char iv[16]; | 123 | unsigned char iv[16]; |
108 | GByteArray* pt; | 124 | char* tmp; |
109 | unsigned int len; | 125 | uint32_t len; |
110 | 126 | ||
111 | init_aes(k, 0, &key, iv); | 127 | init_aes(k, 1, &handle, &skey, iv); |
112 | |||
113 | pt = g_byte_array_new(); | ||
114 | g_byte_array_set_size(pt, ct->len); | ||
115 | 128 | ||
116 | AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT); | 129 | tmp = GNUNET_malloc (size); |
117 | 130 | ||
131 | //AES_cbc_encrypt(ct->data, pt->data, ct->len, &key, iv, AES_DECRYPT); | ||
132 | GNUNET_assert (0 == gcry_cipher_decrypt (handle, tmp, size, ct, size)); | ||
133 | gcry_cipher_close (handle); | ||
118 | /* TODO make less crufty */ | 134 | /* TODO make less crufty */ |
119 | 135 | ||
120 | /* get real length */ | 136 | /* get real length */ |
121 | len = 0; | 137 | len = 0; |
122 | len = len | 138 | len = len |
123 | | ((pt->data[0])<<24) | ((pt->data[1])<<16) | 139 | | ((tmp[0])<<24) | ((tmp[1])<<16) |
124 | | ((pt->data[2])<<8) | ((pt->data[3])<<0); | 140 | | ((tmp[2])<<8) | ((tmp[3])<<0); |
125 | g_byte_array_remove_index(pt, 0); | ||
126 | g_byte_array_remove_index(pt, 0); | ||
127 | g_byte_array_remove_index(pt, 0); | ||
128 | g_byte_array_remove_index(pt, 0); | ||
129 | |||
130 | /* truncate any garbage from the padding */ | 141 | /* truncate any garbage from the padding */ |
131 | g_byte_array_set_size(pt, len); | 142 | *pt = GNUNET_malloc (len); |
132 | 143 | GNUNET_memcpy (*pt, tmp+4, len); | |
133 | return pt; | 144 | GNUNET_free (tmp); |
145 | return len; | ||
134 | } | 146 | } |
135 | 147 | ||
136 | struct GNUNET_CRYPTO_AbeMasterKey* | 148 | struct GNUNET_CRYPTO_AbeMasterKey* |
137 | GNUNET_CRYPTO_cpabe_create_master_key (void) | 149 | GNUNET_CRYPTO_cpabe_create_master_key (void) |
138 | { | 150 | { |
139 | struct GNUNET_CRYPTO_AbeMasterKey* key; | 151 | struct GNUNET_CRYPTO_AbeMasterKey* key; |
140 | bswabe_msk_t* msk; | ||
141 | bswabe_pub_t* pub; | ||
142 | bswabe_setup(&pub, &msk); | ||
143 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey); | 152 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey); |
144 | key->pub = bswabe_pub_serialize(pub); | 153 | gabe_setup(&key->pub, &key->msk); |
145 | key->msk = bswabe_msk_serialize(msk); | ||
146 | GNUNET_assert (NULL != key->pub); | 154 | GNUNET_assert (NULL != key->pub); |
147 | GNUNET_assert (NULL != key->msk); | 155 | GNUNET_assert (NULL != key->msk); |
148 | bswabe_msk_free (msk); | ||
149 | return key; | 156 | return key; |
150 | } | 157 | } |
151 | 158 | ||
152 | void | 159 | void |
153 | GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key) | 160 | GNUNET_CRYPTO_cpabe_delete_master_key (struct GNUNET_CRYPTO_AbeMasterKey *key) |
154 | { | 161 | { |
155 | g_byte_array_unref (key->msk); | 162 | gabe_msk_free (key->msk); //For some reason free of pub implicit? |
156 | g_byte_array_unref (key->pub); | ||
157 | GNUNET_free (key); | 163 | GNUNET_free (key); |
158 | } | 164 | } |
159 | 165 | ||
@@ -162,80 +168,80 @@ GNUNET_CRYPTO_cpabe_create_key (struct GNUNET_CRYPTO_AbeMasterKey *key, | |||
162 | char **attrs) | 168 | char **attrs) |
163 | { | 169 | { |
164 | struct GNUNET_CRYPTO_AbeKey *prv_key; | 170 | struct GNUNET_CRYPTO_AbeKey *prv_key; |
165 | bswabe_pub_t* pub; | ||
166 | bswabe_msk_t* msk; | ||
167 | bswabe_prv_t* prv; | ||
168 | |||
169 | pub = bswabe_pub_unserialize(key->pub, 0); | ||
170 | msk = bswabe_msk_unserialize(pub, key->msk, 0); | ||
171 | prv = bswabe_keygen(pub, msk, attrs); | ||
172 | prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); | 171 | prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); |
173 | prv_key->prv = bswabe_prv_serialize(prv); | 172 | int size; |
174 | prv_key->pub = bswabe_pub_serialize (pub); | 173 | char *tmp; |
174 | |||
175 | prv_key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); | ||
176 | prv_key->prv = gabe_keygen(key->pub, key->msk, attrs); | ||
177 | size = gabe_pub_serialize(key->pub, &tmp); | ||
178 | prv_key->pub = gabe_pub_unserialize(tmp, size); | ||
175 | GNUNET_assert (NULL != prv_key->prv); | 179 | GNUNET_assert (NULL != prv_key->prv); |
176 | //Memory management in bswabe is buggy | ||
177 | //bswabe_prv_free (prv); | ||
178 | bswabe_msk_free (msk); | ||
179 | return prv_key; | 180 | return prv_key; |
180 | } | 181 | } |
181 | 182 | ||
182 | void | 183 | void |
183 | GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key) | 184 | GNUNET_CRYPTO_cpabe_delete_key (struct GNUNET_CRYPTO_AbeKey *key) |
184 | { | 185 | { |
185 | g_byte_array_unref (key->prv); | 186 | //Memory management in gabe is buggy |
186 | g_byte_array_unref (key->pub); | 187 | //gabe_prv_free (prv); |
187 | GNUNET_free (key); | 188 | GNUNET_free (key); |
188 | } | 189 | } |
189 | 190 | ||
190 | ssize_t | 191 | ssize_t |
191 | write_cpabe (void **result, GByteArray* cph_buf, | 192 | write_cpabe (void **result, |
192 | uint32_t file_len, GByteArray* aes_buf) | 193 | uint32_t file_len, |
194 | char* cph_buf, | ||
195 | int cph_buf_len, | ||
196 | char* aes_buf, | ||
197 | int aes_buf_len) | ||
193 | { | 198 | { |
194 | char *ptr; | 199 | char *ptr; |
195 | uint32_t *len; | 200 | uint32_t *len; |
196 | 201 | ||
197 | *result = GNUNET_malloc (12 + cph_buf->len + aes_buf->len); | 202 | *result = GNUNET_malloc (12 + cph_buf_len + aes_buf_len); |
198 | ptr = *result; | 203 | ptr = *result; |
199 | len = (uint32_t*) ptr; | 204 | len = (uint32_t*) ptr; |
200 | *len = htonl (file_len); | 205 | *len = htonl (file_len); |
201 | ptr += 4; | 206 | ptr += 4; |
202 | len = (uint32_t*) ptr; | 207 | len = (uint32_t*) ptr; |
203 | *len = htonl (aes_buf->len); | 208 | *len = htonl (aes_buf_len); |
204 | ptr += 4; | 209 | ptr += 4; |
205 | memcpy (ptr, aes_buf->data, aes_buf->len); | 210 | memcpy (ptr, aes_buf, aes_buf_len); |
206 | ptr += aes_buf->len; | 211 | ptr += aes_buf_len; |
207 | len = (uint32_t*) ptr; | 212 | len = (uint32_t*) ptr; |
208 | *len = htonl (cph_buf->len); | 213 | *len = htonl (cph_buf_len); |
209 | ptr += 4; | 214 | ptr += 4; |
210 | memcpy (ptr, cph_buf->data, cph_buf->len); | 215 | memcpy (ptr, cph_buf, cph_buf_len); |
211 | return 12 + cph_buf->len + aes_buf->len; | 216 | return 12 + cph_buf_len + aes_buf_len; |
212 | } | 217 | } |
213 | 218 | ||
214 | ssize_t | 219 | ssize_t |
215 | read_cpabe (const void *data, GByteArray** cph_buf, GByteArray** aes_buf) | 220 | read_cpabe (const void *data, |
221 | char** cph_buf, | ||
222 | int *cph_buf_len, | ||
223 | char** aes_buf, | ||
224 | int *aes_buf_len) | ||
216 | { | 225 | { |
217 | int buf_len; | 226 | int buf_len; |
218 | int tmp_len; | ||
219 | char *ptr; | 227 | char *ptr; |
220 | uint32_t *len; | 228 | uint32_t *len; |
221 | 229 | ||
222 | *cph_buf = g_byte_array_new(); | ||
223 | *aes_buf = g_byte_array_new(); | ||
224 | ptr = (char*)data; | 230 | ptr = (char*)data; |
225 | len = (uint32_t*)ptr; | 231 | len = (uint32_t*)ptr; |
226 | buf_len = ntohl (*len); | 232 | buf_len = ntohl (*len); |
227 | ptr += 4; | 233 | ptr += 4; |
228 | len = (uint32_t*)ptr; | 234 | len = (uint32_t*)ptr; |
229 | tmp_len = ntohl (*len); | 235 | *aes_buf_len = ntohl (*len); |
230 | ptr += 4; | 236 | ptr += 4; |
231 | g_byte_array_set_size(*aes_buf, tmp_len); | 237 | *aes_buf = GNUNET_malloc (*aes_buf_len); |
232 | memcpy((*aes_buf)->data, ptr, tmp_len); | 238 | memcpy(*aes_buf, ptr, *aes_buf_len); |
233 | ptr += tmp_len; | 239 | ptr += *aes_buf_len; |
234 | len = (uint32_t*)ptr; | 240 | len = (uint32_t*)ptr; |
235 | tmp_len = ntohl (*len); | 241 | *cph_buf_len = ntohl (*len); |
236 | ptr += 4; | 242 | ptr += 4; |
237 | g_byte_array_set_size(*cph_buf, tmp_len); | 243 | *cph_buf = GNUNET_malloc (*cph_buf_len); |
238 | memcpy((*cph_buf)->data, ptr, tmp_len); | 244 | memcpy(*cph_buf, ptr, *cph_buf_len); |
239 | 245 | ||
240 | return buf_len; | 246 | return buf_len; |
241 | } | 247 | } |
@@ -247,69 +253,58 @@ GNUNET_CRYPTO_cpabe_encrypt (const void *block, | |||
247 | const struct GNUNET_CRYPTO_AbeMasterKey *key, | 253 | const struct GNUNET_CRYPTO_AbeMasterKey *key, |
248 | void **result) | 254 | void **result) |
249 | { | 255 | { |
250 | bswabe_pub_t* pub; | 256 | gabe_cph_t* cph; |
251 | bswabe_cph_t* cph; | 257 | char* plt; |
252 | GByteArray* plt; | 258 | char* cph_buf; |
253 | GByteArray* cph_buf; | 259 | char* aes_buf; |
254 | GByteArray* aes_buf; | ||
255 | guint8 *data; | ||
256 | element_t m; | 260 | element_t m; |
257 | size_t payload_len; | 261 | int cph_buf_len; |
262 | int aes_buf_len; | ||
258 | ssize_t result_len; | 263 | ssize_t result_len; |
259 | 264 | ||
260 | pub = bswabe_pub_unserialize(key->pub, 0); | 265 | if( !(cph = gabe_enc(key->pub, m, policy)) ) |
261 | if( !(cph = bswabe_enc(pub, m, policy)) ) | ||
262 | return GNUNET_SYSERR; | 266 | return GNUNET_SYSERR; |
263 | cph_buf = bswabe_cph_serialize(cph); | 267 | cph_buf_len = gabe_cph_serialize(cph, |
264 | bswabe_cph_free(cph); | 268 | &cph_buf); |
265 | data = g_memdup (block, size); | 269 | gabe_cph_free(cph); |
266 | plt = g_byte_array_new_take (data, size); | 270 | plt = GNUNET_memdup (block, size); |
267 | payload_len = plt->len; | 271 | aes_buf_len = aes_128_cbc_encrypt(plt, size, m, &aes_buf); |
268 | aes_buf = aes_128_cbc_encrypt(plt, m); | 272 | GNUNET_free (plt); |
269 | g_byte_array_free(plt, 1); | ||
270 | element_clear(m); | 273 | element_clear(m); |
271 | result_len = write_cpabe(result, cph_buf, payload_len, aes_buf); | 274 | result_len = write_cpabe(result, size, cph_buf, cph_buf_len, aes_buf, aes_buf_len); |
272 | g_byte_array_free(cph_buf, 1); | 275 | GNUNET_free(cph_buf); |
273 | g_byte_array_free(aes_buf, 1); | 276 | GNUNET_free(aes_buf); |
274 | bswabe_pub_free (pub); | ||
275 | return result_len; | 277 | return result_len; |
276 | } | 278 | } |
277 | 279 | ||
278 | ssize_t | 280 | ssize_t |
279 | GNUNET_CRYPTO_cpabe_decrypt (const void *block, | 281 | GNUNET_CRYPTO_cpabe_decrypt (const void *block, |
280 | size_t size, | 282 | size_t size, |
281 | const struct GNUNET_CRYPTO_AbeKey *key, | 283 | const struct GNUNET_CRYPTO_AbeKey *key, |
282 | void **result) | 284 | void **result) |
283 | { | 285 | { |
284 | bswabe_pub_t* pub; | 286 | char* aes_buf; |
285 | bswabe_prv_t* prv; | 287 | char* cph_buf; |
286 | GByteArray* aes_buf; | 288 | gabe_cph_t* cph; |
287 | GByteArray* plt; | ||
288 | GByteArray* cph_buf; | ||
289 | bswabe_cph_t* cph; | ||
290 | element_t m; | 289 | element_t m; |
291 | ssize_t pt_size; | 290 | int cph_buf_size; |
291 | int aes_buf_size; | ||
292 | int plt_len; | ||
292 | 293 | ||
293 | pub = bswabe_pub_unserialize(key->pub, 0); | 294 | read_cpabe(block, &cph_buf, &cph_buf_size, &aes_buf, &aes_buf_size); |
294 | prv = bswabe_prv_unserialize(pub, key->prv, 0); | 295 | cph = gabe_cph_unserialize(key->pub, cph_buf, cph_buf_size); |
295 | pt_size = read_cpabe(block, &cph_buf, &aes_buf); | 296 | if( !gabe_dec(key->pub, key->prv, cph, m) ) { |
296 | cph = bswabe_cph_unserialize(pub, cph_buf, 0); | ||
297 | if( !bswabe_dec(pub, prv, cph, m) ) { | ||
298 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 297 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
299 | "%s\n", bswabe_error()); | 298 | "%s\n", gabe_error()); |
300 | bswabe_cph_free(cph); | 299 | gabe_cph_free(cph); |
301 | return GNUNET_SYSERR; | 300 | return GNUNET_SYSERR; |
302 | } | 301 | } |
303 | bswabe_cph_free(cph); | 302 | gabe_cph_free(cph); |
304 | plt = aes_128_cbc_decrypt(aes_buf, m); | 303 | plt_len = aes_128_cbc_decrypt(aes_buf, aes_buf_size, m, (char**)result); |
305 | g_byte_array_set_size(plt, size); | 304 | //freeing is buggy in gabe |
306 | g_byte_array_free(aes_buf, 1); | 305 | //gabe_prv_free (prv); |
307 | *result = GNUNET_malloc (plt->len); | 306 | //gabe_pub_free (pub); |
308 | GNUNET_memcpy (*result, plt->data, plt->len); | 307 | return plt_len; |
309 | //freeing is buggy in bswabe | ||
310 | //bswabe_prv_free (prv); | ||
311 | bswabe_pub_free (pub); | ||
312 | return pt_size; | ||
313 | } | 308 | } |
314 | 309 | ||
315 | ssize_t | 310 | ssize_t |
@@ -317,9 +312,19 @@ GNUNET_CRYPTO_cpabe_serialize_key (const struct GNUNET_CRYPTO_AbeKey *key, | |||
317 | void **result) | 312 | void **result) |
318 | { | 313 | { |
319 | ssize_t len; | 314 | ssize_t len; |
315 | char *pub; | ||
316 | char *prv; | ||
317 | int pub_len; | ||
318 | int prv_len; | ||
320 | 319 | ||
321 | len = key->pub->len + key->prv->len + 12; | 320 | pub_len = gabe_pub_serialize (key->pub, &pub); |
322 | write_cpabe (result, key->pub, len, key->prv); | 321 | prv_len = gabe_prv_serialize (key->prv, &prv); |
322 | |||
323 | len = pub_len + prv_len + 12; | ||
324 | write_cpabe (result, len, pub, pub_len, prv, prv_len); | ||
325 | |||
326 | GNUNET_free (pub); | ||
327 | GNUNET_free (prv); | ||
323 | 328 | ||
324 | return len; | 329 | return len; |
325 | } | 330 | } |
@@ -329,10 +334,22 @@ GNUNET_CRYPTO_cpabe_deserialize_key (const void *data, | |||
329 | size_t len) | 334 | size_t len) |
330 | { | 335 | { |
331 | struct GNUNET_CRYPTO_AbeKey *key; | 336 | struct GNUNET_CRYPTO_AbeKey *key; |
337 | char *pub; | ||
338 | char *prv; | ||
339 | int prv_len; | ||
340 | int pub_len; | ||
332 | 341 | ||
333 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); | 342 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeKey); |
334 | read_cpabe (data, &key->pub, &key->prv); | 343 | read_cpabe (data, |
335 | 344 | &pub, | |
345 | &pub_len, | ||
346 | &prv, | ||
347 | &prv_len); | ||
348 | key->pub = gabe_pub_unserialize (pub, pub_len); | ||
349 | key->prv = gabe_prv_unserialize (key->pub, prv, prv_len); | ||
350 | |||
351 | GNUNET_free (pub); | ||
352 | GNUNET_free (prv); | ||
336 | return key; | 353 | return key; |
337 | } | 354 | } |
338 | 355 | ||
@@ -341,9 +358,19 @@ GNUNET_CRYPTO_cpabe_serialize_master_key (const struct GNUNET_CRYPTO_AbeMasterKe | |||
341 | void **result) | 358 | void **result) |
342 | { | 359 | { |
343 | ssize_t len; | 360 | ssize_t len; |
361 | char *pub; | ||
362 | char *msk; | ||
363 | int pub_len; | ||
364 | int msk_len; | ||
344 | 365 | ||
345 | len = key->pub->len + key->msk->len + 12; | 366 | pub_len = gabe_pub_serialize (key->pub, &pub); |
346 | write_cpabe (result, key->pub, len, key->msk); | 367 | msk_len = gabe_msk_serialize (key->msk, &msk); |
368 | |||
369 | len = pub_len + msk_len + 12; | ||
370 | write_cpabe (result, len, pub, pub_len, msk, msk_len); | ||
371 | |||
372 | GNUNET_free (pub); | ||
373 | GNUNET_free (msk); | ||
347 | 374 | ||
348 | return len; | 375 | return len; |
349 | } | 376 | } |
@@ -353,9 +380,22 @@ GNUNET_CRYPTO_cpabe_deserialize_master_key (const void *data, | |||
353 | size_t len) | 380 | size_t len) |
354 | { | 381 | { |
355 | struct GNUNET_CRYPTO_AbeMasterKey *key; | 382 | struct GNUNET_CRYPTO_AbeMasterKey *key; |
383 | char *msk; | ||
384 | char *pub; | ||
385 | int msk_len; | ||
386 | int pub_len; | ||
356 | 387 | ||
357 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey); | 388 | key = GNUNET_new (struct GNUNET_CRYPTO_AbeMasterKey); |
358 | read_cpabe (data, &key->pub, &key->msk); | 389 | read_cpabe (data, |
390 | &pub, | ||
391 | &pub_len, | ||
392 | &msk, | ||
393 | &msk_len); | ||
394 | key->pub = gabe_pub_unserialize (pub, pub_len); | ||
395 | key->msk = gabe_msk_unserialize (key->pub, msk, msk_len); | ||
396 | |||
397 | GNUNET_free (pub); | ||
398 | GNUNET_free (msk); | ||
359 | 399 | ||
360 | return key; | 400 | return key; |
361 | } | 401 | } |