fcd15e0b |
1 | # ---?--- |
2 | # |
3 | # $Id$ |
4 | # |
5 | # Key-management interface |
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 | |
28 | MODULE = Catacomb PACKAGE = Catacomb::PubKey |
29 | |
30 | void |
31 | gen_dh(me, ql, pl, steps = 0, r = &rand_global, events = &PL_sv_undef) |
32 | SV *me |
33 | unsigned ql |
34 | unsigned pl |
35 | unsigned steps |
36 | grand *r |
37 | MP_Prime_Gen_NullProc *events |
38 | PREINIT: |
39 | dh_param dp; |
40 | pgen_proc *evproc; |
41 | void *evctx; |
42 | PPCODE: |
43 | pgproc_get(events, &evproc, &evctx); |
44 | if (dh_gen(&dp, ql, pl, steps, r, evproc, evctx)) |
45 | XSRETURN_EMPTY; |
46 | XPUSHs(RET_MP(dp.p)); |
47 | XPUSHs(RET_MP(dp.g)); |
48 | XPUSHs(RET_MP(dp.q)); |
49 | |
50 | void |
51 | gen_limlee(me, ql, pl, flags = 0, steps = 0, r = &rand_global, oevents = &PL_sv_undef, ievents = &PL_sv_undef) |
52 | SV *me |
53 | unsigned ql |
54 | unsigned pl |
55 | unsigned flags |
56 | unsigned steps |
57 | grand *r |
58 | MP_Prime_Gen_NullProc *oevents |
59 | MP_Prime_Gen_NullProc *ievents |
60 | PREINIT: |
61 | dh_param dp; |
62 | pgen_proc *oev, *iev; |
63 | void *oec, *iec; |
64 | size_t nf; |
65 | mp **f; |
66 | size_t i; |
67 | PPCODE: |
68 | pgproc_get(oevents, &oev, &oec); |
69 | pgproc_get(ievents, &iev, &iec); |
70 | if (dh_limlee(&dp, ql, pl, flags, steps, r, |
71 | oev, oec, iev, iec, &nf, &f)) |
72 | XSRETURN_EMPTY; |
73 | XPUSHs(RET_MP(dp.p)); |
74 | XPUSHs(RET_MP(dp.g)); |
75 | XPUSHs(RET_MP(dp.q)); |
76 | for (i = 0; i < nf; i++) |
77 | XPUSHs(RET_MP(f[i])); |
78 | xfree(f); |
79 | |
80 | void |
81 | gen_dsa(me, ql, pl, steps = 0, k = &PL_sv_undef, events = &PL_sv_undef) |
82 | SV *me |
83 | unsigned ql |
84 | unsigned pl |
85 | unsigned steps |
86 | SV *k |
87 | MP_Prime_Gen_NullProc *events |
88 | PREINIT: |
89 | char *kp; |
90 | STRLEN ksz; |
91 | dsa_seed ds; |
92 | dsa_param dp; |
93 | pgen_proc *evproc; |
94 | void *evctx; |
95 | char buf[20]; |
96 | PPCODE: |
97 | if (SvOK(k)) |
98 | kp = SvPV(k, ksz); |
99 | else { |
100 | kp = buf; |
101 | ksz = 20; |
102 | rand_get(RAND_GLOBAL, kp, ksz); |
103 | } |
104 | pgproc_get(events, &evproc, &evctx); |
105 | if (dsa_gen(&dp, ql, pl, steps, kp, ksz, &ds, evproc, evctx)) |
106 | XSRETURN_EMPTY; |
107 | XPUSHs(RET_MP(dp.p)); |
108 | XPUSHs(RET_MP(dp.g)); |
109 | XPUSHs(RET_MP(dp.q)); |
110 | XPUSHs(sv_2mortal(newSVpvn(ds.p, ds.sz))); |
111 | XPUSHs(sv_2mortal(newSViv(ds.count))); |
112 | xfree(ds.p); |
113 | |
114 | MODULE = Catacomb PACKAGE = Catacomb::DSA |
115 | |
116 | ghash * |
117 | beginhash(c) |
118 | SV *c |
119 | PREINIT: |
120 | gdsa g; |
121 | CODE: |
122 | gdsa_pubfromsv(&g, c); |
123 | RETVAL = gdsa_beginhash(&g); |
124 | OUTPUT: |
125 | RETVAL |
126 | |
127 | SV * |
128 | endhash(c, h) |
129 | SV *c |
130 | ghash *h |
131 | PREINIT: |
132 | gdsa g; |
133 | CODE: |
134 | gdsa_pubfromsv(&g, c); |
135 | gdsa_endhash(&g, h); |
136 | XSRETURN_YES; |
137 | |
138 | MODULE = Catacomb PACKAGE = Catacomb::DSA::Private |
139 | |
140 | void |
141 | sign(c, m, k = 0) |
142 | SV *c |
143 | SV *m |
144 | mp *k |
145 | PREINIT: |
146 | gdsa g; |
147 | gdsa_sig s = GDSA_SIG_INIT; |
148 | char *p; |
149 | STRLEN len; |
150 | PPCODE: |
151 | gdsa_privfromsv(&g, c); |
152 | p = SvPV(m, len); |
153 | if (len != g.h->hashsz) |
154 | croak("bad message length"); |
155 | gdsa_sign(&g, &s, p, k); |
156 | XPUSHs(MAKE_MP(s.r)); |
157 | XPUSHs(MAKE_MP(s.s)); |
158 | |
159 | MODULE = Catacomb PACKAGE = Catacomb::DSA::Public |
160 | |
161 | bool |
162 | verify(c, m, r, s) |
163 | SV *c |
164 | mp *r |
165 | mp *s |
166 | SV *m |
167 | PREINIT: |
168 | gdsa g; |
169 | gdsa_sig ss = GDSA_SIG_INIT; |
170 | char *p; |
171 | STRLEN len; |
172 | CODE: |
173 | gdsa_pubfromsv(&g, c); |
174 | p = SvPV(m, len); |
175 | if (len != g.h->hashsz) |
176 | croak("bad message length"); |
177 | ss.r = r; |
178 | ss.s = s; |
179 | RETVAL = !gdsa_verify(&g, &ss, p); |
180 | OUTPUT: |
181 | RETVAL |
182 | |
183 | MODULE = Catacomb PACKAGE = Catacomb::KCDSA |
184 | |
185 | ghash * |
186 | beginhash(c) |
187 | SV *c |
188 | PREINIT: |
189 | gkcdsa g; |
190 | CODE: |
191 | gdsa_pubfromsv(&g, c); |
192 | RETVAL = gkcdsa_beginhash(&g); |
193 | OUTPUT: |
194 | RETVAL |
195 | |
196 | SV * |
197 | endhash(c, h) |
198 | SV *c |
199 | ghash *h |
200 | PREINIT: |
201 | gkcdsa g; |
202 | CODE: |
203 | gdsa_pubfromsv(&g, c); |
204 | gkcdsa_endhash(&g, h); |
205 | XSRETURN_YES; |
206 | |
207 | MODULE = Catacomb PACKAGE = Catacomb::KCDSA::Private |
208 | |
209 | void |
210 | sign(c, m, k = 0) |
211 | SV *c |
212 | SV *m |
213 | mp *k |
214 | PREINIT: |
215 | gkcdsa g; |
216 | gkcdsa_sig s = GKCDSA_SIG_INIT; |
217 | char *p; |
218 | STRLEN len; |
219 | PPCODE: |
220 | gdsa_privfromsv(&g, c); |
221 | p = SvPV(m, len); |
222 | if (len != g.h->hashsz) |
223 | croak("bad message length"); |
224 | gkcdsa_sign(&g, &s, p, k); |
225 | XPUSHs(sv_2mortal(newSVpvn(s.r, g.h->hashsz))); |
226 | XPUSHs(RET_MP(s.s)); |
227 | xfree(s.r); |
228 | |
229 | MODULE = Catacomb PACKAGE = Catacomb::KCDSA::Public |
230 | |
231 | bool |
232 | verify(c, m, r, s) |
233 | SV *c |
234 | SV *r |
235 | mp *s |
236 | SV *m |
237 | PREINIT: |
238 | gkcdsa g; |
239 | gkcdsa_sig ss = GKCDSA_SIG_INIT; |
240 | char *p; |
241 | STRLEN len; |
242 | CODE: |
243 | gdsa_pubfromsv(&g, c); |
244 | p = SvPV(m, len); |
245 | if (len != g.h->hashsz) |
246 | croak("bad message length"); |
247 | ss.r = SvPV(r, len); |
248 | if (len != g.h->hashsz) |
249 | croak("bad signature (r) length"); |
250 | ss.s = s; |
251 | RETVAL = !gkcdsa_verify(&g, &ss, p); |
252 | OUTPUT: |
253 | RETVAL |
254 | |
255 | MODULE = Catacomb PACKAGE = Catacomb::RSA::Public PREFIX = rsa_ |
256 | |
257 | RSA_Public * |
258 | new(me, sv) |
259 | SV *me |
260 | SV *sv |
261 | PREINIT: |
262 | cursor c; |
263 | rsa_pub *rp; |
264 | CODE: |
265 | rp = CREATE(rsa_pub); |
266 | c_init(&c, sv); |
267 | rp->n = C_MP(&c, "n"); |
268 | rp->e = C_MP(&c, "e"); |
269 | RETVAL = CREATE(rsa_pubctx); |
270 | rsa_pubcreate(RETVAL, rp); |
271 | OUTPUT: |
272 | RETVAL |
273 | |
274 | mp * |
275 | n(rp) |
276 | RSA_Public *rp |
277 | CODE: |
278 | RETVAL = MP_COPY(rp->rp->n); |
279 | OUTPUT: |
280 | RETVAL |
281 | |
282 | HV * |
283 | extract(rp) |
284 | RSA_Public *rp |
285 | CODE: |
286 | RETVAL = newHV(); |
287 | hvput(RETVAL, "n", MAKE_MP(rp->rp->n)); |
288 | hvput(RETVAL, "e", MAKE_MP(rp->rp->e)); |
289 | OUTPUT: |
290 | RETVAL |
291 | |
292 | SV * |
293 | DESTROY(rp) |
294 | RSA_Public *rp |
295 | PREINIT: |
296 | rsa_pub *rrp; |
297 | CODE: |
298 | rrp = rp->rp; |
299 | rsa_pubdestroy(rp); |
300 | DESTROY(rp); |
301 | rsa_pubfree(rrp); |
302 | DESTROY(rrp); |
303 | XSRETURN_YES; |
304 | |
305 | mp * |
306 | op(rp, p) |
307 | RSA_Public *rp |
308 | mp *p |
309 | CODE: |
310 | RETVAL = rsa_pubop(rp, MP_NEW, p); |
311 | OUTPUT: |
312 | RETVAL |
313 | |
314 | MODULE = Catacomb PACKAGE = Catacomb::RSA::Private PREFIX = rsa_ |
315 | |
316 | RSA_Private * |
317 | new(me, sv) |
318 | SV *me |
319 | SV *sv |
320 | PREINIT: |
321 | cursor c; |
322 | rsa_priv *rp; |
323 | CODE: |
324 | c_init(&c, sv); |
325 | rp = CREATE(rsa_priv); |
326 | rp->n = C_MP(&c, "n"); |
327 | rp->e = C_MP(&c, "e"); |
328 | rp->d = C_MP(&c, "d"); |
329 | rp->p = C_MP(&c, "p"); |
330 | rp->q = C_MP(&c, "q"); |
331 | rp->dp = C_MP(&c, "dp"); |
332 | rp->dq = C_MP(&c, "dq"); |
333 | rp->q_inv = C_MP(&c, "qi"); |
334 | if (rsa_recover(rp)) |
335 | croak("insuffcient values in Catacomb::RSA::Private::new"); |
336 | RETVAL = CREATE(rsa_privctx); |
337 | rsa_privcreate(RETVAL, rp, &rand_global); |
338 | OUTPUT: |
339 | RETVAL |
340 | |
341 | RSA_Private * |
342 | generate(me, nbits, r = &rand_global, n = 0, events = &PL_sv_undef) |
343 | SV *me |
344 | unsigned nbits |
345 | grand *r |
346 | unsigned n |
347 | MP_Prime_Gen_NullProc *events |
348 | PREINIT: |
349 | pgen_proc *ev; |
350 | void *ec; |
351 | rsa_priv *rp; |
352 | CODE: |
353 | rp = CREATE(rsa_priv); |
354 | pgproc_get(events, &ev, &ec); |
355 | if (rsa_gen(rp, nbits, r, n, ev, ec)) { |
356 | DESTROY(rp); |
357 | XSRETURN_UNDEF; |
358 | } |
359 | RETVAL = CREATE(rsa_privctx); |
360 | rsa_privcreate(RETVAL, rp, &rand_global); |
361 | OUTPUT: |
362 | RETVAL |
363 | |
364 | HV * |
365 | extract(rp) |
366 | RSA_Private *rp |
367 | CODE: |
368 | RETVAL = newHV(); |
369 | hvput(RETVAL, "n", MAKE_MP(rp->rp->n)); |
370 | hvput(RETVAL, "e", MAKE_MP(rp->rp->e)); |
371 | hvput(RETVAL, "d", MAKE_MP(rp->rp->d)); |
372 | hvput(RETVAL, "p", MAKE_MP(rp->rp->p)); |
373 | hvput(RETVAL, "q", MAKE_MP(rp->rp->q)); |
374 | hvput(RETVAL, "dp", MAKE_MP(rp->rp->dp)); |
375 | hvput(RETVAL, "dq", MAKE_MP(rp->rp->dq)); |
376 | hvput(RETVAL, "qi", MAKE_MP(rp->rp->q_inv)); |
377 | OUTPUT: |
378 | RETVAL |
379 | |
380 | mp * |
381 | n(rp) |
382 | RSA_Private *rp |
383 | CODE: |
384 | RETVAL = MP_COPY(rp->rp->n); |
385 | OUTPUT: |
386 | RETVAL |
387 | |
388 | SV * |
389 | DESTROY(rp) |
390 | RSA_Private *rp |
391 | PREINIT: |
392 | rsa_priv *rrp; |
393 | CODE: |
394 | rp->r = &rand_global; |
395 | rrp = rp->rp; |
396 | rsa_privdestroy(rp); |
397 | DESTROY(rp); |
398 | rsa_privfree(rrp); |
399 | DESTROY(rrp); |
400 | XSRETURN_YES; |
401 | |
402 | mp * |
403 | op(rp, p, r = &PL_sv_undef) |
404 | RSA_Private *rp |
405 | mp *p |
406 | SV *r |
407 | CODE: |
408 | rp->r = SvOK(r) ? ptrfromsv(r, "Catacomb::Rand", "r") : 0; |
409 | RETVAL = rsa_privop(rp, MP_NEW, p); |
410 | OUTPUT: |
411 | RETVAL |
412 | |
413 | MODULE = Catacomb PACKAGE = Catacomb::RSA::PKCS1Crypt |
414 | |
415 | mp * |
416 | pad(c, m, sz, nbits) |
417 | SV *c |
418 | SV *m |
419 | size_t sz |
420 | unsigned long nbits |
421 | PREINIT: |
422 | pkcs1 pc; |
423 | void *b; |
424 | void *mm; |
425 | STRLEN msz; |
426 | CODE: |
427 | pkcs1_fromsv(&pc, c); |
428 | mm = SvPV(m, msz); |
429 | b = xmalloc(sz); |
430 | RETVAL = pkcs1_cryptencode(MP_NEW, mm, msz, b, sz, nbits, &pc); |
431 | xfree(b); |
432 | OUTPUT: |
433 | RETVAL |
434 | |
435 | SV * |
436 | unpad(c, m, sz, nbits) |
437 | SV *c |
438 | mp *m |
439 | size_t sz |
440 | unsigned long nbits |
441 | PREINIT: |
442 | pkcs1 pc; |
443 | void *b; |
444 | int rc; |
445 | CODE: |
446 | pkcs1_fromsv(&pc, c); |
447 | b = xmalloc(sz); |
448 | rc = pkcs1_cryptdecode(m, b, sz, nbits, &pc); |
449 | if (rc < 0) |
450 | RETVAL = &PL_sv_undef; |
451 | else |
452 | RETVAL = newSVpvn(b, rc); |
453 | xfree(b); |
454 | OUTPUT: |
455 | RETVAL |
456 | |
457 | MODULE = Catacomb PACKAGE = Catacomb::RSA::PKCS1Sign |
458 | |
459 | mp * |
460 | pad(c, m, sz, nbits) |
461 | SV *c |
462 | SV *m |
463 | size_t sz |
464 | unsigned long nbits |
465 | PREINIT: |
466 | pkcs1 pc; |
467 | void *b; |
468 | void *mm; |
469 | STRLEN msz; |
470 | CODE: |
471 | pkcs1_fromsv(&pc, c); |
472 | mm = SvPV(m, msz); |
473 | b = xmalloc(sz); |
474 | RETVAL = pkcs1_sigencode(MP_NEW, mm, msz, b, sz, nbits, &pc); |
475 | xfree(b); |
476 | OUTPUT: |
477 | RETVAL |
478 | |
479 | SV * |
480 | unpad(c, s, m, sz, nbits) |
481 | SV *c |
482 | mp *s |
483 | SV *m |
484 | size_t sz |
485 | unsigned long nbits |
486 | PREINIT: |
487 | pkcs1 pc; |
488 | void *b; |
489 | void *mm; |
490 | STRLEN msz; |
491 | int rc; |
492 | CODE: |
493 | pkcs1_fromsv(&pc, c); |
494 | mm = SvPV(m, msz); |
495 | b = xmalloc(sz); |
496 | rc = pkcs1_sigdecode(s, mm, msz, b, sz, nbits, &pc); |
497 | if (rc < 0) XSRETURN_UNDEF; |
498 | RETVAL = newSVpvn(b, rc); |
499 | xfree(b); |
500 | OUTPUT: |
501 | RETVAL |
502 | |
503 | MODULE = Catacomb PACKAGE = Catacomb::RSA::OAEP |
504 | |
505 | mp * |
506 | pad(c, m, sz, nbits) |
507 | SV *c |
508 | SV *m |
509 | size_t sz |
510 | unsigned long nbits |
511 | PREINIT: |
512 | oaep pc; |
513 | void *b; |
514 | void *mm; |
515 | STRLEN msz; |
516 | CODE: |
517 | oaep_fromsv(&pc, c); |
518 | mm = SvPV(m, msz); |
519 | b = xmalloc(sz); |
520 | RETVAL = oaep_encode(MP_NEW, mm, msz, b, sz, nbits, &pc); |
521 | xfree(b); |
522 | OUTPUT: |
523 | RETVAL |
524 | |
525 | SV * |
526 | unpad(c, m, sz, nbits) |
527 | SV *c |
528 | mp *m |
529 | size_t sz |
530 | unsigned long nbits |
531 | PREINIT: |
532 | oaep pc; |
533 | void *b; |
534 | int rc; |
535 | CODE: |
536 | oaep_fromsv(&pc, c); |
537 | b = xmalloc(sz); |
538 | rc = oaep_decode(m, b, sz, nbits, &pc); |
539 | if (rc < 0) |
540 | RETVAL = &PL_sv_undef; |
541 | else |
542 | RETVAL = newSVpvn(b, rc); |
543 | xfree(b); |
544 | OUTPUT: |
545 | RETVAL |
546 | |
547 | MODULE = Catacomb PACKAGE = Catacomb::RSA::PSS |
548 | |
549 | mp * |
550 | pad(c, m, sz, nbits) |
551 | SV *c |
552 | SV *m |
553 | size_t sz |
554 | unsigned long nbits |
555 | PREINIT: |
556 | pss pc; |
557 | void *b; |
558 | void *mm; |
559 | STRLEN msz; |
560 | CODE: |
561 | pss_fromsv(&pc, c); |
562 | mm = SvPV(m, msz); |
563 | b = xmalloc(sz); |
564 | RETVAL = pss_encode(MP_NEW, mm, msz, b, sz, nbits, &pc); |
565 | xfree(b); |
566 | OUTPUT: |
567 | RETVAL |
568 | |
569 | SV * |
570 | unpad(c, s, m, sz, nbits) |
571 | SV *c |
572 | mp *s |
573 | SV *m |
574 | size_t sz |
575 | unsigned long nbits |
576 | PREINIT: |
577 | pss pc; |
578 | void *b; |
579 | void *mm; |
580 | STRLEN msz; |
581 | int rc; |
582 | CODE: |
583 | pss_fromsv(&pc, c); |
584 | mm = SvPV(m, msz); |
585 | b = xmalloc(sz); |
586 | rc = pss_decode(s, mm, msz, b, sz, nbits, &pc); |
587 | if (rc < 0) XSRETURN_UNDEF; |
588 | RETVAL = newSVpvn(b, rc); |
589 | xfree(b); |
590 | OUTPUT: |
591 | RETVAL |
592 | |
593 | #----- That's all, folks ---------------------------------------------------- |