660b443c |
1 | # ---?--- |
2 | # |
fcd15e0b |
3 | # $Id$ |
660b443c |
4 | # |
5 | # Miscellaneous function interfaces |
6 | # |
7 | # (c) 2001 Straylight/Edgeware |
8 | # |
9 | |
10 | #----- Licensing notice ----------------------------------------------------- |
11 | # |
12 | # This file is part of the Perl interface to Catacomb. |
13 | # |
14 | # Catacomb/Perl is free software; you can redistribute it and/or modify |
15 | # it under the terms of the GNU General Public License as published by |
16 | # the Free Software Foundation; either version 2 of the License, or |
17 | # (at your option) any later version. |
18 | # |
19 | # Catacomb/Perl is distributed in the hope that it will be useful, |
20 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
21 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
22 | # GNU General Public License for more details. |
23 | # |
24 | # You should have received a copy of the GNU General Public License |
25 | # along with Catacomb/Perl; if not, write to the Free Software Foundation, |
26 | # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
27 | |
fcd15e0b |
28 | MODULE = Catacomb PACKAGE = Catacomb::Share::GF PREFIX = gfshare_ |
29 | |
30 | Share_GF * |
31 | new(me, t, sz) |
32 | SV *me |
33 | UV t |
34 | UV sz |
35 | CODE: |
36 | RETVAL = CREATE(Share_GF); |
37 | if (t < 1 || t > 255) |
38 | croak("share threshhold out of range"); |
39 | gfshare_create(RETVAL, t, sz); |
40 | OUTPUT: |
41 | RETVAL |
42 | |
43 | UV |
44 | sz(s) |
45 | Share_GF *s |
46 | CODE: |
47 | RETVAL = s->sz; |
48 | OUTPUT: |
49 | RETVAL |
50 | |
51 | UV |
52 | t(s) |
53 | Share_GF *s |
54 | CODE: |
55 | RETVAL = s->t; |
56 | OUTPUT: |
57 | RETVAL |
58 | |
59 | UV |
60 | i(s) |
61 | Share_GF *s |
62 | CODE: |
63 | RETVAL = s->i; |
64 | OUTPUT: |
65 | RETVAL |
66 | |
67 | SV * |
68 | DESTROY(s) |
69 | Share_GF *s |
70 | CODE: |
71 | gfshare_destroy(s); |
72 | DESTROY(s); |
73 | XSRETURN_YES; |
74 | |
75 | SV * |
76 | mkshares(s, x, r = &rand_global) |
77 | Share_GF *s |
78 | SV *x |
79 | grand *r |
80 | PREINIT: |
81 | char *p; |
82 | STRLEN len; |
83 | CODE: |
84 | p = SvPV(x, len); |
85 | if (len != s->sz) |
86 | croak("secret length mismatch"); |
87 | gfshare_mkshares(s, r, p); |
88 | s->i = ~0u; |
89 | XSRETURN_YES; |
90 | |
91 | SV * |
92 | get(s, i) |
93 | Share_GF *s |
94 | UV i |
95 | CODE: |
96 | if (i >= 255) |
97 | croak("share index out of range"); |
98 | if (s->i != ~0u) |
99 | croak("not making shares"); |
100 | RETVAL = NEWSV(0, s->sz); |
101 | SvPOK_on(RETVAL); |
102 | gfshare_get(s, i, SvPVX(RETVAL)); |
103 | SvCUR_set(RETVAL, s->sz); |
104 | OUTPUT: |
105 | RETVAL |
106 | |
107 | unsigned |
108 | add(s, i, x) |
109 | Share_GF *s |
110 | UV i |
111 | SV *x |
112 | PREINIT: |
113 | char *p; |
114 | STRLEN len; |
115 | CODE: |
116 | p = SvPV(x, len); |
117 | if (len != s->sz) |
118 | croak("secret length mismatch"); |
119 | if (i == ~0u) |
120 | croak("making shares"); |
121 | if (i >= 255) |
122 | croak("share index out of range"); |
123 | if (s->i >= s->t) |
124 | croak("too many shares"); |
125 | RETVAL = gfshare_add(s, i, p); |
126 | OUTPUT: |
127 | RETVAL |
128 | |
129 | SV * |
130 | combine(s) |
131 | Share_GF *s |
132 | CODE: |
133 | if (s->i == ~0u) |
134 | croak("making shares"); |
135 | if (s->i != s->t) |
136 | croak("not enough shares yet"); |
137 | RETVAL = NEWSV(0, s->sz); |
138 | SvPOK_on(RETVAL); |
139 | gfshare_combine(s, SvPVX(RETVAL)); |
140 | SvCUR_set(RETVAL, s->sz); |
141 | OUTPUT: |
142 | RETVAL |
143 | |
144 | MODULE = Catacomb PACKAGE = Catacomb::Share::Prime PREFIX = share_ |
145 | |
146 | Share_Prime * |
147 | new(me, t, p = &PL_sv_undef) |
148 | SV *me |
149 | UV t |
150 | SV *p |
151 | CODE: |
152 | RETVAL = CREATE(Share_Prime); |
153 | if (t < 1 || t > MPW_MAX) |
154 | croak("share threshhold out of range"); |
155 | share_create(RETVAL, t); |
156 | if (SvOK(p)) |
157 | RETVAL->p = mp_fromsv(p, "p", 0, 1); |
158 | OUTPUT: |
159 | RETVAL |
160 | |
161 | mp * |
162 | p(s) |
163 | Share_Prime *s |
164 | CODE: |
165 | if (!s->p) |
166 | XSRETURN_UNDEF; |
167 | RETVAL = MP_COPY(s->p); |
168 | OUTPUT: |
169 | RETVAL |
170 | |
171 | UV |
172 | t(s) |
173 | Share_Prime *s |
174 | CODE: |
175 | RETVAL = s->t; |
176 | OUTPUT: |
177 | RETVAL |
178 | |
179 | UV |
180 | i(s) |
181 | Share_Prime *s |
182 | CODE: |
183 | RETVAL = s->i; |
184 | OUTPUT: |
185 | RETVAL |
186 | |
187 | SV * |
188 | DESTROY(s) |
189 | Share_Prime *s |
190 | CODE: |
191 | share_destroy(s); |
192 | DESTROY(s); |
193 | XSRETURN_YES; |
194 | |
195 | SV * |
196 | mkshares(s, x, r = &rand_global) |
197 | Share_Prime *s |
198 | mp *x |
199 | grand *r |
200 | CODE: |
201 | if (s->p && MP_CMP(s->p, <=, x)) |
202 | croak("secret out of range"); |
203 | share_mkshares(s, r, x); |
204 | s->i = ~0u; |
205 | XSRETURN_YES; |
206 | |
207 | mp * |
208 | share_get(s, i) |
209 | Share_Prime *s |
210 | UV i |
211 | INIT: |
212 | if (i >= MPW_MAX) |
213 | croak("share index out of range"); |
214 | if (s->i != ~0u) |
215 | croak("not making shares"); |
216 | C_ARGS: |
217 | s, MP_NEW, i |
218 | |
219 | unsigned |
220 | share_add(s, i, x) |
221 | Share_Prime *s |
222 | UV i |
223 | mp *x |
224 | INIT: |
225 | if (!s->p) |
226 | croak("no prime set"); |
227 | if (i == ~0u) |
228 | croak("making shares"); |
229 | if (i >= MPW_MAX) |
230 | croak("share index out of range"); |
231 | if (s->i >= s->t) |
232 | croak("too many shares"); |
233 | C_ARGS: |
234 | s, i, x |
235 | |
236 | mp * |
237 | share_combine(s) |
238 | Share_Prime *s |
239 | INIT: |
240 | if (s->i == ~0u) |
241 | croak("making shares"); |
242 | if (s->i != s->t) |
243 | croak("not enough shares yet"); |
244 | |
660b443c |
245 | MODULE = Catacomb PACKAGE = Catacomb::Passphrase |
246 | |
247 | SV * |
248 | read(me, tag, len = 256) |
249 | SV *me |
250 | char *tag |
251 | int len |
252 | CODE: |
253 | RETVAL = NEWSV(0, len); |
254 | if (passphrase_read(tag, PMODE_READ, SvPVX(RETVAL), len + 1)) |
255 | XSRETURN_UNDEF; |
256 | SvCUR_set(RETVAL, strlen(SvPVX(RETVAL))); |
257 | SvPOK_on(RETVAL); |
258 | OUTPUT: |
259 | RETVAL |
260 | |
261 | SV * |
262 | verify(me, tag, len = 256) |
263 | SV *me |
264 | char *tag |
265 | int len |
266 | CODE: |
267 | RETVAL = NEWSV(0, len); |
268 | if (passphrase_read(tag, PMODE_VERIFY, SvPVX(RETVAL), len + 1)) |
269 | XSRETURN_UNDEF; |
270 | SvCUR_set(RETVAL, strlen(SvPVX(RETVAL))); |
271 | SvPOK_on(RETVAL); |
272 | OUTPUT: |
273 | RETVAL |
274 | |
275 | SV * |
276 | cancel(me, tag) |
277 | SV *me |
278 | char *tag |
279 | CODE: |
280 | passphrase_cancel(tag); |
fcd15e0b |
281 | XSRETURN_YES; |
660b443c |
282 | |
283 | MODULE = Catacomb PACKAGE = Catacomb::KeySize |
284 | |
285 | int |
286 | keysz(ksz, sz) |
287 | keysize *ksz |
288 | int sz |
289 | CODE: |
290 | RETVAL = keysz(sz, ksz); |
291 | OUTPUT: |
292 | RETVAL |
293 | |
fcd15e0b |
294 | void |
295 | expand(ksz) |
296 | keysize *ksz |
297 | PREINIT: |
298 | int i; |
299 | PPCODE: |
300 | switch (ksz[0]) { |
301 | case KSZ_ANY: |
302 | XPUSHs(sv_2mortal(newSVpv("ANY", 0))); |
303 | XPUSHs(sv_2mortal(newSViv(ksz[1]))); |
304 | break; |
305 | case KSZ_RANGE: |
306 | XPUSHs(sv_2mortal(newSVpv("RANGE", 0))); |
307 | for (i = 1; i < 5; i++) |
308 | XPUSHs(sv_2mortal(newSViv(ksz[i]))); |
309 | break; |
310 | case KSZ_SET: |
311 | XPUSHs(sv_2mortal(newSVpv("SET", 0))); |
312 | for (i = 1; ksz[i]; i++) |
313 | XPUSHs(sv_2mortal(newSViv(ksz[i]))); |
314 | break; |
315 | default: |
316 | abort(); |
317 | } |
318 | |
660b443c |
319 | #----- That's all, folks ---------------------------------------------------- |