## For the benefit of the default keyreporter, we need the program na,e.
_base._ego(_argv[0])
+## 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.translate(None, '/')
+ 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.
def _init():
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
+ d[_fixname(c.name)] = c
for c in gccrands.itervalues():
- d[c.name.replace('-', '_').translate(None, '/') + 'rand'] = c
+ d[_fixname(c.name + 'rand')] = c
_init()
## A handy function for our work: add the methods of a named class to an
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, type(obj).__name__ + open)
-def _pp_kv(pp, k, v):
+ return _pp_bgroup(pp, _clsname(obj) + open)
+def _pp_kv(pp, k, v, secretp = False):
ind = _pp_bgroup(pp, k + ' = ')
- pp.pretty(v)
+ _pp_secret(pp, v, secretp)
pp.end_group(ind, '')
def _pp_commas(pp, printfn, items):
firstp = True
@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):
_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)
_augment(PrimeField, _tmp)
class _tmp:
- def __repr__(me): return '%s(%#xL)' % (type(me).__name__, 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)
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:
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)
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:
### 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:
_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:
### Key data objects.
class _tmp:
- def __repr__(me): return 'KeyFile(%r)' % me.name
+ def __repr__(me): return '%s(%r)' % (_clsname(me), me.name)
_augment(KeyFile, _tmp)
class _tmp:
- def __repr__(me): return 'Key(%r)' % me.fulltag
+ 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 me.iteritems()]))
def _repr_pretty_(me, pp, cyclep):
ind = _pp_bgroup_tyname(pp, me)
if cyclep: pp.text('...')
_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):
ind = _pp_bgroup_tyname(pp, me)
if cyclep:
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(ind, ')')
+_augment(KeyData, _tmp)
+
+class _tmp:
+ def _guts(me): return me.bin
_augment(KeyDataBinary, _tmp)
class _tmp:
- def __repr__(me): return 'KeyDataEncrypted(%r, %r)' % \
- (me.ct, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- ind = _pp_bgroup_tyname(pp, me)
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.ct); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(ind, ')')
+ def _guts(me): return me.ct
_augment(KeyDataEncrypted, _tmp)
class _tmp:
- def __repr__(me): return 'KeyDataMP(%r, %r)' % \
- (me.mp, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- ind = _pp_bgroup_tyname(pp, me)
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.mp); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(ind, ')')
+ def _guts(me): return me.mp
_augment(KeyDataMP, _tmp)
class _tmp:
- def __repr__(me): return 'KeyDataString(%r)' % \
- (me.str, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- ind = _pp_bgroup_tyname(pp, me)
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.str); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(ind, ')')
+ def _guts(me): return me.str
_augment(KeyDataString, _tmp)
class _tmp:
- def __repr__(me): return 'KeyDataECPt(%r)' % \
- (me.ecpt, me.writeflags(me.flags))
- def _repr_pretty_(me, pp, cyclep):
- ind = _pp_bgroup_tyname(pp, me)
- if cyclep:
- pp.text('...')
- else:
- pp.pretty(me.ecpt); pp.text(','); pp.breakable()
- pp.pretty(me.writeflags(me.flags))
- pp.end_group(ind, ')')
+ def _guts(me): return me.ecpt
_augment(KeyDataECPt, _tmp)
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 me.iteritems()]))
def _repr_pretty_(me, pp, cyclep):
ind = _pp_bgroup_tyname(pp, me, '({ ')
if cyclep: pp.text('...')
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:
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('...')
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)
###--------------------------------------------------------------------------
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.
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):
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))
+ 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
~mdw / catacomb-python / blobdiff