[catacomb-perl] / Catacomb.pod

=head1 NAME

Catacomb - cryptographic library

=head1 SYNOPSIS

    use Catacomb qw(:const :mp :random :pgen);

    $x = Catacomb::MP->new($str, [$radix]);
    $x = Catacomb::MP->new($i);
    $x = Catacomb::MP->loadb($bytes);
    $x = Catacomb::MP->loadl($bytes);
    $x = Catacomb::MP->loadb2c($bytes);
    $x = Catacomb::MP->loadl2c($bytes);
    ($x, $rest) = Catacomb::MP->fromstring($str, [$radix]);
    $x = mp($str, [$radix]);
    $x = mp($i);
    ($x, $rest) = mp_fromstring($str, [$radix]);
    $a = $b + $c;
    $a = $b - $c;
    $a = $b * $c;
    $a = $b / $c;
    $a = $b % $c;
    $a = $b ** $n;
    $a = $b << $n;
    $a = $b >> $n;
    $a = $b & $c;
    $a = $b | $c;
    $a = $b ^ $c;
    $a = ~$b;
    $p = $b == $c;
    $p = $b != $c;
    $p = $b < $c;
    $p = $b > $c;
    $p = $b <= $c;
    $p = $b >= $c;
    $a = sqrt($b);
    $a = -$b;
    $a = $b->add($c);
    $a = $b->sub($c);
    $a = $b->mul($c);
    ($q, $r) = $a->div($b);
    $a = $b->exp($c);
    $a = $b->sqr();
    $a = $b->sqrt();
    $a = $b->neg();
    $a = $b->not();
    $a = $b->not2c();
    $a = $b->mod($c);
    $p = $b->eq($c);
    $cmp = $b->cmp($c);
    $a = $b->and($c);
    $a = $b->and2c($c);
    $a = $b->or($c);
    $a = $b->or2c($c);
    $a = $b->xor($c);
    $a = $b->xor2c($c);
    $a = $b->nand($c);
    $a = $b->nand2c($c);
    $a = $b->nor($c);
    $a = $b->nor2c($c);
    $a = $b->not();
    $a = $b->not2c();
    $a = $b->lsl($n);
    $a = $b->lsl2c($n);
    $a = $b->lsr($n);
    $a = $b->lsr2c($n);
    $a = $b->setbit($n);
    $a = $b->setbit2c($n);
    $a = $b->clearbit($n);
    $a = $b->clearbit2c($n);
    $p = $b->testbit($n);
    $p = $b->testbit2c($n);
    $x = $y->copy(); # largely useless
    $g = $a->gcd($b);
    ($g, $u, $v) = $a->gcd($b);
    ($s, $t) = $m->odd(); # m = 2^s t
    $a = $p->modexp($x, $e);
    $a = $p->modinv($b);
    $r = $p->modsqrt($x);
    $q = $n->jac($a);
    $p = $x->primep([$rng]);
    $nbits = $x->bits();
    $nbytes = $x->octets();
    $bytes = $x->storeb([$nbytes]);
    $bytes = $x->storel([$nbytes]);
    $bytes = $x->storeb2c([$nbytes]);
    $bytes = $x->storel2c([$nbytes]);
    $str = $x->tostring([$radix]);
    $n = $x->toint();

    $barrett = Catacomb::MP::Barrett->new($p);
    $barrett = $p->barrett();
    $p = $barrett->m();
    $x = $barrett->reduce($y);
    $a = $barrett->exp($x, $y);

    $mont = Catacomb::MP::Mont->new($p);
    $mont = $p->mont();
    $r = $mont->r();
    $r2 = $mont->r2();
    $p = $mont->m();
    $x = $mont->in($y);
    $a = $mont->mul($x, $y);
    $a = $mont->expr($x, $y);
    $a = $mont->mexpr($x0, $e0, $x1, $e1, ...);
    $x = $mont->reduce($y);
    $x = $mont->out($y);
    $a = $mont->exp($x, $y);
    $a = $mont->mexp($x0, $e0, $x1, $e1, ...);

    $reduce = Catacomb::MP::Reduce->new($p);
    $reduce = $p->mkreduce();
    $p = $reduce->m();
    $x = $reduce->reduce($y);
    $a = $barrett->exp($x, $y);

    $crt = Catacomb::MP::CRT->new(@n);
    $n = $crt->product();
    @n = $crt->moduli();
    $x = $crt->solve(@r);

    $p = newprime($nbits, [$rng]);

    $filt = Catacomb::MP::Prime::Filter->new($x);
    $filt = $x->filter();
    $rc = $filt->status();
    $x = $filt->m();
    $rc = $filt->step($n);
    $rc = $filt->jump($jfilt);
    $newfilt = $filt->muladd($mul, $add); # integers

    $stepper = Catacomb::MP::Prime::Filter->stepper($step); # integer
    $stepper = filterstepper($step);
    $jumper = Catacomb::MP::Prime::Filter->stepper($jump); # MP
    $jumper = filterjumper($jump);

    $rabin = Catacomb::MP::Prime::Rabin->new($m);
    $rabin = $p->rabin();
    $m = $rabin->m();
    $rc = $rabin->test($wit);
    $n = $rabin->iters();
    $n = Catacomb::MP::Prime::Rabin->ntests($bits);
    $tester = Catacomb::MP::Prime::Rabin->tester();
    $tester = $rabintester;

    $events = Catacomb::MP::Prime::Gen::Proc->ev();
    $events = Catacomb::MP::Prime::Gen::Proc->evspin();
    $events = Catacomb::MP::Prime::Gen::Proc->subev();

    $p = Catacomb::MP::Prime->gen
      ($name, $x, $nsteps, $stepper, $ntests, $tester, [$events]);
    $p = primegen
      ($name, $x, $nsteps, $stepper, $ntests, $tester, [$events]);
    if (($x, $j) = Catacomb::MP::Prime->strongprime_setup
      ($name, $nbits, [$rng], [$nsteps], [$subevents])) {
      $p = Catacomb::MP::Prime->gen
        ($name, $x, $nsteps, $j, $ntests, $tester, [$events]);
    }
    ($p, @f) = Catacomb::MP::Prime->limlee
      ($name, $qbits, $pbits, [$rng], [$on], [$oev], [$iev]);
    ($p, @f) = limleegen
      ($name, $qbits, $pbits, [$rng], [$on], [$oev], [$iev]);

    package MyPrimeGenObject;
    sub new { ... };
    sub BEGIN { ... };
    sub TRY { ... };
    sub FAIL { ... };
    sub PASS { ... };
    sub DONE { ... };
    sub ABORT { ... };
    $name = $ev->name();
    $x = $ev->m([$xx]);
    $rng = $ev->rand();

    $a = Catacomb::GF->new($x);
    $a = Catacomb::GF->loadb($bytes);
    $a = Catacomb::GF->loadl($bytes);
    ($x, $rest) = Catacomb::GF->fromstring($str, [$radix]);
    $a = gf($mp);
    $a = gf($str);
    $a = gf($i);
    $a = gf_loadb($bytes);
    $a = gf_loadl($bytes);
    ($x, $rest) = gf_fromstring($str, [$radix]);
    $x = mp($a);
    $a = $b + $c;
    $a = $b - $c; # same as +
    $a = $b * $c;
    $a = $b / $c;
    $a = $b % $c;
    $a = $b << $n;
    $a = $b >> $n;
    $a = $b & $c;
    $a = $b | $c;
    $a = $b ^ $c;
    $a = ~$b;
    $p = $b == $c;
    $p = $b != $c;
    $a = -$b; # does nothing
    $a = $b->copy(); # largely pointless
    $a = $b->add($c);
    $a = $b->sub($c);
    $a = $b->mul($c);
    $a = $b->sqr();
    ($q, $r) = $a->div($b);
    $a = $b->lsl($n);
    $a = $b->lsr($n);
    $a = $b->and($c);
    $a = $b->or($c);
    $a = $b->xor($c);
    $a = $b->nand($c);
    $a = $b->nor($c);
    $a = $b->setbit($n);
    $a = $b->clearbit($n);
    $g = $a->gcd($b);
    ($g, $u, $v) = $a->gcd($b);
    $p = $p->irreduciblep();
    $a = $b->modinv($c);
    $a = $b->modexp($c, $n);
    # and all the Catacomb::MP methods

    $F = Catacomb::Field->prime($p);
    $F = Catacomb::Field->niceprime($p);
    $F = Catacomb::Field->binpoly($p);
    $F = Catacomb::Field->binnorm($p, $beta);
    $F = Catacomb::Field->byname($name);
    $F = $p->primefield();
    $F = $p->niceprimefield();
    $F = $p->binpolyfield();
    $F = $p>binnormfield($beta);
    $name = $F->name();
    $ty = $F->type();
    $info = $F->get();
    $p = $F->samep($FF);
    $q = $F->q();
    $m = $F->m();
    $nbits = $F->nbits();
    $nbytes = $F-noctets();
    $xi = $F->in($x);
    $x = $F->out($xi);
    $p = $F->zerop($xi);
    $xi = $F->neg($yi);
    $xi = $F->add($yi, $zi);
    $xi = $F->sub($yi, $zi);
    $xi = $F->mul($yi, $zi);
    $xi = $F->div($yi, $zi);
    $xi = $F->sqr($yi, $zi);
    $xi = $F->inv($yi);
    $xi = $F->reduce($yi);
    $xi = $F->sqrt($yi);
    $xi = $F->quadsolve($yi);
    $xi = $F->dbl($yi);    
    $xi = $F->tpl($yi);
    $xi = $F->hlv($yi);
 
    $e = Catacomb::Field::Elt->new($F, $x);
    $e = $F->elt($x);
    $e = $F->zero();
    $e = $F->one();
    $e = $F->rand([$rng]);
    $F = $e->field();
    $x = $e->value();
    $str = $e->tostring([$radix]);
    $e = $f->inv();
    $e = $f + $g;
    $e = $f - $g;
    $e = $f * $g;
    $e = $f / $g;
    $e = $f ** $n;
    $p = $f == $g;
    $p = $f != $g;
    $e = -$f;
    $e = sqrt($f);
    $p = $f->zerop();

    $P = Catacomb::EC::Point->new([$x], [$y], [$z]);
    ($P, $rest) = Catacomb::EC::Point->get($buf);
    $p = $P->atinfp();
    $x = $P->x();
    $y = $P->y();
    $z = $P->z();
    $p = $P->eq($Q);
    $buf = $P->put();
    $str = $P->tostring();

    $C = Catacomb::EC::Curve->prime($F, $a, $b);
    $C = Catacomb::EC::Curve->primeproj($F, $a, $b);
    $C = Catacomb::EC::Curve->bin($F, $a, $b);
    $C = Catacomb::EC::Curve->binproj($F, $a, $b);
    ($C, $G, $r, $h) = Catacomb::EC::Curve->getinfo($name);
    $C = $F->primecurve($F, $a, $b);
    $C = $F->primeprojcurve($F, $a, $b);
    $C = $F->bincurve($F, $a, $b);
    $C = $F->binprojcurve($F, $a, $b);
    $name = $C->name();
    $a = $C->a();
    $b = $C->b();
    $F = $C->field();
    $info = $C->get();
    $p = $C->samep($CC);
    $bytes = $C->putraw($P);
    ($pp, $rest) = $C->getraw($bytes);
    $buf = $C->putraw($P);
    ($P, $rest) = $C->getraw($buf);
    $P = $C->neg($Q);
    $P = $C->add($Q, $R);
    $P = $C->dbl($Q);
    $p = $C->check($P);
    $P = $C->mul($Q, $n);
    $P = $C->mmul($P0, $n0, $P1, $n1, ...);
    $err = $C->checkinfo($G, $r, $h);
    $Pi = $C->in($P);
    $Pi = $C->fix($Pi);
    $Pi = $C->ifind($xi);
    $Pi = $C->ineg($Qi);
    $Pi = $C->iadd($Qi, $Ri);
    $Pi = $C->isub($Qi, $Ri);
    $Pi = $C->idbl($Qi);
    $p = $C->icheck($Pi);
    $Pi = $C->imul($Qi, $n);
    $Pi = $C->immul($Qi0, $n0, $Qi1, $n1, ...);
    $P = $C->out($Pi);

    $P = Catacomb::EC::Point->new($C, [$p]);
    $P = Catacomb::EC::Point->new($C, $x, $y);
    $P = $C->inf();
    $P = $C->pt($p);
    $P = $C->pt($x, $y);
    $P = $C->find($x);
    $P = $C->rand([$rng]);
    $C = $P->curve();
    $F = $P->field();
    $P = $Q->point();
    $p = $P->atinfp();
    $x = $P->x();
    $y = $P->y();
    $p = $P->check();
    $P = $Q->mul($n);
    $P = $Q + $R;
    $P = $Q - $R;
    $P = $Q * $n;
    $P = $n * $Q;
    $p = $Q == $R;
    $p = $Q != $R;
    $P = -$Q;

    $G = Catacomb::Group->prime($p, $g, $q);
    $G = Catacomb::Group->binary($p, $g, $q);
    $G = Catacomb::Group->ec($C, $G, $r, $h);
    $G = Catacomb::Group->byname($name);
    $G = $p->primegroup($g, $q);
    $G = $p->binpolygroup($g, $q);
    $G = $C->ecgroup($G, $r, $h);
    $info = $G->get();
    $a = $G->mexp($a0, $n0, $a1, $n1, ...);
    $p = $G->samep($GG);
    $r = $G->r();
    $h = $G->h();
    ($p, $err) = $G->check($rng);

    $a = Catacomb::Group::Elt($G, [$x]);
    $a = $G->elt([$x]);
    $a = $G->id();
    $g = $G->g();
    $a = $G->fromint($x);
    $a = $G->fromec($P);
    ($a, $rest) = $G->frombuf($buf);
    ($a, $rest) = $G->fromraw($buf);
    ($a, $rest) = $G->fromstring($str);
    $x = $a->toint();
    $P = $a->toec();
    $buf = $a->tobuf();
    $buf = $a->toraw();
    $str = $a->tostring();
    $G = $a->group();
    $p = $a->identp();
    $p = $a->check();
    $a = $b->exp($n);
    $a = $b->inv();
    $a = $b * $c;
    $a = $b / $c;
    $a = $b ** $n;
    $p = $b == $c;
    $p = $b != $c;

    $pc = Catacomb::PRPClass->find($name);
    $pc = $Catacomb::rijndael;
    $ksz = $pc->keysz();
    $name = $pc->name();
    $blksz = $pc->blksz();
    $ct = $pc->eblk($k, $pt);
    $pt = $pc->eblk($k, $ct);
    $P = $pc->init($k);
    $ct = $P->eblk($pt);
    $pt = $P->dblk($ct);
    $pc = $P->class();

    $cc = Catacomb::CipherClass->find($name);
    $cc = $Catacomb::rijndael_cbc;
    $ksz = $cc->keysz();
    $name = $cc->name();
    $blksz = $cc->blksz();
    $ct = $cc->encrypt($k, $pt, [$iv]);
    $pt = $cc->decrypt($k, $ct, [$iv]);
    $c = $cc->init();
    $ct = $c->encrypt($pt);
    $pt = $c->decrypt($ct);
    $c->setiv($iv);
    $c->bdry();
    $pc = $c->class();

    $hc = Catacomb::HashClass->find($name);
    $hc = $Catacomb::sha;
    $hsz = $hc->hashsz();
    $name = $hc->name();
    $res = $hc->hash($msg);
    $h = $hc->init();
    $h->hash($buf); # as often as necessary
    $hh = $h->copy();
    $hc = $h->class();
    $res = $h->done();

    $mc = Catacomb::MACClass->find($name);
    $mc = $Catacomb::sha_hmac;
    $hsz = $mc->hashsz();
    $ksz = $mc->keysz();
    $name = $mc->name();
    $t = $mc->mac($k, $msg);
    $m = $mc->key($k);
    $mc = $m->class();
    $t = $m->hash($msg);
    $h = $m->init();

    $rng = Catacomb::Rand::True->new();
    $rng = Catacomb::random;
    $rng->gate();
    $rng->stretch();
    $rng->key($k);
    $rng->noisesrc();
    $rng->seed([$nbits]);

    $rng = Catacomb::Rand::DSA->new($k);
    $rng->passes($n);
    $k = $rng->seed();

    $rng = Catacomb::Rand::Fib->new($seed);
    $rng = Catacomb::Rand::LC->new($seed);
    $rng = Catacomb::Rand::RC4->new($k);
    $rng = Catacomb::Rand::SEAL->new($k);
    $rng = Catacomb::Rand::MGF->new($name, $k);
    $rng = Catacomb::Rand::Counter->new($name, $k);
    $rng = Catacomb::Rand::OFB->new($name, $k);
    
    $rng->seedint($i);
    $rng->seedblock($buf);
    $rng->seedmp($x);
    $rng->seedrand($rng2);
    $u = $rng->raw();
    $u = $rng->word();
    $b = $rng->byte();
    $c = $rng->char();
    $u = $rng->range($max);
    $x = $rng->mp($nbits, [$or]);
    $x = $rng->mprange($max);
    $buf = $rng->fill($nbytes);
    $name = $rng->name();
    $f = $rng->flags();
    $u = $rng->max();

    ($p, $g, $q) = Catacomb::PubKey->gen_dh
      ($ql, $pl, [$steps], [$r], [$events]);
    ($p, $g, $q, @f) = Catacomb::PubKey->gen_limlee
      ($ql, $pl, [$flags], [$steps], [$r], [$oevents], [$ievents]);
    ($p, $g, $q, $seed, $count) = Catacomb::PubKey->gen_dsa
      ($ql, $pl, [$steps], [$k], [$events]);

    $dsapub = Catacomb::DSA::Public->new([$G, $p, $hunoz, $h, $rng]);
    $dsapub = Catacomb::DSA::Public->new
      ({ G => $G, p => $p, h => $h, rng => $rng});
    $h = $dsapub->beginhash();
    $dsapub->endhash($h);
    $p = $dsapub->verify($msg, $r, $s);

    $dsapriv = Catacomb::DSA::Private->new([$G, $p, $u, $h, $rng]);
    ($r, $s) = $dsapriv->sign($msg, [$k]);

    $kcdsapub = Catacomb::KCDSA::Public->new([$G, $p, $hunoz, $h, $rng]);
    $h = $kcdsapub->beginhash();
    $kcdsapub->endhash($h);
    $p = $kcdsapub->verify($msg, $r, $s);

    $kcdsapriv = Catacomb::KCDSA::Private->new([$G, $p, $u, $h, $rng]);
    ($r, $s) = $kcdsapriv->sign($msg, [$k]);

    $p1pad = Catacomb::RSA::PKCS1Crypt->new([$ep, $rng]);
    $p1pad = Catacomb::RSA::PKCS1Sign->new([$ep, $rng]);
    $oaeppad = Catacomb::RSA::OAEP->new([$c, $h, $ep, $rng]);
    $psspad = Catacomb::RSA::PSS->new([$c, $h, $ssz, $rng]);
    $x = $pad->pad($m, $sz, $nbits);
    $m = $cryptpad->unpad($m, $sz, $nbits);
    $m = $sigpad->unpad($s, $m, $sz, $nbits);

    $rsapub = Catacomb::RSA::Public->new([$n, $e]);
    $rsapub = Catacomb::RSA::Public->new({ n => $n, e => $e });
    $n = $rsapub->n();
    $h = $rsapub->extract();
    $x = $rsapub->op($y);
    $c = $rsapub->encrypt($cryptpad, $m);
    $rc = $rsapub->verify($signpad, $s, [$m]);

    $rsapriv = Catacomb::RSA::Private->new
      ([$n, $e, $d, $p, $q, $dp, $dq, $qi]);
    $rsapriv = Catacomb::RSA::Public->new
      ({ n => $n, e => $e, d => $d, 
         p => $p, q => $q, dp => $dp, dq => $dq, qi => $qi });
    $rsapriv = Catacomb::RSA::Private->generate
      ($nbits, [$rng], [$steps], [$events]);
    $n = $rsapriv->n();
    $h = $rsapriv->extract();
    $x = $rsapriv->op($y, [$rng]);
    $m = $rsapriv->decrypt($cryptpad, $c, [$rng]);
    $s = $rsapriv->sign($signpad, $m, [$rng]);

    $s = Catacomb::Share::GF->new($t, $sz);
    $sz = $s->sz();
    $t = $s->t();
    $i = $s->i();
    $s->mkshares($secret, [$rng]);
    $share = $s->get($i);
    $left = $s->add($i, $share);
    $secret = $s->combine();

    $s = Catacomb::Share::Prime->new($t, [$p]);
    $p = $s->p();
    $t = $s->t();
    $i = $s->i();
    $s->mkshares($secret, [$rng]);
    $share = $s->get($i);
    $left = $s->add($i, $share);
    $secret = $s->combine();

    $pp = Catacomb::Passphrase->read($tag, [$len]);
    $pp = Catacomb::Passphrase->verify($tag, [$len]);
    Catacomb::Passphrase->cancel($tag);

    $ssz = $ksz->keysz($sz);
    @ksz = $ksz->expand();

    $kf = Catacomb::Key::File->new($name, [$kopen], [$reporter]);
    $p = $kf->merge($name, $fh, [$reporter]);
    $p = $kf->extract($key, $fh, [$kfilt]);
    $kwriteerr = $kf->save();
    $i = $kf->iterate();
    $key = $i->next();

    $key = $kf->bytype($kf, $type);
    $key = $kf->byid($kf, $id);
    $key = $kf->bytag($kf, $tag);
    $key = $kf->newkey($kf, $id, $type, $exp);
    ($key, $kd, $ftag) = $kf->qtag($qtag);
    $p = $key->chkident($id);
    $p = $key->chkcomment($id);
    $exp = $key->exp();
    $exp = $key->del();
    $comm = $key->comment();
    $id = $key->id();
    $tag = $key->tag();
    $type = $key->type();
    $p = $key->setcomment($comm);
    $p = $key->settag($tag);
    $p = $key->delete();
    $ftag = $key->fulltag();
    $v = $key->getattr($a);
    $p = $key->putattr($a, $v);
    $p = $key->expiredp();
    $p = $key->used();
    $p = $key->fingerprint($h, [$kfilt]);
    $Catacomb::Key::error;
    $str = Catacomb::Key->strerror($errnum);
    $ah = $key->attrs(); # returns hashref
    $i = $key->attriter();
    ($a, $v) = $i->next();

    $kfilt = Catacomb::Key::Filter->new($f, $m);
    $kfilt = Catacomb::Key::Filter->new($fstr);
    $fstr = $kfilt->tostring();
    $f = $kfilt->f();
    $m = $kfilt->m();

    $kd = Catacomb::Key::Data->new();
    ($kd, $rest) = Catacomb::Key::Data->read($str);
    $kd = Catacomb::Key::Data->decode($buf);
    $kd = $key->data();
    $kd->setbinary($bin);
    $kd->setencrypted($crypted);
    $kd->setmp($x);
    $kd->setstring($str);
    $kd->setec($P);
    $f = $kd->flags();
    $bin = $kd->getbinary();
    $crypted = $kd->getcrypted();
    $x = $kd->getmp();
    $str = $kd->getstring();
    $P = $kd->getec();
     $kd->setstruct();
    $kkd = $kd->structfind($t);
    $kkd = $kd->structcreate($t);
    $kd->structdel($t);
    $kh = $kd->structopen(); # returns hashref
    $kkd = $kd->copy();
    $kkd = $kd->lock($k);
    $kkd = $kd->unlock($k);
    $kkd = $kd->plock($tag);
    $kkd = $kd->punlock($tag);
    $str = $kd->write();
    $buf = $kd->encode();
    $i = $kd->structiter();

=head1 DESCRIPTION

=head1 SEE ALSO

Catacomb(3).

=head1 AUTHOR

Mark Wooding, <mdw@nsict.org>
Commit	Line	Data
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>