chiark - git - mdw - catacomb-perl/blob - Catacomb.pod

   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>