| 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> |