![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bliss_signature.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins / bliss|
Return to bliss_signature.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins / bliss |
1.1 misho 1: /*
2: * Copyright (C) 2014 Andreas Steffen
3: * HSR Hochschule fuer Technik Rapperswil
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #include "bliss_signature.h"
17: #include "bliss_bitpacker.h"
18: #include "bliss_huffman_coder.h"
19:
20:
21: typedef struct private_bliss_signature_t private_bliss_signature_t;
22:
23: /**
24: * Private data of a bliss_signature_t object.
25: */
26: struct private_bliss_signature_t {
27: /**
28: * Public interface for this signer.
29: */
30: bliss_signature_t public;
31:
32: /**
33: * BLISS signature parameter set
34: */
35: const bliss_param_set_t *set;
36:
37: /**
38: * BLISS signature vector z1 of size n
39: */
40: int32_t *z1;
41:
42: /**
43: * BLISS signature vector z2d of size n
44: */
45: int16_t *z2d;
46:
47: /**
48: * Indices of sparse BLISS challenge vector c of size kappa
49: */
50: uint16_t *c_indices;
51:
52: };
53:
54: METHOD(bliss_signature_t, get_encoding, chunk_t,
55: private_bliss_signature_t *this)
56: {
57: bliss_bitpacker_t *packer;
58: bliss_huffman_coder_t *coder;
59: bliss_huffman_code_t *code;
60: int32_t z1;
61: uint32_t z1_sign;
62: uint16_t z2d_bits;
63: chunk_t encoding = chunk_empty;
64: int i;
65:
66: z2d_bits = this->set->z1_bits - this->set->d;
67:
68: /* Get Huffman code for this BLISS parameter set */
69: code = bliss_huffman_code_get_by_id(this->set->id);
70: if (!code)
71: {
72: DBG1(DBG_LIB, "no Huffman code found for parameter set %N",
73: bliss_param_set_id_names, this->set->id);
74: return chunk_empty;
75: }
76:
77: packer = bliss_bitpacker_create(this->set->n * this->set->z1_bits +
78: this->set->n * z2d_bits +
79: this->set->kappa * this->set->n_bits);
80: coder = bliss_huffman_coder_create(code, packer);
81:
82: for (i = 0; i < this->set->n; i++)
83: {
84: /* determine and remove the sign of z1[i]*/
85: z1_sign = this->z1[i] < 0;
86: z1 = z1_sign ? -this->z1[i] : this->z1[i];
87:
88: if (!packer->write_bits(packer, z1_sign, 1) ||
89: !packer->write_bits(packer, z1 & 0xff, 8) ||
90: !coder->encode(coder, z1 >> 8, this->z2d[i]))
91: {
92: goto end;
93: }
94: }
95: for (i = 0; i < this->set->kappa; i++)
96: {
97: if (!packer->write_bits(packer, this->c_indices[i], this->set->n_bits))
98: {
99: goto end;
100: }
101: }
102: encoding = packer->extract_buf(packer);
103:
104: DBG2(DBG_LIB, "efficiency of Huffman coder is %6.4f bits/tuple (%u bits)",
105: coder->get_bits(coder)/(double)(this->set->n),
106: coder->get_bits(coder));
107: DBG2(DBG_LIB, "generated BLISS signature (%u bits encoded in %u bytes)",
108: packer->get_bits(packer), encoding.len);
109:
110: end:
111: coder->destroy(coder);
112: packer->destroy(packer);
113: return encoding;
114: }
115:
116: METHOD(bliss_signature_t, get_parameters, void,
117: private_bliss_signature_t *this, int32_t **z1, int16_t **z2d,
118: uint16_t **c_indices)
119: {
120: *z1 = this->z1;
121: *z2d = this->z2d;
122: *c_indices = this->c_indices;
123: }
124:
125: METHOD(bliss_signature_t, destroy, void,
126: private_bliss_signature_t *this)
127: {
128: free(this->z1);
129: free(this->z2d);
130: free(this->c_indices);
131: free(this);
132: }
133:
134: /**
135: * See header.
136: */
137: bliss_signature_t *bliss_signature_create(const bliss_param_set_t *set)
138: {
139: private_bliss_signature_t *this;
140:
141: INIT(this,
142: .public = {
143: .get_encoding = _get_encoding,
144: .get_parameters = _get_parameters,
145: .destroy = _destroy,
146: },
147: .set = set,
148: .z1 = malloc(set->n * sizeof(int32_t)),
149: .z2d = malloc(set->n * sizeof(int16_t)),
150: .c_indices = malloc(set->n * sizeof(uint16_t)),
151: );
152:
153: return &this->public;
154: }
155:
156: /**
157: * See header.
158: */
159: bliss_signature_t *bliss_signature_create_from_data(const bliss_param_set_t *set,
160: chunk_t encoding)
161: {
162: private_bliss_signature_t *this;
163: bliss_bitpacker_t *packer;
164: bliss_huffman_coder_t *coder;
165: bliss_huffman_code_t *code;
166: uint32_t z1_sign, z1_low, value;
167: int32_t z1;
168: int16_t z2;
169: int i;
170:
171: /* Get Huffman code for this BLISS parameter set */
172: code = bliss_huffman_code_get_by_id(set->id);
173: if (!code)
174: {
175: DBG1(DBG_LIB, "no Huffman code found for parameter set %N",
176: bliss_param_set_id_names, set->id);
177: return NULL;
178: }
179:
180: if (encoding.len == 0)
181: {
182: DBG1(DBG_LIB, "zero length BLISS signature");
183: return NULL;
184: }
185:
186: INIT(this,
187: .public = {
188: .get_encoding = _get_encoding,
189: .get_parameters = _get_parameters,
190: .destroy = _destroy,
191: },
192: .set = set,
193: .z1 = malloc(set->n * sizeof(int32_t)),
194: .z2d = malloc(set->n * sizeof(int16_t)),
195: .c_indices = malloc(set->n * sizeof(uint16_t)),
196: );
197:
198: packer = bliss_bitpacker_create_from_data(encoding);
199: coder = bliss_huffman_coder_create(code, packer);
200:
201: for (i = 0; i < set->n; i++)
202: {
203: if (!packer->read_bits(packer, &z1_sign, 1) ||
204: !packer->read_bits(packer, &z1_low, 8) ||
205: !coder->decode(coder, &z1, &z2))
206: {
207: DBG1(DBG_LIB, "truncated BLISS signature encoding of z1/z2");
208: coder->destroy(coder);
209: packer->destroy(packer);
210: destroy(this);
211: return NULL;
212: }
213: z1 = (z1 << 8) + z1_low;
214: this->z1[i] = z1_sign ? -z1 : z1;
215: this->z2d[i] = z2;
216: }
217: coder->destroy(coder);
218:
219: for (i = 0; i < set->kappa; i++)
220: {
221: if (!packer->read_bits(packer, &value, set->n_bits))
222: {
223: DBG1(DBG_LIB, "truncated BLISS signature encoding of c_indices");
224: packer->destroy(packer);
225: destroy(this);
226: return NULL;
227: }
228: this->c_indices[i] = value;
229: }
230: packer->destroy(packer);
231:
232: return &this->public;
233: }