from binascii import hexlify as _hexify, unhexlify as _unhexify
from contextlib import contextmanager as _ctxmgr
-import DLFCN as _dlfcn
+try: import DLFCN as _dlfcn
+except ImportError: _dlfcn = None
import os as _os
from struct import pack as _pack
import sys as _sys
## For the benefit of the default keyreporter, we need the program name.
_base._ego(_sys.argv[0])
+## Register our module.
+_base._set_home_module(_sys.modules[__name__])
+def default_lostexchook(why, ty, val, tb):
+ """`catacomb.lostexchook(WHY, TY, VAL, TB)' reports lost exceptions."""
+ _sys.stderr.write("\n\n!!! LOST EXCEPTION: %s\n" % why)
+ _sys.excepthook(ty, val, tb)
+ _sys.stderr.write("\n")
+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()
+
## How to fix a name back into the right identifier. Alas, the rules are not
## consistent.
def _fixname(name):
name = name.replace('-', '_')
## But slashes might become underscores or just vanish.
- if name.startswith('salsa20'): name = name.translate(None, '/')
+ if name.startswith('salsa20'): name = name.replace('/', '')
else: name = name.replace('/', '_')
## Done.
for i in b:
if i[0] != '_':
d[i] = b[i];
- for i in ['ByteString',
- 'MP', 'GF', 'Field',
- 'ECPt', 'ECPtCurve', 'ECCurve', 'ECInfo',
- 'DHInfo', 'BinDHInfo', 'RSAPriv', 'BBSPriv',
- 'PrimeFilter', 'RabinMiller',
- 'Group', 'GE',
- 'KeySZ', 'KeyData']:
- c = d[i]
- pre = '_' + i + '_'
- plen = len(pre)
- for j in b:
- if j[:plen] == pre:
- setattr(c, j[plen:], classmethod(b[j]))
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()
def _checkend(r):
x, rest = r
if rest != '':
- raise SyntaxError, 'junk at end of string'
+ raise SyntaxError('junk at end of string')
return x
## Some pretty-printing utilities.
class _HashBase (object):
## The standard hash methods. Assume that `hash' is defined and returns
## the receiver.
- def hashu8(me, n): return me.hash(_pack('B', n))
- def hashu16l(me, n): return me.hash(_pack('<H', n))
- def hashu16b(me, n): return me.hash(_pack('>H', n))
+ def _check_range(me, n, max):
+ if not (0 <= n <= max): raise OverflowError("out of range")
+ def hashu8(me, n):
+ me._check_range(n, 0xff)
+ return me.hash(_pack('B', n))
+ def hashu16l(me, n):
+ me._check_range(n, 0xffff)
+ return me.hash(_pack('<H', n))
+ def hashu16b(me, n):
+ me._check_range(n, 0xffff)
+ return me.hash(_pack('>H', n))
hashu16 = hashu16b
- def hashu32l(me, n): return me.hash(_pack('<L', n))
- def hashu32b(me, n): return me.hash(_pack('>L', n))
+ def hashu32l(me, n):
+ me._check_range(n, 0xffffffff)
+ return me.hash(_pack('<L', n))
+ def hashu32b(me, n):
+ me._check_range(n, 0xffffffff)
+ return me.hash(_pack('>L', n))
hashu32 = hashu32b
- def hashu64l(me, n): return me.hash(_pack('<Q', n))
- def hashu64b(me, n): return me.hash(_pack('>Q', n))
+ def hashu64l(me, n):
+ me._check_range(n, 0xffffffffffffffff)
+ return me.hash(_pack('<Q', n))
+ def hashu64b(me, n):
+ me._check_range(n, 0xffffffffffffffff)
+ return me.hash(_pack('>Q', n))
hashu64 = hashu64b
def hashbuf8(me, s): return me.hashu8(len(s)).hash(s)
def hashbuf16l(me, s): return me.hashu16l(len(s)).hash(s)
## Python gets really confused if I try to augment `__new__' on native
## classes, so wrap and delegate. Sorry.
- def __init__(me, perso = '', *args, **kw):
+ def __init__(me, perso = _bin(''), *args, **kw):
super(_ShakeBase, me).__init__(*args, **kw)
me._h = me._SHAKE(perso = perso, func = me._FUNC)
## Delegate methods...
- def copy(me): new = me.__class__(); new._copy(me)
- def _copy(me, other): me._h = other._h
+ def copy(me): new = me.__class__._bare_new(); new._copy(me); return new
+ def _copy(me, other): me._h = other._h.copy()
def hash(me, m): me._h.hash(m); return me
def xof(me): me._h.xof(); return me
def get(me, n): return me._h.get(n)
def buffered(me): return me._h.buffered
@property
def rate(me): return me._h.rate
+ @classmethod
+ def _bare_new(cls): return cls()
class _tmp:
def check(me, h):
Shake._Z = _ShakeBase._Z = ByteString.zero(200)
class KMAC (_ShakeBase):
- _FUNC = 'KMAC'
+ _FUNC = _bin('KMAC')
def __init__(me, k, *arg, **kw):
super(KMAC, me).__init__(*arg, **kw)
with me.bytepad(): me.stringenc(k)
def xof(me):
me.rightenc(0)
return super(KMAC, me).xof()
+ @classmethod
+ def _bare_new(cls): return cls(_bin(""))
class KMAC128 (KMAC): _SHAKE = Shake128; _TAGSZ = 16
class KMAC256 (KMAC): _SHAKE = Shake256; _TAGSZ = 32
def __mul__(me, you):
n, d = _split_rat(you)
return type(me)(me._n*n, me._d*d)
- def __div__(me, you):
+ __rmul__ = __mul__
+ def __truediv__(me, you):
n, d = _split_rat(you)
return type(me)(me._n*d, me._d*n)
- def __rdiv__(me, you):
+ def __rtruediv__(me, you):
n, d = _split_rat(you)
return type(me)(me._d*n, me._n*d)
+ __div__ = __truediv__
+ __rdiv__ = __rtruediv__
def __cmp__(me, you):
n, d = _split_rat(you)
- return type(me)(me._n*d, n*me._d)
+ return cmp(me._n*d, n*me._d)
def __rcmp__(me, you):
n, d = _split_rat(you)
return cmp(n*me._d, me._n*d)
def mont(x): return MPMont(x)
def barrett(x): return MPBarrett(x)
def reduce(x): return MPReduce(x)
- def __div__(me, you): return IntRat(me, you)
- def __rdiv__(me, you): return IntRat(you, me)
+ def __truediv__(me, you): return IntRat(me, you)
+ def __rtruediv__(me, you): return IntRat(you, me)
+ __div__ = __truediv__
+ __rdiv__ = __rtruediv__
_repr_pretty_ = _pp_str
_augment(MP, _tmp)
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)
- def __div__(me, you): return GFRat(me, you)
- def __rdiv__(me, you): return GFRat(you, me)
+ def __truediv__(me, you): return GFRat(me, you)
+ def __rtruediv__(me, you): return GFRat(you, me)
+ __div__ = __truediv__
+ __rdiv__ = __rtruediv__
_repr_pretty_ = _pp_str
_augment(GF, _tmp)
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'
+ if sz < me.min: raise ValueError('key too small')
elif sz > me.max: return me.max
else: return sz - sz%me.mod
def pad(me, sz):
- if sz > me.max: raise ValueError, 'key too large'
+ if sz > me.max: raise ValueError('key too large')
elif sz < me.min: return me.min
- else: sz += me.mod; return sz - sz%me.mod
+ else: sz += me.mod - 1; return sz - sz%me.mod
_augment(KeySZRange, _tmp)
class _tmp:
found = -1
for i in me.set:
if found < i <= sz: found = i
- if found < 0: raise ValueError, 'key too small'
+ if found < 0: raise ValueError('key too small')
return found
def pad(me, sz):
found = -1
for i in me.set:
if sz <= i and (found == -1 or i < found): found = i
- if found < 0: raise ValueError, 'key too large'
+ if found < 0: raise ValueError('key too large')
return found
_augment(KeySZSet, _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)
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(KeyDataStructured, _tmp)
### RSA encoding techniques.
class PKCS1Crypt (object):
- def __init__(me, ep = '', rng = rand):
+ def __init__(me, ep = _bin(''), rng = rand):
me.ep = ep
me.rng = rng
def encode(me, msg, nbits):
return _base._p1crypt_decode(ct, nbits, me.ep, me.rng)
class PKCS1Sig (object):
- def __init__(me, ep = '', rng = rand):
+ def __init__(me, ep = _bin(''), rng = rand):
me.ep = ep
me.rng = rng
def encode(me, msg, nbits):
return _base._p1sig_decode(msg, sig, nbits, me.ep, me.rng)
class OAEP (object):
- def __init__(me, mgf = sha_mgf, hash = sha, ep = '', rng = rand):
+ def __init__(me, mgf = sha_mgf, hash = sha, ep = _bin(''), rng = rand):
me.mgf = mgf
me.hash = hash
me.ep = ep
class _BasePub (object):
def __init__(me, pub, *args, **kw):
- if not me._PUBSZ.check(len(pub)): raise ValueError, 'bad public key'
+ if not me._PUBSZ.check(len(pub)): raise ValueError('bad public key')
super(_BasePub, me).__init__(*args, **kw)
me.pub = pub
def __repr__(me): return '%s(pub = %r)' % (_clsname(me), me.pub)
class _BasePriv (object):
def __init__(me, priv, pub = None, *args, **kw):
- if not me._KEYSZ.check(len(priv)): raise ValueError, 'bad private key'
+ if not me._KEYSZ.check(len(priv)): raise ValueError('bad private key')
if pub is None: pub = me._pubkey(priv)
super(_BasePriv, me).__init__(pub = pub, *args, **kw)
me.priv = priv
return ed448_sign(me.priv, msg, pub = me.pub, **kw)
###--------------------------------------------------------------------------
-### Built-in named curves and prime groups.
-
-class _groupmap (object):
- def __init__(me, map, nth):
- me.map = map
- me.nth = nth
- me._n = max(map.values()) + 1
- me.i = me._n*[None]
+### Built-in algorithm and group tables.
+
+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, ' }')
- def __len__(me):
- return me._n
- def __contains__(me, k):
- return k in me.map
- def __getitem__(me, k):
- i = me.map[k]
- if me.i[i] is None:
- me.i[i] = me.nth(i)
- return me.i[i]
- def __setitem__(me, k, v):
- 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)
+_augment(_base._MiscTable, _tmp)
###--------------------------------------------------------------------------
### Prime number generation.
me.add = add
def _stepfn(me, step):
if step <= 0:
- raise ValueError, 'step must be positive'
+ raise ValueError('step must be positive')
if step <= MPW_MAX:
return lambda f: f.step(step)
j = PrimeFilter(step)
~mdw / catacomb-python / blobdiff