catacomb/__init__.py: Add iterfoo methods to _groupmap.

[catacomb-python] / catacomb / __init__.py

diff --git a/catacomb/__init__.py b/catacomb/__init__.py
index 8b1d0ef..aaec637 100644 (file)
--- a/catacomb/__init__.py
+++ b/catacomb/__init__.py
@@ -15,12 +15,12 @@
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
-# 
+#
 # Catacomb/Python is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with Catacomb/Python; if not, write to the Free Software Foundation,
 # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
@@ -46,17 +46,17 @@ def _init():
     if i[0] != '_':
       d[i] = b[i];
   for i in ['MP', 'GF', 'Field',
-            'ECPt', 'ECPtCurve', 'ECCurve', 'ECInfo',
-            'DHInfo', 'BinDHInfo', 'RSAPriv', 'BBSPriv',
-            'PrimeFilter', 'RabinMiller',
-            'Group', 'GE',
-            'KeyData']:
+           'ECPt', 'ECPtCurve', 'ECCurve', 'ECInfo',
+           'DHInfo', 'BinDHInfo', 'RSAPriv', 'BBSPriv',
+           'PrimeFilter', 'RabinMiller',
+           'Group', 'GE',
+           'KeyData']:
     c = d[i]
     pre = '_' + i + '_'
     plen = len(pre)
     for j in b:
       if j[:plen] == pre:
-        setattr(c, j[plen:], classmethod(b[j]))
+       setattr(c, j[plen:], classmethod(b[j]))
   for i in [gcciphers, gchashes, gcmacs, gcprps]:
     for c in i.itervalues():
       d[c.name.replace('-', '_')] = c
@@ -117,7 +117,12 @@ class _tmp:
 _augment(MP, _tmp)
 
 class _tmp:
+  def zerop(x): return x == 0
   def reduce(x): return GFReduce(x)
+  def trace(x, y): return x.reduce().trace(y)
+  def halftrace(x, y): return x.reduce().halftrace(y)
+  def modsqrt(x, y): return x.reduce().sqrt(y)
+  def quadsolve(x, y): return x.reduce().quadsolve(y)
 _augment(GF, _tmp)
 
 class _tmp:
@@ -159,7 +164,7 @@ class _tmp:
   def fromraw(me, s):
     return ecpt.fromraw(me, s)
   def pt(me, *args):
-    return ECPt(me, *args)
+    return me(*args)
 _augment(ECCurve, _tmp)
 
 class _tmp:
@@ -174,7 +179,7 @@ _augment(ECPt, _tmp)
 class _tmp:
   def __repr__(me):
     return 'ECInfo(curve = %r, G = %r, r = %s, h = %s)' % \
-           (me.curve, me.G, me.r, me.h)
+          (me.curve, me.G, me.r, me.h)
   def group(me):
     return ECGroup(me)
 _augment(ECInfo, _tmp)
@@ -199,7 +204,7 @@ _augment(KeySZAny, _tmp)
 class _tmp:
   def __repr__(me):
     return 'KeySZRange(%d, %d, %d, %d)' % \
-           (me.default, me.min, me.max, me.mod)
+          (me.default, me.min, me.max, me.mod)
   def check(me, sz): return me.min <= sz <= me.max and sz % me.mod == 0
   def best(me, sz):
     if sz < me.min: raise ValueError, 'key too small'
@@ -223,7 +228,7 @@ _augment(KeySZSet, _tmp)
 class _tmp:
   def __repr__(me):
     return '%s(p = %s, r = %s, g = %s)' % \
-           (type(me).__name__, me.p, me.r, me.g)
+          (type(me).__name__, me.p, me.r, me.g)
 _augment(FGInfo, _tmp)
 
 class _tmp:
@@ -287,7 +292,7 @@ class PSS (object):
     return _base._pss_encode(msg, nbits, me.mgf, me.hash, me.saltsz, me.rng)
   def decode(me, msg, sig, nbits):
     return _base._pss_decode(msg, sig, nbits,
-                             me.mgf, me.hash, me.saltsz, me.rng)
+                            me.mgf, me.hash, me.saltsz, me.rng)
 
 class _tmp:
   def encrypt(me, msg, enc):
@@ -298,7 +303,7 @@ class _tmp:
       x = enc.decode(msg, me.pubop(sig), me.n.nbits)
       return x is None or x == msg
     except ValueError:
-      return False      
+      return False
 _augment(RSAPub, _tmp)
 
 class _tmp:
@@ -326,10 +331,20 @@ class _groupmap (object):
     raise TypeError, "immutable object"
   def __iter__(me):
     return iter(me.map)
+  def iterkeys(me):
+    return iter(me.map)
+  def itervalues(me):
+    for k in me:
+      yield me[k]
+  def iteritems(me):
+    for k in me:
+      yield k, me[k]
   def keys(me):
     return [k for k in me]
   def values(me):
     return [me[k] for k in me]
+  def items(me):
+    return [(k, me[k]) for k in me]
 eccurves = _groupmap(_base._eccurves, ECInfo._curven)
 primegroups = _groupmap(_base._pgroups, DHInfo._groupn)
 bingroups = _groupmap(_base._bingroups, BinDHInfo._groupn)
@@ -499,20 +514,20 @@ class SimulTester (PrimeGenEventHandler):
 def sgprime(start, step = 2, name = 'p', event = pgen_nullev, nsteps = 0):
   start = MP(start)
   return pgen(start, name, SimulStepper(step = step), SimulTester(), event,
-              nsteps, RabinMiller.iters(start.nbits))
+             nsteps, RabinMiller.iters(start.nbits))
 
 def findprimitive(mod, hh = [], exp = None, name = 'g', event = pgen_nullev):
   return pgen(0, name, PrimitiveStepper(), PrimitiveTester(mod, hh, exp),
-              event, 0, 1)
+             event, 0, 1)
 
 def kcdsaprime(pbits, qbits, rng = rand,
-               event = pgen_nullev, name = 'p', nsteps = 0):
+              event = pgen_nullev, name = 'p', nsteps = 0):
   hbits = pbits - qbits
   h = pgen(rng.mp(hbits, 1), name + ' [h]',
-           PrimeGenStepper(2), PrimeGenTester(),
-           event, nsteps, RabinMiller.iters(hbits))
+          PrimeGenStepper(2), PrimeGenTester(),
+          event, nsteps, RabinMiller.iters(hbits))
   q = pgen(rng.mp(qbits, 1), name, SimulStepper(2 * h, 1, 2),
-           SimulTester(2 * h, 1), event, nsteps, RabinMiller.iters(qbits))
+          SimulTester(2 * h, 1), event, nsteps, RabinMiller.iters(qbits))
   p = 2 * q * h + 1
   return p, q, h