3 Catacomb - cryptographic library
7 use Catacomb qw(:const :mp :random :pgen);
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]);
18 ($x, $rest) = mp_fromstring($str, [$radix]);
42 ($q, $r) = $a->div($b);
69 $a = $b->setbit2c($n);
70 $a = $b->clearbit($n);
71 $a = $b->clearbit2c($n);
73 $p = $b->testbit2c($n);
74 $x = $y->copy(); # largely useless
76 ($g, $u, $v) = $a->gcd($b);
77 ($s, $t) = $m->odd(); # m = 2^s t
78 $a = $p->modexp($x, $e);
82 $p = $x->primep([$rng]);
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]);
92 $barrett = Catacomb::MP::Barrett->new($p);
93 $barrett = $p->barrett();
95 $x = $barrett->reduce($y);
96 $a = $barrett->exp($x, $y);
98 $mont = Catacomb::MP::Mont->new($p);
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);
109 $a = $mont->exp($x, $y);
110 $a = $mont->mexp($x0, $e0, $x1, $e1, ...);
112 $reduce = Catacomb::MP::Reduce->new($p);
113 $reduce = $p->mkreduce();
115 $x = $reduce->reduce($y);
116 $a = $barrett->exp($x, $y);
118 $crt = Catacomb::MP::CRT->new(@n);
119 $n = $crt->product();
121 $x = $crt->solve(@r);
123 $p = newprime($nbits, [$rng]);
125 $filt = Catacomb::MP::Prime::Filter->new($x);
126 $filt = $x->filter();
127 $rc = $filt->status();
129 $rc = $filt->step($n);
130 $rc = $filt->jump($jfilt);
131 $newfilt = $filt->muladd($mul, $add); # integers
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);
138 $rabin = Catacomb::MP::Prime::Rabin->new($m);
139 $rabin = $p->rabin();
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;
147 $events = Catacomb::MP::Prime::Gen::Proc->ev();
148 $events = Catacomb::MP::Prime::Gen::Proc->evspin();
149 $events = Catacomb::MP::Prime::Gen::Proc->subev();
151 $p = Catacomb::MP::Prime->gen
152 ($name, $x, $nsteps, $stepper, $ntests, $tester, [$events]);
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]);
160 ($p, @f) = Catacomb::MP::Prime->limlee
161 ($name, $qbits, $pbits, [$rng], [$on], [$oev], [$iev]);
163 ($name, $qbits, $pbits, [$rng], [$on], [$oev], [$iev]);
165 package MyPrimeGenObject;
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]);
184 $a = gf_loadb($bytes);
185 $a = gf_loadl($bytes);
186 ($x, $rest) = gf_fromstring($str, [$radix]);
189 $a = $b - $c; # same as +
201 $a = -$b; # does nothing
202 $a = $b->copy(); # largely pointless
207 ($q, $r) = $a->div($b);
216 $a = $b->clearbit($n);
218 ($g, $u, $v) = $a->gcd($b);
219 $p = $p->irreduciblep();
221 $a = $b->modexp($c, $n);
222 # and all the Catacomb::MP methods
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);
239 $nbits = $F->nbits();
240 $nbytes = $F-noctets();
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);
251 $xi = $F->reduce($yi);
253 $xi = $F->quadsolve($yi);
258 $e = Catacomb::Field::Elt->new($F, $x);
262 $e = $F->rand([$rng]);
265 $str = $e->tostring([$radix]);
278 $P = Catacomb::EC::Point->new([$x], [$y], [$z]);
279 ($P, $rest) = Catacomb::EC::Point->get($buf);
286 $str = $P->tostring();
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);
303 $bytes = $C->putraw($P);
304 ($pp, $rest) = $C->getraw($bytes);
305 $buf = $C->putraw($P);
306 ($P, $rest) = $C->getraw($buf);
308 $P = $C->add($Q, $R);
311 $P = $C->mul($Q, $n);
312 $P = $C->mmul($P0, $n0, $P1, $n1, ...);
313 $err = $C->checkinfo($G, $r, $h);
316 $Pi = $C->ifind($xi);
318 $Pi = $C->iadd($Qi, $Ri);
319 $Pi = $C->isub($Qi, $Ri);
321 $p = $C->icheck($Pi);
322 $Pi = $C->imul($Qi, $n);
323 $Pi = $C->immul($Qi0, $n0, $Qi1, $n1, ...);
326 $P = Catacomb::EC::Point->new($C, [$p]);
327 $P = Catacomb::EC::Point->new($C, $x, $y);
332 $P = $C->rand([$rng]);
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);
357 $a = $G->mexp($a0, $n0, $a1, $n1, ...);
361 ($p, $err) = $G->check($rng);
363 $a = Catacomb::Group::Elt($G, [$x]);
367 $a = $G->fromint($x);
369 ($a, $rest) = $G->frombuf($buf);
370 ($a, $rest) = $G->fromraw($buf);
371 ($a, $rest) = $G->fromstring($str);
376 $str = $a->tostring();
388 $pc = Catacomb::PRPClass->find($name);
389 $pc = $Catacomb::rijndael;
392 $blksz = $pc->blksz();
393 $ct = $pc->eblk($k, $pt);
394 $pt = $pc->eblk($k, $ct);
400 $cc = Catacomb::CipherClass->find($name);
401 $cc = $Catacomb::rijndael_cbc;
404 $blksz = $cc->blksz();
405 $ct = $cc->encrypt($k, $pt, [$iv]);
406 $pt = $cc->decrypt($k, $ct, [$iv]);
408 $ct = $c->encrypt($pt);
409 $pt = $c->decrypt($ct);
414 $hc = Catacomb::HashClass->find($name);
415 $hc = $Catacomb::sha;
416 $hsz = $hc->hashsz();
418 $res = $hc->hash($msg);
420 $h->hash($buf); # as often as necessary
425 $mc = Catacomb::MACClass->find($name);
426 $mc = $Catacomb::sha_hmac;
427 $hsz = $mc->hashsz();
430 $t = $mc->mac($k, $msg);
436 $rng = Catacomb::Rand::True->new();
437 $rng = Catacomb::random;
442 $rng->seed([$nbits]);
444 $rng = Catacomb::Rand::DSA->new($k);
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);
457 $rng->seedblock($buf);
459 $rng->seedrand($rng2);
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();
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]);
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);
486 $dsapriv = Catacomb::DSA::Private->new([$G, $p, $u, $h, $rng]);
487 ($r, $s) = $dsapriv->sign($msg, [$k]);
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);
494 $kcdsapriv = Catacomb::KCDSA::Private->new([$G, $p, $u, $h, $rng]);
495 ($r, $s) = $kcdsapriv->sign($msg, [$k]);
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);
505 $rsapub = Catacomb::RSA::Public->new([$n, $e]);
506 $rsapub = Catacomb::RSA::Public->new({ n => $n, e => $e });
508 $h = $rsapub->extract();
509 $x = $rsapub->op($y);
510 $c = $rsapub->encrypt($cryptpad, $m);
511 $rc = $rsapub->verify($signpad, $s, [$m]);
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]);
521 $h = $rsapriv->extract();
522 $x = $rsapriv->op($y, [$rng]);
523 $m = $rsapriv->decrypt($cryptpad, $c, [$rng]);
524 $s = $rsapriv->sign($signpad, $m, [$rng]);
526 $s = Catacomb::Share::GF->new($t, $sz);
530 $s->mkshares($secret, [$rng]);
531 $share = $s->get($i);
532 $left = $s->add($i, $share);
533 $secret = $s->combine();
535 $s = Catacomb::Share::Prime->new($t, [$p]);
539 $s->mkshares($secret, [$rng]);
540 $share = $s->get($i);
541 $left = $s->add($i, $share);
542 $secret = $s->combine();
544 $pp = Catacomb::Passphrase->read($tag, [$len]);
545 $pp = Catacomb::Passphrase->verify($tag, [$len]);
546 Catacomb::Passphrase->cancel($tag);
548 $ssz = $ksz->keysz($sz);
549 @ksz = $ksz->expand();
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();
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);
567 $comm = $key->comment();
570 $type = $key->type();
571 $p = $key->setcomment($comm);
572 $p = $key->settag($tag);
574 $ftag = $key->fulltag();
575 $v = $key->getattr($a);
576 $p = $key->putattr($a, $v);
577 $p = $key->expiredp();
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();
586 $kfilt = Catacomb::Key::Filter->new($f, $m);
587 $kfilt = Catacomb::Key::Filter->new($fstr);
588 $fstr = $kfilt->tostring();
592 $kd = Catacomb::Key::Data->new();
593 ($kd, $rest) = Catacomb::Key::Data->read($str);
594 $kd = Catacomb::Key::Data->decode($buf);
596 $kd->setbinary($bin);
597 $kd->setencrypted($crypted);
599 $kd->setstring($str);
602 $bin = $kd->getbinary();
603 $crypted = $kd->getcrypted();
605 $str = $kd->getstring();
608 $kkd = $kd->structfind($t);
609 $kkd = $kd->structcreate($t);
611 $kh = $kd->structopen(); # returns hashref
613 $kkd = $kd->lock($k);
614 $kkd = $kd->unlock($k);
615 $kkd = $kd->plock($tag);
616 $kkd = $kd->punlock($tag);
618 $buf = $kd->encode();
619 $i = $kd->structiter();
629 Mark Wooding, <mdw@nsict.org>