fcd15e0b |
1 | =head1 NAME |
2 | |
3 | Catacomb - cryptographic library |
4 | |
5 | =head1 SYNOPSIS |
6 | |
7 | use Catacomb qw(:const :mp :random :pgen); |
8 | |
9 | $x = Catacomb::MP->new($str, [$radix]); |
10 | $x = Catacomb::MP->new($i); |
11 | $x = Catacomb::MP->loadb($bytes); |
12 | $x = Catacomb::MP->loadl($bytes); |
13 | $x = Catacomb::MP->loadb2c($bytes); |
14 | $x = Catacomb::MP->loadl2c($bytes); |
15 | ($x, $rest) = Catacomb::MP->fromstring($str, [$radix]); |
16 | $x = mp($str, [$radix]); |
17 | $x = mp($i); |
18 | ($x, $rest) = mp_fromstring($str, [$radix]); |
19 | $a = $b + $c; |
20 | $a = $b - $c; |
21 | $a = $b * $c; |
22 | $a = $b / $c; |
23 | $a = $b % $c; |
24 | $a = $b ** $n; |
25 | $a = $b << $n; |
26 | $a = $b >> $n; |
27 | $a = $b & $c; |
28 | $a = $b | $c; |
29 | $a = $b ^ $c; |
30 | $a = ~$b; |
31 | $p = $b == $c; |
32 | $p = $b != $c; |
33 | $p = $b < $c; |
34 | $p = $b > $c; |
35 | $p = $b <= $c; |
36 | $p = $b >= $c; |
37 | $a = sqrt($b); |
38 | $a = -$b; |
39 | $a = $b->add($c); |
40 | $a = $b->sub($c); |
41 | $a = $b->mul($c); |
42 | ($q, $r) = $a->div($b); |
43 | $a = $b->exp($c); |
44 | $a = $b->sqr(); |
45 | $a = $b->sqrt(); |
46 | $a = $b->neg(); |
47 | $a = $b->not(); |
48 | $a = $b->not2c(); |
49 | $a = $b->mod($c); |
50 | $p = $b->eq($c); |
51 | $cmp = $b->cmp($c); |
52 | $a = $b->and($c); |
53 | $a = $b->and2c($c); |
54 | $a = $b->or($c); |
55 | $a = $b->or2c($c); |
56 | $a = $b->xor($c); |
57 | $a = $b->xor2c($c); |
58 | $a = $b->nand($c); |
59 | $a = $b->nand2c($c); |
60 | $a = $b->nor($c); |
61 | $a = $b->nor2c($c); |
62 | $a = $b->not(); |
63 | $a = $b->not2c(); |
64 | $a = $b->lsl($n); |
65 | $a = $b->lsl2c($n); |
66 | $a = $b->lsr($n); |
67 | $a = $b->lsr2c($n); |
68 | $a = $b->setbit($n); |
69 | $a = $b->setbit2c($n); |
70 | $a = $b->clearbit($n); |
71 | $a = $b->clearbit2c($n); |
72 | $p = $b->testbit($n); |
73 | $p = $b->testbit2c($n); |
74 | $x = $y->copy(); # largely useless |
75 | $g = $a->gcd($b); |
76 | ($g, $u, $v) = $a->gcd($b); |
77 | ($s, $t) = $m->odd(); # m = 2^s t |
78 | $a = $p->modexp($x, $e); |
79 | $a = $p->modinv($b); |
80 | $r = $p->modsqrt($x); |
81 | $q = $n->jac($a); |
82 | $p = $x->primep([$rng]); |
83 | $nbits = $x->bits(); |
84 | $nbytes = $x->octets(); |
85 | $bytes = $x->storeb([$nbytes]); |
86 | $bytes = $x->storel([$nbytes]); |
87 | $bytes = $x->storeb2c([$nbytes]); |
88 | $bytes = $x->storel2c([$nbytes]); |
89 | $str = $x->tostring([$radix]); |
90 | $n = $x->toint(); |
91 | |
92 | $barrett = Catacomb::MP::Barrett->new($p); |
93 | $barrett = $p->barrett(); |
94 | $p = $barrett->m(); |
95 | $x = $barrett->reduce($y); |
96 | $a = $barrett->exp($x, $y); |
97 | |
98 | $mont = Catacomb::MP::Mont->new($p); |
99 | $mont = $p->mont(); |
100 | $r = $mont->r(); |
101 | $r2 = $mont->r2(); |
102 | $p = $mont->m(); |
103 | $x = $mont->in($y); |
104 | $a = $mont->mul($x, $y); |
105 | $a = $mont->expr($x, $y); |
106 | $a = $mont->mexpr($x0, $e0, $x1, $e1, ...); |
107 | $x = $mont->reduce($y); |
108 | $x = $mont->out($y); |
109 | $a = $mont->exp($x, $y); |
110 | $a = $mont->mexp($x0, $e0, $x1, $e1, ...); |
111 | |
112 | $reduce = Catacomb::MP::Reduce->new($p); |
113 | $reduce = $p->mkreduce(); |
114 | $p = $reduce->m(); |
115 | $x = $reduce->reduce($y); |
116 | $a = $barrett->exp($x, $y); |
117 | |
118 | $crt = Catacomb::MP::CRT->new(@n); |
119 | $n = $crt->product(); |
120 | @n = $crt->moduli(); |
121 | $x = $crt->solve(@r); |
122 | |
123 | $p = newprime($nbits, [$rng]); |
124 | |
125 | $filt = Catacomb::MP::Prime::Filter->new($x); |
126 | $filt = $x->filter(); |
127 | $rc = $filt->status(); |
128 | $x = $filt->m(); |
129 | $rc = $filt->step($n); |
130 | $rc = $filt->jump($jfilt); |
131 | $newfilt = $filt->muladd($mul, $add); # integers |
132 | |
133 | $stepper = Catacomb::MP::Prime::Filter->stepper($step); # integer |
134 | $stepper = filterstepper($step); |
135 | $jumper = Catacomb::MP::Prime::Filter->stepper($jump); # MP |
136 | $jumper = filterjumper($jump); |
137 | |
138 | $rabin = Catacomb::MP::Prime::Rabin->new($m); |
139 | $rabin = $p->rabin(); |
140 | $m = $rabin->m(); |
141 | $rc = $rabin->test($wit); |
142 | $n = $rabin->iters(); |
143 | $n = Catacomb::MP::Prime::Rabin->ntests($bits); |
144 | $tester = Catacomb::MP::Prime::Rabin->tester(); |
145 | $tester = $rabintester; |
146 | |
147 | $events = Catacomb::MP::Prime::Gen::Proc->ev(); |
148 | $events = Catacomb::MP::Prime::Gen::Proc->evspin(); |
149 | $events = Catacomb::MP::Prime::Gen::Proc->subev(); |
150 | |
151 | $p = Catacomb::MP::Prime->gen |
152 | ($name, $x, $nsteps, $stepper, $ntests, $tester, [$events]); |
153 | $p = primegen |
154 | ($name, $x, $nsteps, $stepper, $ntests, $tester, [$events]); |
155 | if (($x, $j) = Catacomb::MP::Prime->strongprime_setup |
156 | ($name, $nbits, [$rng], [$nsteps], [$subevents])) { |
157 | $p = Catacomb::MP::Prime->gen |
158 | ($name, $x, $nsteps, $j, $ntests, $tester, [$events]); |
159 | } |
160 | ($p, @f) = Catacomb::MP::Prime->limlee |
161 | ($name, $qbits, $pbits, [$rng], [$on], [$oev], [$iev]); |
162 | ($p, @f) = limleegen |
163 | ($name, $qbits, $pbits, [$rng], [$on], [$oev], [$iev]); |
164 | |
165 | package MyPrimeGenObject; |
166 | sub new { ... }; |
167 | sub BEGIN { ... }; |
168 | sub TRY { ... }; |
169 | sub FAIL { ... }; |
170 | sub PASS { ... }; |
171 | sub DONE { ... }; |
172 | sub ABORT { ... }; |
173 | $name = $ev->name(); |
174 | $x = $ev->m([$xx]); |
175 | $rng = $ev->rand(); |
176 | |
177 | $a = Catacomb::GF->new($x); |
178 | $a = Catacomb::GF->loadb($bytes); |
179 | $a = Catacomb::GF->loadl($bytes); |
180 | ($x, $rest) = Catacomb::GF->fromstring($str, [$radix]); |
181 | $a = gf($mp); |
182 | $a = gf($str); |
183 | $a = gf($i); |
184 | $a = gf_loadb($bytes); |
185 | $a = gf_loadl($bytes); |
186 | ($x, $rest) = gf_fromstring($str, [$radix]); |
187 | $x = mp($a); |
188 | $a = $b + $c; |
189 | $a = $b - $c; # same as + |
190 | $a = $b * $c; |
191 | $a = $b / $c; |
192 | $a = $b % $c; |
193 | $a = $b << $n; |
194 | $a = $b >> $n; |
195 | $a = $b & $c; |
196 | $a = $b | $c; |
197 | $a = $b ^ $c; |
198 | $a = ~$b; |
199 | $p = $b == $c; |
200 | $p = $b != $c; |
201 | $a = -$b; # does nothing |
202 | $a = $b->copy(); # largely pointless |
203 | $a = $b->add($c); |
204 | $a = $b->sub($c); |
205 | $a = $b->mul($c); |
206 | $a = $b->sqr(); |
207 | ($q, $r) = $a->div($b); |
208 | $a = $b->lsl($n); |
209 | $a = $b->lsr($n); |
210 | $a = $b->and($c); |
211 | $a = $b->or($c); |
212 | $a = $b->xor($c); |
213 | $a = $b->nand($c); |
214 | $a = $b->nor($c); |
215 | $a = $b->setbit($n); |
216 | $a = $b->clearbit($n); |
217 | $g = $a->gcd($b); |
218 | ($g, $u, $v) = $a->gcd($b); |
219 | $p = $p->irreduciblep(); |
220 | $a = $b->modinv($c); |
221 | $a = $b->modexp($c, $n); |
222 | # and all the Catacomb::MP methods |
223 | |
224 | $F = Catacomb::Field->prime($p); |
225 | $F = Catacomb::Field->niceprime($p); |
226 | $F = Catacomb::Field->binpoly($p); |
227 | $F = Catacomb::Field->binnorm($p, $beta); |
228 | $F = Catacomb::Field->byname($name); |
229 | $F = $p->primefield(); |
230 | $F = $p->niceprimefield(); |
231 | $F = $p->binpolyfield(); |
232 | $F = $p>binnormfield($beta); |
233 | $name = $F->name(); |
234 | $ty = $F->type(); |
235 | $info = $F->get(); |
236 | $p = $F->samep($FF); |
237 | $q = $F->q(); |
238 | $m = $F->m(); |
239 | $nbits = $F->nbits(); |
240 | $nbytes = $F-noctets(); |
241 | $xi = $F->in($x); |
242 | $x = $F->out($xi); |
243 | $p = $F->zerop($xi); |
244 | $xi = $F->neg($yi); |
245 | $xi = $F->add($yi, $zi); |
246 | $xi = $F->sub($yi, $zi); |
247 | $xi = $F->mul($yi, $zi); |
248 | $xi = $F->div($yi, $zi); |
249 | $xi = $F->sqr($yi, $zi); |
250 | $xi = $F->inv($yi); |
251 | $xi = $F->reduce($yi); |
252 | $xi = $F->sqrt($yi); |
253 | $xi = $F->quadsolve($yi); |
254 | $xi = $F->dbl($yi); |
255 | $xi = $F->tpl($yi); |
256 | $xi = $F->hlv($yi); |
257 | |
258 | $e = Catacomb::Field::Elt->new($F, $x); |
259 | $e = $F->elt($x); |
260 | $e = $F->zero(); |
261 | $e = $F->one(); |
262 | $e = $F->rand([$rng]); |
263 | $F = $e->field(); |
264 | $x = $e->value(); |
265 | $str = $e->tostring([$radix]); |
266 | $e = $f->inv(); |
267 | $e = $f + $g; |
268 | $e = $f - $g; |
269 | $e = $f * $g; |
270 | $e = $f / $g; |
271 | $e = $f ** $n; |
272 | $p = $f == $g; |
273 | $p = $f != $g; |
274 | $e = -$f; |
275 | $e = sqrt($f); |
276 | $p = $f->zerop(); |
277 | |
278 | $P = Catacomb::EC::Point->new([$x], [$y], [$z]); |
279 | ($P, $rest) = Catacomb::EC::Point->get($buf); |
280 | $p = $P->atinfp(); |
281 | $x = $P->x(); |
282 | $y = $P->y(); |
283 | $z = $P->z(); |
284 | $p = $P->eq($Q); |
285 | $buf = $P->put(); |
286 | $str = $P->tostring(); |
287 | |
288 | $C = Catacomb::EC::Curve->prime($F, $a, $b); |
289 | $C = Catacomb::EC::Curve->primeproj($F, $a, $b); |
290 | $C = Catacomb::EC::Curve->bin($F, $a, $b); |
291 | $C = Catacomb::EC::Curve->binproj($F, $a, $b); |
292 | ($C, $G, $r, $h) = Catacomb::EC::Curve->getinfo($name); |
293 | $C = $F->primecurve($F, $a, $b); |
294 | $C = $F->primeprojcurve($F, $a, $b); |
295 | $C = $F->bincurve($F, $a, $b); |
296 | $C = $F->binprojcurve($F, $a, $b); |
297 | $name = $C->name(); |
298 | $a = $C->a(); |
299 | $b = $C->b(); |
300 | $F = $C->field(); |
301 | $info = $C->get(); |
302 | $p = $C->samep($CC); |
303 | $bytes = $C->putraw($P); |
304 | ($pp, $rest) = $C->getraw($bytes); |
305 | $buf = $C->putraw($P); |
306 | ($P, $rest) = $C->getraw($buf); |
307 | $P = $C->neg($Q); |
308 | $P = $C->add($Q, $R); |
309 | $P = $C->dbl($Q); |
310 | $p = $C->check($P); |
311 | $P = $C->mul($Q, $n); |
312 | $P = $C->mmul($P0, $n0, $P1, $n1, ...); |
313 | $err = $C->checkinfo($G, $r, $h); |
314 | $Pi = $C->in($P); |
315 | $Pi = $C->fix($Pi); |
316 | $Pi = $C->ifind($xi); |
317 | $Pi = $C->ineg($Qi); |
318 | $Pi = $C->iadd($Qi, $Ri); |
319 | $Pi = $C->isub($Qi, $Ri); |
320 | $Pi = $C->idbl($Qi); |
321 | $p = $C->icheck($Pi); |
322 | $Pi = $C->imul($Qi, $n); |
323 | $Pi = $C->immul($Qi0, $n0, $Qi1, $n1, ...); |
324 | $P = $C->out($Pi); |
325 | |
326 | $P = Catacomb::EC::Point->new($C, [$p]); |
327 | $P = Catacomb::EC::Point->new($C, $x, $y); |
328 | $P = $C->inf(); |
329 | $P = $C->pt($p); |
330 | $P = $C->pt($x, $y); |
331 | $P = $C->find($x); |
332 | $P = $C->rand([$rng]); |
333 | $C = $P->curve(); |
334 | $F = $P->field(); |
335 | $P = $Q->point(); |
336 | $p = $P->atinfp(); |
337 | $x = $P->x(); |
338 | $y = $P->y(); |
339 | $p = $P->check(); |
340 | $P = $Q->mul($n); |
341 | $P = $Q + $R; |
342 | $P = $Q - $R; |
343 | $P = $Q * $n; |
344 | $P = $n * $Q; |
345 | $p = $Q == $R; |
346 | $p = $Q != $R; |
347 | $P = -$Q; |
348 | |
349 | $G = Catacomb::Group->prime($p, $g, $q); |
350 | $G = Catacomb::Group->binary($p, $g, $q); |
351 | $G = Catacomb::Group->ec($C, $G, $r, $h); |
352 | $G = Catacomb::Group->byname($name); |
353 | $G = $p->primegroup($g, $q); |
354 | $G = $p->binpolygroup($g, $q); |
355 | $G = $C->ecgroup($G, $r, $h); |
356 | $info = $G->get(); |
357 | $a = $G->mexp($a0, $n0, $a1, $n1, ...); |
358 | $p = $G->samep($GG); |
359 | $r = $G->r(); |
360 | $h = $G->h(); |
361 | ($p, $err) = $G->check($rng); |
362 | |
363 | $a = Catacomb::Group::Elt($G, [$x]); |
364 | $a = $G->elt([$x]); |
365 | $a = $G->id(); |
366 | $g = $G->g(); |
367 | $a = $G->fromint($x); |
368 | $a = $G->fromec($P); |
369 | ($a, $rest) = $G->frombuf($buf); |
370 | ($a, $rest) = $G->fromraw($buf); |
371 | ($a, $rest) = $G->fromstring($str); |
372 | $x = $a->toint(); |
373 | $P = $a->toec(); |
374 | $buf = $a->tobuf(); |
375 | $buf = $a->toraw(); |
376 | $str = $a->tostring(); |
377 | $G = $a->group(); |
378 | $p = $a->identp(); |
379 | $p = $a->check(); |
380 | $a = $b->exp($n); |
381 | $a = $b->inv(); |
382 | $a = $b * $c; |
383 | $a = $b / $c; |
384 | $a = $b ** $n; |
385 | $p = $b == $c; |
386 | $p = $b != $c; |
387 | |
388 | $pc = Catacomb::PRPClass->find($name); |
389 | $pc = $Catacomb::rijndael; |
390 | $ksz = $pc->keysz(); |
391 | $name = $pc->name(); |
392 | $blksz = $pc->blksz(); |
393 | $ct = $pc->eblk($k, $pt); |
394 | $pt = $pc->eblk($k, $ct); |
395 | $P = $pc->init($k); |
396 | $ct = $P->eblk($pt); |
397 | $pt = $P->dblk($ct); |
398 | $pc = $P->class(); |
399 | |
400 | $cc = Catacomb::CipherClass->find($name); |
401 | $cc = $Catacomb::rijndael_cbc; |
402 | $ksz = $cc->keysz(); |
403 | $name = $cc->name(); |
404 | $blksz = $cc->blksz(); |
405 | $ct = $cc->encrypt($k, $pt, [$iv]); |
406 | $pt = $cc->decrypt($k, $ct, [$iv]); |
407 | $c = $cc->init(); |
408 | $ct = $c->encrypt($pt); |
409 | $pt = $c->decrypt($ct); |
410 | $c->setiv($iv); |
411 | $c->bdry(); |
412 | $pc = $c->class(); |
413 | |
414 | $hc = Catacomb::HashClass->find($name); |
415 | $hc = $Catacomb::sha; |
416 | $hsz = $hc->hashsz(); |
417 | $name = $hc->name(); |
418 | $res = $hc->hash($msg); |
419 | $h = $hc->init(); |
420 | $h->hash($buf); # as often as necessary |
421 | $hh = $h->copy(); |
422 | $hc = $h->class(); |
423 | $res = $h->done(); |
424 | |
425 | $mc = Catacomb::MACClass->find($name); |
426 | $mc = $Catacomb::sha_hmac; |
427 | $hsz = $mc->hashsz(); |
428 | $ksz = $mc->keysz(); |
429 | $name = $mc->name(); |
430 | $t = $mc->mac($k, $msg); |
431 | $m = $mc->key($k); |
432 | $mc = $m->class(); |
433 | $t = $m->hash($msg); |
434 | $h = $m->init(); |
435 | |
436 | $rng = Catacomb::Rand::True->new(); |
437 | $rng = Catacomb::random; |
438 | $rng->gate(); |
439 | $rng->stretch(); |
440 | $rng->key($k); |
441 | $rng->noisesrc(); |
442 | $rng->seed([$nbits]); |
443 | |
444 | $rng = Catacomb::Rand::DSA->new($k); |
445 | $rng->passes($n); |
446 | $k = $rng->seed(); |
447 | |
448 | $rng = Catacomb::Rand::Fib->new($seed); |
449 | $rng = Catacomb::Rand::LC->new($seed); |
450 | $rng = Catacomb::Rand::RC4->new($k); |
451 | $rng = Catacomb::Rand::SEAL->new($k); |
452 | $rng = Catacomb::Rand::MGF->new($name, $k); |
453 | $rng = Catacomb::Rand::Counter->new($name, $k); |
454 | $rng = Catacomb::Rand::OFB->new($name, $k); |
455 | |
456 | $rng->seedint($i); |
457 | $rng->seedblock($buf); |
458 | $rng->seedmp($x); |
459 | $rng->seedrand($rng2); |
460 | $u = $rng->raw(); |
461 | $u = $rng->word(); |
462 | $b = $rng->byte(); |
463 | $c = $rng->char(); |
464 | $u = $rng->range($max); |
465 | $x = $rng->mp($nbits, [$or]); |
466 | $x = $rng->mprange($max); |
467 | $buf = $rng->fill($nbytes); |
468 | $name = $rng->name(); |
469 | $f = $rng->flags(); |
470 | $u = $rng->max(); |
471 | |
472 | ($p, $g, $q) = Catacomb::PubKey->gen_dh |
473 | ($ql, $pl, [$steps], [$r], [$events]); |
474 | ($p, $g, $q, @f) = Catacomb::PubKey->gen_limlee |
475 | ($ql, $pl, [$flags], [$steps], [$r], [$oevents], [$ievents]); |
476 | ($p, $g, $q, $seed, $count) = Catacomb::PubKey->gen_dsa |
477 | ($ql, $pl, [$steps], [$k], [$events]); |
478 | |
479 | $dsapub = Catacomb::DSA::Public->new([$G, $p, $hunoz, $h, $rng]); |
480 | $dsapub = Catacomb::DSA::Public->new |
481 | ({ G => $G, p => $p, h => $h, rng => $rng}); |
482 | $h = $dsapub->beginhash(); |
483 | $dsapub->endhash($h); |
484 | $p = $dsapub->verify($msg, $r, $s); |
485 | |
486 | $dsapriv = Catacomb::DSA::Private->new([$G, $p, $u, $h, $rng]); |
487 | ($r, $s) = $dsapriv->sign($msg, [$k]); |
488 | |
489 | $kcdsapub = Catacomb::KCDSA::Public->new([$G, $p, $hunoz, $h, $rng]); |
490 | $h = $kcdsapub->beginhash(); |
491 | $kcdsapub->endhash($h); |
492 | $p = $kcdsapub->verify($msg, $r, $s); |
493 | |
494 | $kcdsapriv = Catacomb::KCDSA::Private->new([$G, $p, $u, $h, $rng]); |
495 | ($r, $s) = $kcdsapriv->sign($msg, [$k]); |
496 | |
497 | $p1pad = Catacomb::RSA::PKCS1Crypt->new([$ep, $rng]); |
498 | $p1pad = Catacomb::RSA::PKCS1Sign->new([$ep, $rng]); |
499 | $oaeppad = Catacomb::RSA::OAEP->new([$c, $h, $ep, $rng]); |
500 | $psspad = Catacomb::RSA::PSS->new([$c, $h, $ssz, $rng]); |
501 | $x = $pad->pad($m, $sz, $nbits); |
502 | $m = $cryptpad->unpad($m, $sz, $nbits); |
503 | $m = $sigpad->unpad($s, $m, $sz, $nbits); |
504 | |
505 | $rsapub = Catacomb::RSA::Public->new([$n, $e]); |
506 | $rsapub = Catacomb::RSA::Public->new({ n => $n, e => $e }); |
507 | $n = $rsapub->n(); |
508 | $h = $rsapub->extract(); |
509 | $x = $rsapub->op($y); |
510 | $c = $rsapub->encrypt($cryptpad, $m); |
511 | $rc = $rsapub->verify($signpad, $s, [$m]); |
512 | |
513 | $rsapriv = Catacomb::RSA::Private->new |
514 | ([$n, $e, $d, $p, $q, $dp, $dq, $qi]); |
515 | $rsapriv = Catacomb::RSA::Public->new |
516 | ({ n => $n, e => $e, d => $d, |
517 | p => $p, q => $q, dp => $dp, dq => $dq, qi => $qi }); |
518 | $rsapriv = Catacomb::RSA::Private->generate |
519 | ($nbits, [$rng], [$steps], [$events]); |
520 | $n = $rsapriv->n(); |
521 | $h = $rsapriv->extract(); |
522 | $x = $rsapriv->op($y, [$rng]); |
523 | $m = $rsapriv->decrypt($cryptpad, $c, [$rng]); |
524 | $s = $rsapriv->sign($signpad, $m, [$rng]); |
525 | |
526 | $s = Catacomb::Share::GF->new($t, $sz); |
527 | $sz = $s->sz(); |
528 | $t = $s->t(); |
529 | $i = $s->i(); |
530 | $s->mkshares($secret, [$rng]); |
531 | $share = $s->get($i); |
532 | $left = $s->add($i, $share); |
533 | $secret = $s->combine(); |
534 | |
535 | $s = Catacomb::Share::Prime->new($t, [$p]); |
536 | $p = $s->p(); |
537 | $t = $s->t(); |
538 | $i = $s->i(); |
539 | $s->mkshares($secret, [$rng]); |
540 | $share = $s->get($i); |
541 | $left = $s->add($i, $share); |
542 | $secret = $s->combine(); |
543 | |
544 | $pp = Catacomb::Passphrase->read($tag, [$len]); |
545 | $pp = Catacomb::Passphrase->verify($tag, [$len]); |
546 | Catacomb::Passphrase->cancel($tag); |
547 | |
548 | $ssz = $ksz->keysz($sz); |
549 | @ksz = $ksz->expand(); |
550 | |
551 | $kf = Catacomb::Key::File->new($name, [$kopen], [$reporter]); |
552 | $p = $kf->merge($name, $fh, [$reporter]); |
553 | $p = $kf->extract($key, $fh, [$kfilt]); |
554 | $kwriteerr = $kf->save(); |
555 | $i = $kf->iterate(); |
556 | $key = $i->next(); |
557 | |
558 | $key = $kf->bytype($kf, $type); |
559 | $key = $kf->byid($kf, $id); |
560 | $key = $kf->bytag($kf, $tag); |
561 | $key = $kf->newkey($kf, $id, $type, $exp); |
562 | ($key, $kd, $ftag) = $kf->qtag($qtag); |
563 | $p = $key->chkident($id); |
564 | $p = $key->chkcomment($id); |
565 | $exp = $key->exp(); |
566 | $exp = $key->del(); |
567 | $comm = $key->comment(); |
568 | $id = $key->id(); |
569 | $tag = $key->tag(); |
570 | $type = $key->type(); |
571 | $p = $key->setcomment($comm); |
572 | $p = $key->settag($tag); |
573 | $p = $key->delete(); |
574 | $ftag = $key->fulltag(); |
575 | $v = $key->getattr($a); |
576 | $p = $key->putattr($a, $v); |
577 | $p = $key->expiredp(); |
578 | $p = $key->used(); |
579 | $p = $key->fingerprint($h, [$kfilt]); |
580 | $Catacomb::Key::error; |
581 | $str = Catacomb::Key->strerror($errnum); |
582 | $ah = $key->attrs(); # returns hashref |
583 | $i = $key->attriter(); |
584 | ($a, $v) = $i->next(); |
585 | |
586 | $kfilt = Catacomb::Key::Filter->new($f, $m); |
587 | $kfilt = Catacomb::Key::Filter->new($fstr); |
588 | $fstr = $kfilt->tostring(); |
589 | $f = $kfilt->f(); |
590 | $m = $kfilt->m(); |
591 | |
592 | $kd = Catacomb::Key::Data->new(); |
593 | ($kd, $rest) = Catacomb::Key::Data->read($str); |
594 | $kd = Catacomb::Key::Data->decode($buf); |
595 | $kd = $key->data(); |
596 | $kd->setbinary($bin); |
597 | $kd->setencrypted($crypted); |
598 | $kd->setmp($x); |
599 | $kd->setstring($str); |
600 | $kd->setec($P); |
601 | $f = $kd->flags(); |
602 | $bin = $kd->getbinary(); |
603 | $crypted = $kd->getcrypted(); |
604 | $x = $kd->getmp(); |
605 | $str = $kd->getstring(); |
606 | $P = $kd->getec(); |
607 | $kd->setstruct(); |
608 | $kkd = $kd->structfind($t); |
609 | $kkd = $kd->structcreate($t); |
610 | $kd->structdel($t); |
611 | $kh = $kd->structopen(); # returns hashref |
612 | $kkd = $kd->copy(); |
613 | $kkd = $kd->lock($k); |
614 | $kkd = $kd->unlock($k); |
615 | $kkd = $kd->plock($tag); |
616 | $kkd = $kd->punlock($tag); |
617 | $str = $kd->write(); |
618 | $buf = $kd->encode(); |
619 | $i = $kd->structiter(); |
620 | |
621 | =head1 DESCRIPTION |
622 | |
623 | =head1 SEE ALSO |
624 | |
625 | Catacomb(3). |
626 | |
627 | =head1 AUTHOR |
628 | |
629 | Mark Wooding, <mdw@nsict.org> |