X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-perl/blobdiff_plain/f9952aec1cf6c64a5681308eea817b6113a37433..fcd15e0b7a3d0f0ca2f30953573f8d1f6b8e8bd2:/Catacomb.pm

diff --git a/Catacomb.pm b/Catacomb.pm
index fd0e455..8c2fb73 100644
--- a/Catacomb.pm
+++ b/Catacomb.pm
@@ -28,222 +28,58 @@
 #----- 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 { &not2c($_[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 ----------------------------------------------------