### along with Catacomb/Python; if not, write to the Free Software Foundation,
### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-import _base
-import types as _types
+from __future__ import with_statement
+
from binascii import hexlify as _hexify, unhexlify as _unhexify
-from sys import argv as _argv
+from contextlib import contextmanager as _ctxmgr
+try: import DLFCN as _dlfcn
+except ImportError: _dlfcn = None
+import os as _os
+from struct import pack as _pack
+import sys as _sys
+import types as _types
+
+###--------------------------------------------------------------------------
+### Import the main C extension module.
+
+try:
+ _dlflags = _odlflags = _sys.getdlopenflags()
+except AttributeError:
+ _dlflags = _odlflags = -1
+
+## Set the `deep binding' flag. Python has its own different MD5
+## implementation, and some distributions export `md5_init' and friends so
+## they override our versions, which doesn't end well. Figure out how to
+## turn this flag on so we don't have the problem.
+if _dlflags >= 0:
+ try: _dlflags |= _dlfcn.RTLD_DEEPBIND
+ except AttributeError:
+ try: _dlflags |= _os.RTLD_DEEPBIND
+ except AttributeError:
+ if _os.uname()[0] == 'Linux': _dlflags |= 8 # magic knowledge
+ else: pass # can't do this.
+ _sys.setdlopenflags(_dlflags)
+
+if _sys.version_info >= (3,): from . import _base
+else: import _base
+
+if _odlflags >= 0:
+ _sys.setdlopenflags(_odlflags)
+
+del _dlflags, _odlflags
###--------------------------------------------------------------------------
### Basic stuff.
-## For the benefit of the default keyreporter, we need the program na,e.
-_base._ego(_argv[0])
+## 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.
+if _sys.version_info >= (3,):
+ def _bin(s): return s.encode('iso8859-1')
+else:
+ def _bin(s): return s
+
+## Iterating over dictionaries.
+if _sys.version_info >= (3,):
+ def _iteritems(dict): return dict.items()
+ def _itervalues(dict): return dict.values()
+else:
+ def _iteritems(dict): return dict.iteritems()
+ def _itervalues(dict): return dict.itervalues()
+
+## The built-in bignum type.
+try: long
+except NameError: _long = int
+else: _long = long
+
+## How to fix a name back into the right identifier. Alas, the rules are not
+## consistent.
+def _fixname(name):
+
+ ## Hyphens consistently become underscores.
+ name = name.replace('-', '_')
+
+ ## But slashes might become underscores or just vanish.
+ if name.startswith('salsa20'): name = name.replace('/', '')
+ else: name = name.replace('/', '_')
+
+ ## Done.
+ return name
## Initialize the module. Drag in the static methods of the various
## classes; create names for the various known crypto algorithms.
for i in b:
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',
- '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, gchashes, gcmacs, gcprps]:
- for c in i.itervalues():
- d[c.name.replace('-', '_').translate(None, '/')] = c
- for c in gccrands.itervalues():
- d[c.name.replace('-', '_').translate(None, '/') + 'rand'] = c
+ for i in [gcciphers, gcaeads, gchashes, gcmacs, gcprps]:
+ for c in _itervalues(i):
+ d[_fixname(c.name)] = c
+ for c in _itervalues(gccrands):
+ d[_fixname(c.name + 'rand')] = c
_init()
## A handy function for our work: add the methods of a named class to an
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.
+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_kv(pp, k, v):
- ind = len(k) + 3
- pp.begin_group(ind, k + ' = ')
- pp.pretty(v)
+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
else: pp.text(','); pp.breakable()
printfn(i)
def _pp_dict(pp, items):
- def p((k, v)):
- pp.begin_group(0, '')
+ def p(kv):
+ k, v = kv
+ pp.begin_group(0)
pp.pretty(k)
pp.text(':')
- pp.begin_group(2, '')
+ pp.begin_group(2)
pp.breakable()
pp.pretty(v)
- pp.end_group(2, '')
- pp.end_group(0, '')
+ pp.end_group(2)
+ pp.end_group(0)
_pp_commas(pp, p, items)
###--------------------------------------------------------------------------
+### Mappings.
+
+if _sys.version_info >= (3,):
+ class _tmp:
+ def __str__(me): return '%s(%r)' % (type(me).__name__, list(me))
+ __repr__ = __str__
+ def _repr_pretty_(me, pp, cyclep):
+ ind = _pp_bgroup_tyname(pp, me, '([')
+ _pp_commas(pp, pp.pretty, me)
+ pp.end_group(ind, '])')
+ _augment(_base._KeyView, _tmp)
+ _augment(_base._ValueView, _tmp)
+ _augment(_base._ItemView, _tmp)
+
+###--------------------------------------------------------------------------
### Bytestrings.
class _tmp:
def fromhex(x):
return ByteString(_unhexify(x))
fromhex = staticmethod(fromhex)
- def __hex__(me):
- return _hexify(me)
+ if _sys.version_info >= (3,):
+ def hex(me): return _hexify(me).decode()
+ else:
+ 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
###--------------------------------------------------------------------------
+### Symmetric encryption.
+
+class _tmp:
+ 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
+ else: a = e.aad().hash(h)
+ c0 = e.encrypt(m)
+ c1, t = e.done(aad = a)
+ return c0 + c1, t
+ 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)
+ m = d.decrypt(c)
+ m += d.done(t, aad = a)
+ return m
+_augment(GAEKey, _tmp)
+
+###--------------------------------------------------------------------------
### Hashing.
class _tmp:
_augment(GHash, _tmp)
_augment(Poly1305Hash, _tmp)
+class _tmp:
+ def check(me, h):
+ return ctstreq(h, me.done(len(h)))
+_augment(Shake, _tmp)
+
+KMAC128.keysz = KeySZAny(16); KMAC128.tagsz = 16
+KMAC256.keysz = KeySZAny(32); KMAC256.tagsz = 32
+
###--------------------------------------------------------------------------
### 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)
+ y, t = salsa20_naclbox(k).encrypt(n, m)
+ return 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:])
+ tsz = poly1305.tagsz
+ return salsa20_naclbox(k).decrypt(n, c[tsz:], c[0:tsz])
###--------------------------------------------------------------------------
### Multiprecision integers and binary polynomials.
-def _split_rat(x):
- if isinstance(x, BaseRat): return x._n, x._d
- else: return x, 1
class BaseRat (object):
"""Base class implementing fields of fractions over Euclidean domains."""
def __new__(cls, a, b):
- a, b = cls.RING(a), cls.RING(b)
+ a, b = cls.RING._implicit(a), cls.RING._implicit(b)
q, r = divmod(a, b)
- if r == 0: return q
+ if r == cls.ZERO: return q
g = b.gcd(r)
me = super(BaseRat, cls).__new__(cls)
me._n = a//g
@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 _split_rat(me, x):
+ if isinstance(x, me.__class__): return x._n, x._d
+ else: return x, me.ONE
def __add__(me, you):
- n, d = _split_rat(you)
+ n, d = me._split_rat(you)
return type(me)(me._n*d + n*me._d, d*me._d)
__radd__ = __add__
def __sub__(me, you):
- n, d = _split_rat(you)
+ n, d = me._split_rat(you)
return type(me)(me._n*d - n*me._d, d*me._d)
def __rsub__(me, you):
- n, d = _split_rat(you)
+ n, d = me._split_rat(you)
return type(me)(n*me._d - me._n*d, d*me._d)
def __mul__(me, you):
- n, d = _split_rat(you)
+ n, d = me._split_rat(you)
return type(me)(me._n*n, me._d*d)
- def __div__(me, you):
- n, d = _split_rat(you)
+ __rmul__ = __mul__
+ def __truediv__(me, you):
+ n, d = me._split_rat(you)
return type(me)(me._n*d, me._d*n)
- def __rdiv__(me, you):
- n, d = _split_rat(you)
+ def __rtruediv__(me, you):
+ n, d = me._split_rat(you)
return type(me)(me._d*n, me._n*d)
- def __cmp__(me, you):
- n, d = _split_rat(you)
- return type(me)(me._n*d, n*me._d)
- def __rcmp__(me, you):
- n, d = _split_rat(you)
- return cmp(n*me._d, me._n*d)
+ if _sys.version_info < (3,):
+ __div__ = __truediv__
+ __rdiv__ = __rtruediv__
+ def _order(me, you, op):
+ n, d = me._split_rat(you)
+ 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
+ ZERO, ONE = MP(0), MP(1)
+ 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
+ ZERO, ONE = GF(0), GF(1)
class _tmp:
def negp(x): return x < 0
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):
+ 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)
+ if _sys.version_info < (3,):
+ __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)
+ if _sys.version_info < (3,):
+ __div__ = __truediv__
+ __rdiv__ = __rtruediv__
_repr_pretty_ = _pp_str
_augment(GF, _tmp)
_augment(Field, _tmp)
class _tmp:
- def __repr__(me): return '%s(%sL)' % (type(me).__name__, 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):
- tyname = type(me).__name__
- if cyclep:
- pp.text(tyname + '(...)')
- else:
- ind = len(tyname) + 1
- pp.begin_group(ind, tyname + '(')
- pp.pretty(me.p)
- pp.end_group(ind, ')')
+ 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(%#xL)' % (type(me).__name__, 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):
- tyname = type(me).__name__
- if cyclep:
- pp.text(tyname + '(...)')
- else:
- ind = len(tyname) + 1
- pp.begin_group(ind, tyname + '(')
- pp.text('%#x' % me.p)
- pp.end_group(ind, ')')
+ 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:
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):
- tyname = type(me).__name__
+ ind = _pp_bgroup_tyname(pp, me)
if cyclep:
- pp.text(tyname + '(...)')
+ pp.text('...')
else:
- ind = len(tyname) + 1
- pp.begin_group(ind, tyname + '(')
pp.pretty(me.field); pp.text(','); pp.breakable()
pp.pretty(me.a); pp.text(','); pp.breakable()
pp.pretty(me.b)
- pp.end_group(ind, ')')
+ pp.end_group(ind, ')')
+ def fromstring(str): return _checkend(ECCurve.parse(str))
+ fromstring = staticmethod(fromstring)
def frombuf(me, s):
return ecpt.frombuf(me, s)
def fromraw(me, s):
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)
elif not me:
pp.text('inf')
else:
- pp.begin_group(1, '(')
+ ind = _pp_bgroup(pp, '(')
pp.pretty(me.ix); pp.text(','); pp.breakable()
pp.pretty(me.iy)
- pp.end_group(1, ')')
+ 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('ECInfo(...)')
+ pp.text('...')
else:
- pp.begin_group(7, 'ECInfo(')
_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(7, ')')
+ pp.end_group(ind, ')')
def __hash__(me):
h = 0x9bedb8de
h ^= hash(me.curve)
h ^= 2*hash(me.G) & 0xffffffff
return h
+ def fromstring(str): return _checkend(ECInfo.parse(str))
+ fromstring = staticmethod(fromstring)
def group(me):
return ECGroup(me)
_augment(ECInfo, _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
+ def pad(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('KeySZRange(...)')
+ pp.text('...')
else:
- pp.begin_group(11, 'KeySZRange(')
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(11, ')')
- def check(me, sz): return me.min <= sz <= me.max and sz % me.mod == 0
+ 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'
- elif sz > me.max: return me.max
- else: return sz - (sz % me.mod)
+ if sz < me.min: raise ValueError('key too small')
+ elif me.max is not None and sz > me.max: return me.max
+ else: return sz - sz%me.mod
+ def pad(me, sz):
+ if me.max is not None and sz > me.max: raise ValueError('key too large')
+ elif sz < me.min: return me.min
+ else: sz += me.mod - 1; return sz - sz%me.mod
_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('KeySZSet(...)')
+ pp.text('...')
else:
- pp.begin_group(9, 'KeySZSet(')
pp.pretty(me.default); pp.text(','); pp.breakable()
- pp.begin_group(1, '{')
+ ind1 = _pp_bgroup(pp, '{')
_pp_commas(pp, pp.pretty, me.set)
- pp.end_group(1, '}')
- pp.end_group(9, ')')
+ pp.end_group(ind1, '}')
+ pp.end_group(ind, ')')
def check(me, sz): return sz in me.set
def best(me, sz):
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')
return found
_augment(KeySZSet, _tmp)
### Key data objects.
class _tmp:
- def __repr__(me): return 'KeyFile(%r)' % me.name
+ 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 __repr__(me): return 'Key(%r)' % me.fulltag
+ 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 'KeyAttributes({%s})' % \
- ', '.join(['%r: %r' % kv for kv in me.iteritems()])
+ return '%s({%s})' % (_clsname(me),
+ ', '.join(['%r: %r' % kv for kv in _iteritems(me)()]))
def _repr_pretty_(me, pp, cyclep):
- pp.begin_group(14, 'KeyAttributes(')
+ ind = _pp_bgroup_tyname(pp, me)
if cyclep: pp.text('...')
- else: _pp_dict(pp, me.iteritems())
- pp.end_group(14, ')')
+ else: _pp_dict(pp, _iteritems(me))
+ pp.end_group(ind, ')')
_augment(KeyAttributes, _tmp)
class _tmp:
- def __repr__(me): return 'KeyDataBinary(%r, %r)' % \
- (me.bin, me.writeflags(me.flags))
+ 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):
- pp.begin_group(14, 'KeyDataBinary(')
+ ind = _pp_bgroup_tyname(pp, me)
if cyclep:
- pp.text('KeyDataBinary(...)')
+ pp.text('...')
else:
- pp.pretty(me.bin); pp.text(','); pp.breakable()
+ _pp_secret(pp, me._guts(), not (me.flags & KF_NONSECRET))
+ pp.text(','); pp.breakable()
pp.pretty(me.writeflags(me.flags))
- pp.end_group(14, ')')
+ 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 __repr__(me): return 'KeyDataEncrypted(%r, %r)' % \
- (me.ct, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- pp.begin_group(17, 'KeyDataEncrypted(')
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.ct); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(17, ')')
+ def _guts(me): return me.ct
_augment(KeyDataEncrypted, _tmp)
+KeyDataEncrypted._HASHBASE = 0xffe000d4
class _tmp:
- def __repr__(me): return 'KeyDataMP(%r, %r)' % \
- (me.mp, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- pp.begin_group(10, 'KeyDataMP(')
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.mp); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(10, ')')
+ def _guts(me): return me.mp
_augment(KeyDataMP, _tmp)
+KeyDataMP._HASHBASE = 0x1cb64d69
class _tmp:
- def __repr__(me): return 'KeyDataString(%r)' % \
- (me.str, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- pp.begin_group(14, 'KeyDataString(')
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.str); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(14, ')')
+ def _guts(me): return me.str
_augment(KeyDataString, _tmp)
+KeyDataString._HASHBASE = 0x349c33ea
class _tmp:
- def __repr__(me): return 'KeyDataECPt(%r)' % \
- (me.ecpt, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- pp.begin_group(12, 'KeyDataECPt(')
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.ecpt); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(12, ')')
+ def _guts(me): return me.ecpt
_augment(KeyDataECPt, _tmp)
+KeyDataECPt._HASHBASE = 0x2509718b
class _tmp:
def __repr__(me):
- return 'KeyDataStructured({%s})' % \
- ', '.join(['%r: %r' % kv for kv in me.iteritems()])
+ return '%s({%s})' % (_clsname(me),
+ ', '.join(['%r: %r' % kv for kv in _iteritems(me)]))
def _repr_pretty_(me, pp, cyclep):
- pp.begin_group(20, 'KeyDataStructured({ ')
+ ind = _pp_bgroup_tyname(pp, me, '({ ')
if cyclep: pp.text('...')
- else: _pp_dict(pp, me.iteritems())
- pp.end_group(20, ' })')
+ 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.
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):
- tyname = type(me).__name__
+ ind = _pp_bgroup_tyname(pp, me)
if cyclep:
- pp.text(tyname + '(...)')
+ pp.text('...')
else:
- ind = len(tyname) + 1
- pp.begin_group(ind, tyname + '(')
_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, ')')
+ pp.end_group(ind, ')')
_augment(FGInfo, _tmp)
class _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:
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:
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))
- _repr_pretty_ = _pp_str
+ def _repr_pretty_(me, pp, cyclep):
+ pp.pretty(type(me)._get_geval(me))
_augment(GE, _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
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)
###--------------------------------------------------------------------------
-### Bernstein's elliptic curve crypto and related schemes.
+### DSA and related schemes.
-X25519_BASE = \
- bytes('0900000000000000000000000000000000000000000000000000000000000000')
+class _tmp:
+ def __repr__(me): return '%s(G = %r, p = %r, hash = %r)' % \
+ (_clsname(me), me.G, me.p, me.hash)
+ 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.text(','); pp.breakable()
+ _pp_kv(pp, 'hash', me.hash)
+ pp.end_group(ind, ')')
+_augment(DSAPub, _tmp)
+_augment(KCDSAPub, _tmp)
-X448_BASE = \
- bytes('05000000000000000000000000000000000000000000000000000000'
- '00000000000000000000000000000000000000000000000000000000')
+class _tmp:
+ def __repr__(me): return '%s(G = %r, u = %s, p = %r, hash = %r)' % \
+ (_clsname(me), me.G, _repr_secret(me.u), me.p, me.hash)
+ 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.text(','); pp.breakable()
+ _pp_kv(pp, 'hash', me.hash)
+ pp.end_group(ind, ')')
+_augment(DSAPriv, _tmp)
+_augment(KCDSAPriv, _tmp)
+
+###--------------------------------------------------------------------------
+### Bernstein's elliptic curve crypto and related schemes.
-Z128 = bytes('00000000000000000000000000000000')
+X25519_BASE = MP(9).storel(32)
+X448_BASE = MP(5).storel(56)
-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
+Z128 = ByteString.zero(16)
-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)
+class _BasePub (object):
+ def __init__(me, pub, *args, **kw):
+ 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)
+ def _pp(me, pp): _pp_kv(pp, 'pub', me.pub)
+ def _repr_pretty_(me, pp, cyclep):
+ ind = _pp_bgroup_tyname(pp, me)
+ if cyclep: pp.text('...')
+ else: me._pp(pp)
+ pp.end_group(ind, ')')
+
+class _BasePriv (object):
+ def __init__(me, priv, pub = None, *args, **kw):
+ 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
+ @classmethod
+ def generate(cls, rng = rand):
+ return cls(rng.block(cls._KEYSZ.default))
+ def __repr__(me):
+ return '%s(priv = %d, pub = %r)' % \
+ (_clsname(me), _repr_secret(me.priv), me.pub)
+ def _pp(me, pp):
+ _pp_kv(pp, 'priv', me.priv, secretp = True); pp.text(','); pp.breakable()
+ super(_BasePriv, me)._pp(pp)
+
+class _XDHPub (_BasePub): pass
+
+class _XDHPriv (_BasePriv):
+ def _pubkey(me, priv): return me._op(priv, me._BASE)
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))
-
-class X25519Pub (_BoxyPub):
- _PUBSZ = X25519_PUBSZ
+ 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)
+
+class X25519Pub (_XDHPub):
+ _PUBSZ = KeySZSet(X25519_PUBSZ)
_BASE = X25519_BASE
-class X25519Priv (_BoxyPriv, X25519Pub):
- _KEYSZ = X25519_KEYSZ
+class X25519Priv (_XDHPriv, X25519Pub):
+ _KEYSZ = KeySZSet(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
+class X448Pub (_XDHPub):
+ _PUBSZ = KeySZSet(X448_PUBSZ)
_BASE = X448_BASE
-class X448Priv (_BoxyPriv, X448Pub):
- _KEYSZ = X448_KEYSZ
+class X448Priv (_XDHPriv, X448Pub):
+ _KEYSZ = KeySZSet(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))
+ def _hashkey(me, z): return Shake256().hash(z).done(salsa20.keysz.default)
+
+class _EdDSAPub (_BasePub):
+ def beginhash(me): return me._HASH()
+ def endhash(me, h): return h.done()
+
+class _EdDSAPriv (_BasePriv, _EdDSAPub):
+ pass
+
+class Ed25519Pub (_EdDSAPub):
+ _PUBSZ = KeySZSet(ED25519_PUBSZ)
+ _HASH = sha512
+ def verify(me, msg, sig, **kw):
+ return ed25519_verify(me.pub, msg, sig, **kw)
+
+class Ed25519Priv (_EdDSAPriv, Ed25519Pub):
+ _KEYSZ = KeySZAny(ED25519_KEYSZ)
+ def _pubkey(me, priv): return ed25519_pubkey(priv)
+ def sign(me, msg, **kw):
+ return ed25519_sign(me.priv, msg, pub = me.pub, **kw)
+
+class Ed448Pub (_EdDSAPub):
+ _PUBSZ = KeySZSet(ED448_PUBSZ)
+ _HASH = shake256
+ def verify(me, msg, sig, **kw):
+ return ed448_verify(me.pub, msg, sig, **kw)
+
+class Ed448Priv (_EdDSAPriv, Ed448Pub):
+ _KEYSZ = KeySZAny(ED448_KEYSZ)
+ def _pubkey(me, priv): return ed448_pubkey(priv)
+ def sign(me, msg, **kw):
+ 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):
- if cyclep:
- pp.text('{ ... }')
- else:
- pp.begin_group(2, '{ ')
- _pp_dict(pp, me.iteritems())
- pp.end_group(2, ' }')
- 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)
+ ind = _pp_bgroup(pp, '{ ')
+ if cyclep: pp.text('...')
+ else: _pp_dict(pp, _iteritems(me))
+ pp.end_group(ind, ' }')
+_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)