X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/2aa7d3a9238bfb3d117ca23191ea402c5c5d6f40..8aafc119905401cd820194d547018043510b1f88:/catacomb/__init__.py?ds=sidebyside

diff --git a/catacomb/__init__.py b/catacomb/__init__.py
index bbbe74b..5483cca 100644
--- a/catacomb/__init__.py
+++ b/catacomb/__init__.py
@@ -80,6 +80,13 @@ lostexchook = default_lostexchook
 ## Text/binary conversions.
 def _bin(s): return s
 
+## Iterating over dictionaries.
+def _iteritems(dict): return dict.iteritems()
+def _itervalues(dict): return dict.itervalues()
+
+## The built-in bignum type.
+_long = long
+
 ## How to fix a name back into the right identifier.  Alas, the rules are not
 ## consistent.
 def _fixname(name):
@@ -103,9 +110,9 @@ def _init():
     if i[0] != '_':
       d[i] = b[i];
   for i in [gcciphers, gcaeads, gchashes, gcmacs, gcprps]:
-    for c in i.itervalues():
+    for c in _itervalues(i):
       d[_fixname(c.name)] = c
-  for c in gccrands.itervalues():
+  for c in _itervalues(gccrands):
     d[_fixname(c.name + 'rand')] = c
 _init()
 
@@ -157,7 +164,8 @@ def _pp_commas(pp, printfn, items):
     else: pp.text(','); pp.breakable()
     printfn(i)
 def _pp_dict(pp, items):
-  def p((k, v)):
+  def p(kv):
+    k, v = kv
     pp.begin_group(0)
     pp.pretty(k)
     pp.text(':')
@@ -175,10 +183,10 @@ class _tmp:
   def fromhex(x):
     return ByteString(_unhexify(x))
   fromhex = staticmethod(fromhex)
-  def __hex__(me):
-    return _hexify(me)
+  def hex(me): return _hexify(me)
+  __hex__ = hex
   def __repr__(me):
-    return 'bytes(%r)' % hex(me)
+    return 'bytes(%r)' % me.hex()
 _augment(ByteString, _tmp)
 ByteString.__hash__ = str.__hash__
 bytes = ByteString.fromhex
@@ -187,7 +195,7 @@ bytes = ByteString.fromhex
 ### Symmetric encryption.
 
 class _tmp:
-  def encrypt(me, n, m, tsz = None, h = ByteString('')):
+  def encrypt(me, n, m, tsz = None, h = ByteString.zero(0)):
     if tsz is None: tsz = me.__class__.tagsz.default
     e = me.enc(n, len(h), len(m), tsz)
     if not len(h): a = None
@@ -195,7 +203,7 @@ class _tmp:
     c0 = e.encrypt(m)
     c1, t = e.done(aad = a)
     return c0 + c1, t
-  def decrypt(me, n, c, t, h = ByteString('')):
+  def decrypt(me, n, c, t, h = ByteString.zero(0)):
     d = me.dec(n, len(h), len(c), len(t))
     if not len(h): a = None
     else: a = d.aad().hash(h)
@@ -382,15 +390,22 @@ class BaseRat (object):
     return type(me)(me._d*n, me._n*d)
   __div__ = __truediv__
   __rdiv__ = __rtruediv__
-  def __cmp__(me, you):
-    n, d = _split_rat(you)
-    return cmp(me._n*d, n*me._d)
-  def __rcmp__(me, you):
+  def _order(me, you, op):
     n, d = _split_rat(you)
-    return cmp(n*me._d, me._n*d)
+    return op(me._n*d, n*me._d)
+  def __eq__(me, you): return me._order(you, lambda x, y: x == y)
+  def __ne__(me, you): return me._order(you, lambda x, y: x != y)
+  def __le__(me, you): return me._order(you, lambda x, y: x <= y)
+  def __lt__(me, you): return me._order(you, lambda x, y: x <  y)
+  def __gt__(me, you): return me._order(you, lambda x, y: x >  y)
+  def __ge__(me, you): return me._order(you, lambda x, y: x >= y)
 
 class IntRat (BaseRat):
   RING = MP
+  def __new__(cls, a, b):
+    if isinstance(a, float) or isinstance(b, float): return a/b
+    return super(IntRat, cls).__new__(cls, a, b)
+  def __float__(me): return float(me._n)/float(me._d)
 
 class GFRat (BaseRat):
   RING = GF
@@ -404,8 +419,12 @@ class _tmp:
   def mont(x): return MPMont(x)
   def barrett(x): return MPBarrett(x)
   def reduce(x): return MPReduce(x)
-  def __truediv__(me, you): return IntRat(me, you)
-  def __rtruediv__(me, you): return IntRat(you, me)
+  def __truediv__(me, you):
+    if isinstance(you, float): return _long(me)/you
+    else: return IntRat(me, you)
+  def __rtruediv__(me, you):
+    if isinstance(you, float): return you/_long(me)
+    else: return IntRat(you, me)
   __div__ = __truediv__
   __rdiv__ = __rtruediv__
   _repr_pretty_ = _pp_str
@@ -441,7 +460,7 @@ class _tmp:
 _augment(Field, _tmp)
 
 class _tmp:
-  def __repr__(me): return '%s(%sL)' % (_clsname(me), me.p)
+  def __repr__(me): return '%s(%s)' % (_clsname(me), me.p)
   def __hash__(me): return 0x114401de ^ hash(me.p)
   def _repr_pretty_(me, pp, cyclep):
     ind = _pp_bgroup_tyname(pp, me)
@@ -452,7 +471,7 @@ class _tmp:
 _augment(PrimeField, _tmp)
 
 class _tmp:
-  def __repr__(me): return '%s(%#xL)' % (_clsname(me), me.p)
+  def __repr__(me): return '%s(%#x)' % (_clsname(me), me.p)
   def ec(me, a, b): return ECBinProjCurve(me, a, b)
   def _repr_pretty_(me, pp, cyclep):
     ind = _pp_bgroup_tyname(pp, me)
@@ -647,21 +666,34 @@ _augment(KeySZSet, _tmp)
 ### Key data objects.
 
 class _tmp:
+  def merge(me, file, report = None):
+    """KF.merge(FILE, [report = <built-in-reporter>])"""
+    name = file.name
+    lno = 1
+    for line in file:
+      me.mergeline(name, lno, line, report)
+      lno += 1
+    return me
   def __repr__(me): return '%s(%r)' % (_clsname(me), me.name)
 _augment(KeyFile, _tmp)
 
 class _tmp:
+  def extract(me, file, filter = ''):
+    """KEY.extract(FILE, [filter = <any>])"""
+    line = me.extractline(filter)
+    file.write(line)
+    return me
   def __repr__(me): return '%s(%r)' % (_clsname(me), me.fulltag)
 _augment(Key, _tmp)
 
 class _tmp:
   def __repr__(me):
     return '%s({%s})' % (_clsname(me),
-                         ', '.join(['%r: %r' % kv for kv in me.iteritems()]))
+                         ', '.join(['%r: %r' % kv for kv in _iteritems(me)()]))
   def _repr_pretty_(me, pp, cyclep):
     ind = _pp_bgroup_tyname(pp, me)
     if cyclep: pp.text('...')
-    else: _pp_dict(pp, me.iteritems())
+    else: _pp_dict(pp, _iteritems(me))
     pp.end_group(ind, ')')
 _augment(KeyAttributes, _tmp)
 
@@ -680,38 +712,66 @@ class _tmp:
       pp.text(','); pp.breakable()
       pp.pretty(me.writeflags(me.flags))
     pp.end_group(ind, ')')
+  def __hash__(me): return me._HASHBASE ^ hash(me._guts())
+  def __eq__(me, kd):
+    return type(me) == type(kd) and \
+      me._guts() == kd._guts() and \
+      me.flags == kd.flags
+  def __ne__(me, kd):
+    return not me == kd
 _augment(KeyData, _tmp)
 
 class _tmp:
   def _guts(me): return me.bin
+  def __eq__(me, kd):
+    return isinstance(kd, KeyDataBinary) and me.bin == kd.bin
 _augment(KeyDataBinary, _tmp)
+KeyDataBinary._HASHBASE = 0x961755c3
 
 class _tmp:
   def _guts(me): return me.ct
 _augment(KeyDataEncrypted, _tmp)
+KeyDataEncrypted._HASHBASE = 0xffe000d4
 
 class _tmp:
   def _guts(me): return me.mp
 _augment(KeyDataMP, _tmp)
+KeyDataMP._HASHBASE = 0x1cb64d69
 
 class _tmp:
   def _guts(me): return me.str
 _augment(KeyDataString, _tmp)
+KeyDataString._HASHBASE = 0x349c33ea
 
 class _tmp:
   def _guts(me): return me.ecpt
 _augment(KeyDataECPt, _tmp)
+KeyDataECPt._HASHBASE = 0x2509718b
 
 class _tmp:
   def __repr__(me):
     return '%s({%s})' % (_clsname(me),
-                         ', '.join(['%r: %r' % kv for kv in me.iteritems()]))
+                         ', '.join(['%r: %r' % kv for kv in _iteritems(me)]))
   def _repr_pretty_(me, pp, cyclep):
     ind = _pp_bgroup_tyname(pp, me, '({ ')
     if cyclep: pp.text('...')
-    else: _pp_dict(pp, me.iteritems())
+    else: _pp_dict(pp, _iteritems(me))
     pp.end_group(ind, ' })')
+  def __hash__(me):
+    h = me._HASHBASE
+    for k, v in _iteritems(me):
+      h = ((h << 1) ^ 3*hash(k) ^ 5*hash(v))&0xffffffff
+    return h
+  def __eq__(me, kd):
+    if type(me) != type(kd) or me.flags != kd.flags or len(me) != len(kd):
+      return False
+    for k, v in _iteritems(me):
+      try: vv = kd[k]
+      except KeyError: return False
+      if v != vv: return False
+    return True
 _augment(KeyDataStructured, _tmp)
+KeyDataStructured._HASHBASE = 0x85851b21
 
 ###--------------------------------------------------------------------------
 ### Abstract groups.
@@ -1009,11 +1069,11 @@ class Ed448Priv (_EdDSAPriv, Ed448Pub):
 
 class _tmp:
   def __repr__(me):
-    return '{%s}' % ', '.join(['%r: %r' % kv for kv in me.iteritems()])
+    return '{%s}' % ', '.join(['%r: %r' % kv for kv in _iteritems(me)])
   def _repr_pretty_(me, pp, cyclep):
     ind = _pp_bgroup(pp, '{ ')
     if cyclep: pp.text('...')
-    else: _pp_dict(pp, me.iteritems())
+    else: _pp_dict(pp, _iteritems(me))
     pp.end_group(ind, ' }')
 _augment(_base._MiscTable, _tmp)