X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/catacomb-python/blobdiff_plain/a1e3dbc594b83e7e391c4b9453956c7cdf37915e..457b4e971a2795898c83a53ae4c27d6a893690d1:/catacomb/__init__.py

diff --git a/catacomb/__init__.py b/catacomb/__init__.py
index f79b4d2..785838e 100644
--- a/catacomb/__init__.py
+++ b/catacomb/__init__.py
@@ -96,6 +96,44 @@ def _checkend(r):
     raise SyntaxError, 'junk at end of string'
   return x
 
+## Some pretty-printing utilities.
+PRINT_SECRETS = False
+def _clsname(me): return type(me).__name__
+def _repr_secret(thing, secretp = True):
+  if not secretp or PRINT_SECRETS: return repr(thing)
+  else: return '#<SECRET>'
+def _pp_str(me, pp, cyclep): pp.text(cyclep and '...' or str(me))
+def _pp_secret(pp, thing, secretp = True):
+  if not secretp or PRINT_SECRETS: pp.pretty(thing)
+  else: pp.text('#<SECRET>')
+def _pp_bgroup(pp, text):
+  ind = len(text)
+  pp.begin_group(ind, text)
+  return ind
+def _pp_bgroup_tyname(pp, obj, open = '('):
+  return _pp_bgroup(pp, _clsname(obj) + open)
+def _pp_kv(pp, k, v, secretp = False):
+  ind = _pp_bgroup(pp, k + ' = ')
+  _pp_secret(pp, v, secretp)
+  pp.end_group(ind, '')
+def _pp_commas(pp, printfn, items):
+  firstp = True
+  for i in items:
+    if firstp: firstp = False
+    else: pp.text(','); pp.breakable()
+    printfn(i)
+def _pp_dict(pp, items):
+  def p((k, v)):
+    pp.begin_group(0)
+    pp.pretty(k)
+    pp.text(':')
+    pp.begin_group(2)
+    pp.breakable()
+    pp.pretty(v)
+    pp.end_group(2)
+    pp.end_group(0)
+  _pp_commas(pp, p, items)
+
 ###--------------------------------------------------------------------------
 ### Bytestrings.
 
@@ -108,8 +146,39 @@ class _tmp:
   def __repr__(me):
     return 'bytes(%r)' % hex(me)
 _augment(ByteString, _tmp)
+ByteString.__hash__ = str.__hash__
 bytes = ByteString.fromhex
 
+###--------------------------------------------------------------------------
+### Hashing.
+
+class _tmp:
+  def check(me, h):
+    hh = me.done()
+    return ctstreq(h, hh)
+_augment(GHash, _tmp)
+_augment(Poly1305Hash, _tmp)
+
+###--------------------------------------------------------------------------
+### NaCl `secretbox'.
+
+def secret_box(k, n, m):
+  E = xsalsa20(k).setiv(n)
+  r = E.enczero(poly1305.keysz.default)
+  s = E.enczero(poly1305.masksz)
+  y = E.encrypt(m)
+  t = poly1305(r)(s).hash(y).done()
+  return ByteString(t + y)
+
+def secret_unbox(k, n, c):
+  E = xsalsa20(k).setiv(n)
+  r = E.enczero(poly1305.keysz.default)
+  s = E.enczero(poly1305.masksz)
+  y = c[poly1305.tagsz:]
+  if not poly1305(r)(s).hash(y).check(c[0:poly1305.tagsz]):
+    raise ValueError, 'decryption failed'
+  return E.decrypt(c[poly1305.tagsz:])
+
 ###--------------------------------------------------------------------------
 ### Multiprecision integers and binary polynomials.
 
@@ -132,7 +201,8 @@ class BaseRat (object):
   @property
   def denom(me): return me._d
   def __str__(me): return '%s/%s' % (me._n, me._d)
-  def __repr__(me): return '%s(%s, %s)' % (type(me).__name__, me._n, me._d)
+  def __repr__(me): return '%s(%s, %s)' % (_clsname(me), me._n, me._d)
+  _repr_pretty_ = _pp_str
 
   def __add__(me, you):
     n, d = _split_rat(you)
@@ -177,6 +247,7 @@ class _tmp:
   def reduce(x): return MPReduce(x)
   def __div__(me, you): return IntRat(me, you)
   def __rdiv__(me, you): return IntRat(you, me)
+  _repr_pretty_ = _pp_str
 _augment(MP, _tmp)
 
 class _tmp:
@@ -188,6 +259,7 @@ class _tmp:
   def quadsolve(x, y): return x.reduce().quadsolve(y)
   def __div__(me, you): return GFRat(me, you)
   def __rdiv__(me, you): return GFRat(you, me)
+  _repr_pretty_ = _pp_str
 _augment(GF, _tmp)
 
 class _tmp:
@@ -206,14 +278,24 @@ class _tmp:
 _augment(Field, _tmp)
 
 class _tmp:
-  def __repr__(me): return '%s(%sL)' % (type(me).__name__, me.p)
+  def __repr__(me): return '%s(%sL)' % (_clsname(me), me.p)
   def __hash__(me): return 0x114401de ^ hash(me.p)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep: pp.text('...')
+    else: pp.pretty(me.p)
+    pp.end_group(ind, ')')
   def ec(me, a, b): return ECPrimeProjCurve(me, a, b)
 _augment(PrimeField, _tmp)
 
 class _tmp:
-  def __repr__(me): return '%s(%sL)' % (type(me).__name__, hex(me.p))
+  def __repr__(me): return '%s(%#xL)' % (_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)
+    if cyclep: pp.text('...')
+    else: pp.text('%#x' % me.p)
+    pp.end_group(ind, ')')
 _augment(BinField, _tmp)
 
 class _tmp:
@@ -231,6 +313,7 @@ _augment(BinNormField, _tmp)
 class _tmp:
   def __str__(me): return str(me.value)
   def __repr__(me): return '%s(%s)' % (repr(me.field), repr(me.value))
+  _repr_pretty_ = _pp_str
 _augment(FE, _tmp)
 
 ###--------------------------------------------------------------------------
@@ -238,7 +321,16 @@ _augment(FE, _tmp)
 
 class _tmp:
   def __repr__(me):
-    return '%s(%r, %s, %s)' % (type(me).__name__, me.field, me.a, me.b)
+    return '%s(%r, %s, %s)' % (_clsname(me), me.field, me.a, me.b)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      pp.pretty(me.field); pp.text(','); pp.breakable()
+      pp.pretty(me.a); pp.text(','); pp.breakable()
+      pp.pretty(me.b)
+    pp.end_group(ind, ')')
   def frombuf(me, s):
     return ecpt.frombuf(me, s)
   def fromraw(me, s):
@@ -267,17 +359,37 @@ _augment(ECBinCurve, _tmp)
 
 class _tmp:
   def __repr__(me):
-    if not me: return 'ECPt()'
-    return 'ECPt(%s, %s)' % (me.ix, me.iy)
+    if not me: return '%s()' % _clsname(me)
+    return '%s(%s, %s)' % (_clsname(me), me.ix, me.iy)
   def __str__(me):
     if not me: return 'inf'
     return '(%s, %s)' % (me.ix, me.iy)
+  def _repr_pretty_(me, pp, cyclep):
+    if cyclep:
+      pp.text('...')
+    elif not me:
+      pp.text('inf')
+    else:
+      ind = _pp_bgroup(pp, '(')
+      pp.pretty(me.ix); pp.text(','); pp.breakable()
+      pp.pretty(me.iy)
+      pp.end_group(ind, ')')
 _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)
+    return '%s(curve = %r, G = %r, r = %s, h = %s)' % \
+           (_clsname(me), me.curve, me.G, me.r, me.h)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'curve', me.curve); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'G', me.G); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'r', me.r); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'h', me.h)
+    pp.end_group(ind, ')')
   def __hash__(me):
     h = 0x9bedb8de
     h ^=   hash(me.curve)
@@ -294,21 +406,41 @@ class _tmp:
   def __str__(me):
     if not me: return 'inf'
     return '(%s, %s)' % (me.x, me.y)
+  def _repr_pretty_(me, pp, cyclep):
+    if cyclep:
+      pp.text('...')
+    elif not me:
+      pp.text('inf')
+    else:
+      ind = _pp_bgroup(pp, '(')
+      pp.pretty(me.x); pp.text(','); pp.breakable()
+      pp.pretty(me.y)
+      pp.end_group(ind, ')')
 _augment(ECPtCurve, _tmp)
 
 ###--------------------------------------------------------------------------
 ### Key sizes.
 
 class _tmp:
-  def __repr__(me): return 'KeySZAny(%d)' % me.default
+  def __repr__(me): return '%s(%d)' % (_clsname(me), me.default)
   def check(me, sz): return True
   def best(me, sz): return sz
 _augment(KeySZAny, _tmp)
 
 class _tmp:
   def __repr__(me):
-    return 'KeySZRange(%d, %d, %d, %d)' % \
-           (me.default, me.min, me.max, me.mod)
+    return '%s(%d, %d, %d, %d)' % \
+           (_clsname(me), me.default, me.min, me.max, me.mod)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      pp.pretty(me.default); pp.text(','); pp.breakable()
+      pp.pretty(me.min); pp.text(','); pp.breakable()
+      pp.pretty(me.max); pp.text(','); pp.breakable()
+      pp.pretty(me.mod)
+    pp.end_group(ind, ')')
   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'
@@ -317,7 +449,17 @@ class _tmp:
 _augment(KeySZRange, _tmp)
 
 class _tmp:
-  def __repr__(me): return 'KeySZSet(%d, %s)' % (me.default, me.set)
+  def __repr__(me): return '%s(%d, %s)' % (_clsname(me), me.default, me.set)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      pp.pretty(me.default); pp.text(','); pp.breakable()
+      ind1 = _pp_bgroup(pp, '{')
+      _pp_commas(pp, pp.pretty, me.set)
+      pp.end_group(ind1, '}')
+    pp.end_group(ind, ')')
   def check(me, sz): return sz in me.set
   def best(me, sz):
     found = -1
@@ -327,13 +469,91 @@ class _tmp:
     return found
 _augment(KeySZSet, _tmp)
 
+###--------------------------------------------------------------------------
+### Key data objects.
+
+class _tmp:
+  def __repr__(me): return '%s(%r)' % (_clsname(me), me.name)
+_augment(KeyFile, _tmp)
+
+class _tmp:
+  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()]))
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep: pp.text('...')
+    else: _pp_dict(pp, me.iteritems())
+    pp.end_group(ind, ')')
+_augment(KeyAttributes, _tmp)
+
+class _tmp:
+  def __repr__(me):
+    return '%s(%s, %r)' % (_clsname(me),
+                           _repr_secret(me._guts(),
+                                        not (me.flags & KF_NONSECRET)),
+                           me.writeflags(me.flags))
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_secret(pp, me._guts(), not (me.flags & KF_NONSECRET))
+      pp.text(','); pp.breakable()
+      pp.pretty(me.writeflags(me.flags))
+    pp.end_group(ind, ')')
+_augment(KeyData, _tmp)
+
+class _tmp:
+  def _guts(me): return me.bin
+_augment(KeyDataBinary, _tmp)
+
+class _tmp:
+  def _guts(me): return me.ct
+_augment(KeyDataEncrypted, _tmp)
+
+class _tmp:
+  def _guts(me): return me.mp
+_augment(KeyDataMP, _tmp)
+
+class _tmp:
+  def _guts(me): return me.str
+_augment(KeyDataString, _tmp)
+
+class _tmp:
+  def _guts(me): return me.ecpt
+_augment(KeyDataECPt, _tmp)
+
+class _tmp:
+  def __repr__(me):
+    return '%s({%s})' % (_clsname(me),
+                         ', '.join(['%r: %r' % kv for kv in me.iteritems()]))
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me, '({ ')
+    if cyclep: pp.text('...')
+    else: _pp_dict(pp, me.iteritems())
+    pp.end_group(ind, ' })')
+_augment(KeyDataStructured, _tmp)
+
 ###--------------------------------------------------------------------------
 ### Abstract groups.
 
 class _tmp:
   def __repr__(me):
-    return '%s(p = %s, r = %s, g = %s)' % \
-           (type(me).__name__, me.p, me.r, me.g)
+    return '%s(p = %s, r = %s, g = %s)' % (_clsname(me), me.p, me.r, me.g)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'p', me.p); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'r', me.r); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'g', me.g)
+    pp.end_group(ind, ')')
 _augment(FGInfo, _tmp)
 
 class _tmp:
@@ -346,7 +566,12 @@ _augment(BinDHInfo, _tmp)
 
 class _tmp:
   def __repr__(me):
-    return '%s(%r)' % (type(me).__name__, me.info)
+    return '%s(%r)' % (_clsname(me), me.info)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep: pp.text('...')
+    else: pp.pretty(me.info)
+    pp.end_group(ind, ')')
 _augment(Group, _tmp)
 
 class _tmp:
@@ -357,6 +582,7 @@ class _tmp:
     h ^= 2*hash(info.r) & 0xffffffff
     h ^= 5*hash(info.g) & 0xffffffff
     return h
+  def _get_geval(me, x): return MP(x)
 _augment(PrimeGroup, _tmp)
 
 class _tmp:
@@ -367,15 +593,19 @@ class _tmp:
     h ^= 2*hash(info.r) & 0xffffffff
     h ^= 5*hash(info.g) & 0xffffffff
     return h
+  def _get_geval(me, x): return GF(x)
 _augment(BinGroup, _tmp)
 
 class _tmp:
   def __hash__(me): return 0x0ec23dab ^ hash(me.info)
+  def _get_geval(me, x): return x.toec()
 _augment(ECGroup, _tmp)
 
 class _tmp:
   def __repr__(me):
     return '%r(%r)' % (me.group, str(me))
+  def _repr_pretty_(me, pp, cyclep):
+    pp.pretty(type(me)._get_geval(me))
 _augment(GE, _tmp)
 
 ###--------------------------------------------------------------------------
@@ -434,13 +664,158 @@ class _tmp:
       return x is None or x == msg
     except ValueError:
       return False
+  def __repr__(me):
+    return '%s(n = %r, e = %r)' % (_clsname(me), me.n, me.e)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'n', me.n); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'e', me.e)
+    pp.end_group(ind, ')')
 _augment(RSAPub, _tmp)
 
 class _tmp:
   def decrypt(me, ct, enc): return enc.decode(me.privop(ct), me.n.nbits)
   def sign(me, msg, enc): return me.privop(enc.encode(msg, me.n.nbits))
+  def __repr__(me):
+    return '%s(n = %r, e = %r, d = %s, ' \
+      'p = %s, q = %s, dp = %s, dq = %s, q_inv = %s)' % \
+      (_clsname(me), me.n, me.e,
+       _repr_secret(me.d), _repr_secret(me.p), _repr_secret(me.q),
+       _repr_secret(me.dp), _repr_secret(me.dq), _repr_secret(me.q_inv))
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'n', me.n); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'e', me.e); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'd', me.d, secretp = True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'p', me.p, secretp = True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'q', me.q, secretp = True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'dp', me.dp, secretp = True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'dq', me.dq, secretp = True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'q_inv', me.q_inv, secretp = True)
+    pp.end_group(ind, ')')
 _augment(RSAPriv, _tmp)
 
+###--------------------------------------------------------------------------
+### DSA and related schemes.
+
+class _tmp:
+  def __repr__(me): return '%s(G = %r, p = %r)' % (_clsname(me), me.G, me.p)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'G', me.G); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'p', me.p)
+    pp.end_group(ind, ')')
+_augment(DSAPub, _tmp)
+_augment(KCDSAPub, _tmp)
+
+class _tmp:
+  def __repr__(me): return '%s(G = %r, u = %s, p = %r)' % \
+      (_clsname(me), me.G, _repr_secret(me.u), me.p)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'G', me.G); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'u', me.u, True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'p', me.p)
+    pp.end_group(ind, ')')
+_augment(DSAPriv, _tmp)
+_augment(KCDSAPriv, _tmp)
+
+###--------------------------------------------------------------------------
+### Bernstein's elliptic curve crypto and related schemes.
+
+X25519_BASE = \
+  bytes('0900000000000000000000000000000000000000000000000000000000000000')
+
+X448_BASE = \
+  bytes('05000000000000000000000000000000000000000000000000000000'
+        '00000000000000000000000000000000000000000000000000000000')
+
+Z128 = bytes('00000000000000000000000000000000')
+
+class _BoxyPub (object):
+  def __init__(me, pub, *kw, **kwargs):
+    if len(pub) != me._PUBSZ: raise ValueError, 'bad public key'
+    super(_BoxyPub, me).__init__(*kw, **kwargs)
+    me.pub = pub
+  def __repr__(me): return '%s(pub = %r)' % (_clsname(me), me.pub)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'pub', me.pub)
+    pp.end_group(ind, ')')
+
+class _BoxyPriv (_BoxyPub):
+  def __init__(me, priv, pub = None, *kw, **kwargs):
+    if len(priv) != me._KEYSZ: raise ValueError, 'bad private key'
+    if pub is None: pub = me._op(priv, me._BASE)
+    super(_BoxyPriv, me).__init__(pub = pub, *kw, **kwargs)
+    me.priv = priv
+  def agree(me, you): return me._op(me.priv, you.pub)
+  def boxkey(me, recip):
+    return me._hashkey(me.agree(recip))
+  def box(me, recip, n, m):
+    return secret_box(me.boxkey(recip), n, m)
+  def unbox(me, recip, n, c):
+    return secret_unbox(me.boxkey(recip, n, c))
+  def __repr__(me): return '%s(priv = %s, pub = %r)' % \
+      (_clsname(me), _repr_secret(me.priv), me.pub)
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup_tyname(pp, me)
+    if cyclep:
+      pp.text('...')
+    else:
+      _pp_kv(pp, 'priv', me.priv, True); pp.text(','); pp.breakable()
+      _pp_kv(pp, 'pub', me.pub)
+    pp.end_group(ind, ')')
+
+class X25519Pub (_BoxyPub):
+  _PUBSZ = X25519_PUBSZ
+  _BASE = X25519_BASE
+
+class X25519Priv (_BoxyPriv, X25519Pub):
+  _KEYSZ = X25519_KEYSZ
+  def _op(me, k, X): return x25519(k, X)
+  def _hashkey(me, z): return hsalsa20_prf(z, Z128)
+
+class X448Pub (_BoxyPub):
+  _PUBSZ = X448_PUBSZ
+  _BASE = X448_BASE
+
+class X448Priv (_BoxyPriv, X448Pub):
+  _KEYSZ = X448_KEYSZ
+  def _op(me, k, X): return x448(k, X)
+  ##def _hashkey(me, z): return ???
+
+class Ed25519Pub (object):
+  def __init__(me, pub):
+    me.pub = pub
+  def verify(me, msg, sig):
+    return ed25519_verify(me.pub, msg, sig)
+
+class Ed25519Priv (Ed25519Pub):
+  def __init__(me, priv):
+    me.priv = priv
+    Ed25519Pub.__init__(me, ed25519_pubkey(priv))
+  def sign(me, msg):
+    return ed25519_sign(me.priv, msg, pub = me.pub)
+  @classmethod
+  def generate(cls, rng = rand):
+    return cls(rng.block(ED25519_KEYSZ))
+
 ###--------------------------------------------------------------------------
 ### Built-in named curves and prime groups.
 
@@ -448,9 +823,17 @@ class _groupmap (object):
   def __init__(me, map, nth):
     me.map = map
     me.nth = nth
-    me.i = [None] * (max(map.values()) + 1)
+    me._n = max(map.values()) + 1
+    me.i = me._n*[None]
   def __repr__(me):
-    return '{%s}' % ', '.join(['%r: %r' % (k, me[k]) for k in me])
+    return '{%s}' % ', '.join(['%r: %r' % kv for kv in me.iteritems()])
+  def _repr_pretty_(me, pp, cyclep):
+    ind = _pp_bgroup(pp, '{ ')
+    if cyclep: pp.text('...')
+    else: _pp_dict(pp, me.iteritems())
+    pp.end_group(ind, ' }')
+  def __len__(me):
+    return me._n
   def __contains__(me, k):
     return k in me.map
   def __getitem__(me, k):