#----- Basic stuff ----------------------------------------------------------
package Catacomb;
-use DynaLoader;
-use Exporter;
-@ISA = qw(DynaLoader Exporter);
+use Catacomb::Base;
$VERSION = "1.0.0";
-bootstrap Catacomb;
-
-@EXPORT_OK = qw($random);
-%EXPORT_TAGS = ("const" => [qw(GRAND_CRYPTO PGEN_TRY PGEN_FAIL PGEN_PASS
- PGEN_DONE PGEN_ABORT PGEN_BEGIN)]);
-Exporter::export_ok_tags("const");
-
-sub AUTOLOAD {
- my $val = const($AUTOLOAD);
- *$AUTOLOAD = sub { $val };
- goto &$AUTOLOAD;
-}
-
-#----- Multiprecision arithmetic --------------------------------------------
-
-package Catacomb::MP;
-use Carp;
-
-use overload
- '+' => sub { _binop(\&add, @_); },
- '-' => sub { _binop(\&sub, @_); },
- '*' => sub { _binop(\&mul, @_); },
- '/' => sub { _binop(\&div, @_); },
- '%' => sub { _binop(\&mod, @_); },
- '&' => sub { _binop(\&and2c, @_); },
- '|' => sub { _binop(\&or2c, @_); },
- '^' => sub { _binop(\&xor2c, @_); },
- '**' => sub { _binop(\&pow, @_); },
- '>>' => sub { &lsr2c(@_[0, 1]); },
- '<<' => sub { &lsl2c(@_[0, 1]); },
- '~' => sub { ¬2c($_[0]) },
- '==' => sub { _binop(\&eq, @_); },
- '<=>' => sub { _binop(\&cmp, @_); },
- '""' => sub { &tostring($_[0]); },
- '0+' => sub { &toint($_[0]); },
- 'sqrt' => sub { &sqrt($_[0]); },
- 'neg' => sub { &neg($_[0]); };
-
-sub mod { (&div($_[0], $_[1]))[1]; }
-
-sub pow {
- croak("Usage: Catacomb::MP::pow(a, b)") unless @_ == 2;
- my ($a, $b) = @_;
- my $r = Catacomb::MP->new(1);
- while ($b) {
- $r *= $a if $b & 1;
- $a = sqr($a);
- $b >>= 1;
- }
- return $r;
-}
-
-sub _binop {
- my ($func, $a, $b, $flag) = @_;
- return $flag ? &$func($b, $a) : &$func($a, $b);
-}
-
-sub modexp {
- croak("Usage: Catacomb::MP::modexp(p, g, x)") unless @_ == 3;
- my ($p, $g, $x) = @_;
- $g = $p - $g if $g < 0;
- $g = $g % $p if $g > $p;
- if ($p & 1) {
- my $mm = Catacomb::MP::Mont->new($p);
- return $mm->exp($g, $x);
+BEGIN { @EXPORT_OK = (); }
+
+use Catacomb::MP;
+use Catacomb::GF;
+use Catacomb::Field;
+use Catacomb::EC;
+use Catacomb::Group;
+use Catacomb::Rand;
+use Catacomb::Crypto;
+use Catacomb::Key;
+
+foreach $_ (qw(Catacomb::MP::mp Catacomb::GF::gf
+ Catacomb::MP::newprime
+ Catacomb::MP::mp_loadl Catacomb::MP::mp_loadb
+ Catacomb::MP::mp_loadl2c Catacomb::MP::mp_loadb2c
+ Catacomb::MP::mp_fromstring
+ Catacomb::GF::gf_loadl Catacomb::GF::gf_loadb
+ Catacomb::GF::gf_fromstring
+ Catacomb::MP::Prime::primegen
+ Catacomb::MP::Prime::limleegen
+ Catacomb::MP::Prime::Filter::filterstepper)) {
+ my $new;
+ my $proc;
+ if (m:^(.*)/(.*)$:) {
+ $proc = $1;
+ $new = $2;
+ } elsif (/:(\w+)$/) {
+ $new = $1;
+ $proc = $_;
} else {
- my $mb = Catacomb::MP::Barrett->new($p);
- return $mb->exp($g, $x);
- }
-}
-
-sub modinv {
- croak("Usage: Catacomb::MP::modinv(p, x)") unless @_ == 2;
- my ($g, undef, $i) = gcd($_[0], $_[1]);
- croak("Arguments aren't coprime in Catacomb::MP::modinv") unless $g == 1;
- return $i;
-}
-
-#----- Binary polynomials ---------------------------------------------------
-
-package Catacomb::GF;
-use Carp;
-
-@ISA = qw(Catacomb::MP);
-
-use overload
- '+' => sub { _binop(\&add, @_); },
- '-' => sub { _binop(\&add, @_); },
- '*' => sub { _binop(\&mul, @_); },
- '/' => sub { _binop(\&div, @_); },
- '%' => sub { _binop(\&mod, @_); },
- '&' => sub { _binop(\&Catacomb::MP::and, @_); },
- '|' => sub { _binop(\&Catacomb::MP::or, @_); },
- '^' => sub { _binop(\&Catacomb::MP::xor, @_); },
- '>>' => sub { &Catacomb::MP::lsr(@_[0, 1]); },
- '<<' => sub { &Catacomb::MP::lsl(@_[0, 1]); },
- '~' => sub { &Catacomb::MP::not($_[0]) },
- '==' => sub { _binop(\&Catacomb::MP::eq, @_); },
- '<=>' => sub { _binop(\&Catacomb::MP::cmp, @_); },
- '""' => sub { "0x" . &Catacomb::MP::tostring($_[0], 16); },
- 'neg' => sub { $_[0]; },
- '0+' => sub { &Catacomb::MP::toint($_[0]); };
-
-sub mod { (&div($_[0], $_[1]))[1]; }
-
-sub _binop {
- my ($func, $a, $b, $flag) = @_;
- return $flag ? &$func($b, $a) : &$func($a, $b);
-}
-
-#----- Prime testing --------------------------------------------------------
-
-{
- my $cmpg = "Catacomb::MP::Prime::Gen";
- foreach my $i (qw(FilterStepper JumpStepper RabinTester)) {
- @{"${cmpg}::${i}::ISA"} = ("${cmpg}::MagicProc");
- }
- @{"${cmpg}::MagicProc::ISA"} = ("${cmpg}::Proc");
-}
-
-#----- Crypto algorithms ----------------------------------------------------
-
-package Catacomb;
-
-foreach my $i (qw(Cipher Hash MAC)) {
- my $tag = lc($i);
- my @v = ();
- my $cl = "Catacomb::${i}Class";
- foreach my $c (&{"${cl}::list"}($cl)) {
- my $x = $c->name(); $x =~ tr/a-zA-Z0-9/_/cs;
- ${"Catacomb::${i}::${x}"} = undef; # SUYB
- ${"Catacomb::${i}::${x}"} = $c;
- push(@v, "\$Catacomb::${i}::${x}");
+ next;
}
- $EXPORT_TAGS{$tag} = \@v;
- Exporter::export_ok_tags($tag);
-}
-
-package Catacomb::CipherClass;
-use Carp;
-
-sub encrypt {
- croak("Usage: Catacomb::CipherClass::encrypt(cc, k, [iv], plain)")
- if @_ < 3 || @_ > 4;
- my ($cc, $k, $iv, $p) = @_;
- if (@_ == 3) {
- $p = $iv;
- $iv = undef;
- }
- my $c = $cc->init($k);
- $c->setiv($iv) if defined($iv);
- return $c->encrypt($p);
-}
-
-sub decrypt {
- croak("Usage: Catacomb::CipherClass::decrypt(cc, k, [iv], cipher)")
- if @_ < 3 || @_ > 4;
- my ($cc, $k, $iv, $p) = @_;
- if (@_ == 3) {
- $p = $iv;
- $iv = undef;
- }
- my $c = $cc->init($k);
- $c->setiv($iv) if defined($iv);
- return $c->decrypt($p);
-}
-
-package Catacomb::HashClass;
-use Carp;
-
-sub hash {
- croak("Usage: Catacomb::HashClass::hash(hc, p)") unless @_ == 2;
- my ($hc, $p) = @_;
- my $h = $hc->init();
- $h->hash($p);
- return $h->done();
-}
-
-package Catacomb::MACClass;
-use Carp;
-
-sub mac {
- croak("Usage: Catacomb::MACClass::mac(mc, k, p)") unless @_ == 3;
- my ($mc, $k, $p) = @_;
- my $m = $mc->key($k);
- return $m->hash($p);
-}
-
-package Catacomb::MAC;
-use Carp;
-
-sub hash {
- croak("Usage: Catacomb::MAC::hash(m, p)") unless @_ == 2;
- my ($m, $p) = @_;
- my $h = $m->init();
- $h->hash($p);
- return $h->done();
-}
-
-#----- Random number generators ---------------------------------------------
-
-package Catacomb;
-
-foreach my $i (qw(True Fib LC DSA RC4 SEAL MGF Counter OFB Magic)) {
- @{"Catacomb::Rand::${i}::ISA"} = qw(Catacomb::Rand);
+ *{$new} = \&{$proc};
}
-$Catacomb::random = Catacomb::Rand::True->_global();
-$Catacomb::random->noisesrc();
-$Catacomb::random->seed(160);
+$rabin_tester = Catacomb::MP::Prime::Rabin->tester();
+$pg_events = Catacomb::MP::Prime::Gen::Proc->ev();
+$pg_evspin = Catacomb::MP::Prime::Gen::Proc->evspin();
+$pg_subev = Catacomb::MP::Prime::Gen::Proc->subev();
+
+$EXPORT_TAGS{"const"} = [Catacomb::_constants()];
+$EXPORT_TAGS{"random"} = [qw($random)];
+$EXPORT_TAGS{"mp"} = [qw(mp gf mp_loadb mp_loadl mp_loadb2c mp_loadl2c
+ mp_fromstring gf_loadb gf_loadl gf_fromstring)];
+$EXPORT_TAGS{"pgen"} = [qw(newprime primegen limleegen
+ filterstepper $rabin_tester
+ $pg_events $pg_evspin $pg_subev)];
+Exporter::export_ok_tags(keys %EXPORT_TAGS);
#----- That's all, folks ----------------------------------------------------
~mdw / catacomb-perl / blobdiff