X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/d7ab1bab81155baa763449d5afa81e16df98dbe7..96851f5db8542a4630aaa9b0dbe7cb0495b5ab8b:/catacomb/__init__.py diff --git a/catacomb/__init__.py b/catacomb/__init__.py index b7f40fa..aaec637 100644 --- a/catacomb/__init__.py +++ b/catacomb/__init__.py @@ -15,20 +15,30 @@ # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. -# +# # Catacomb/Python is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. -# +# # You should have received a copy of the GNU General Public License # along with Catacomb/Python; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +#----- Imports -------------------------------------------------------------- + import _base import types as _types from binascii import hexlify as _hexify, unhexlify as _unhexify +from sys import argv as _argv +#----- Basic stuff ---------------------------------------------------------- + +## For the benefit of the default keyreporter, we need the program na,e. +_base._ego(_argv[0]) + +## Initialize the module. Drag in the static methods of the various +## classes; create names for the various known crypto algorithms. def _init(): d = globals() b = _base.__dict__; @@ -36,21 +46,27 @@ def _init(): if i[0] != '_': d[i] = b[i]; for i in ['MP', 'GF', 'Field', - 'ECPt', 'ECPtCurve', 'ECCurve', 'ECInfo', - 'DHInfo', 'BinDHInfo', 'RSAPriv', 'PrimeFilter', 'RabinMiller', - 'Group', 'GE']: + 'ECPt', 'ECPtCurve', 'ECCurve', 'ECInfo', + 'DHInfo', 'BinDHInfo', 'RSAPriv', 'BBSPriv', + 'PrimeFilter', 'RabinMiller', + 'Group', 'GE', + '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]: - for j in i: - c = i[j] + setattr(c, j[plen:], classmethod(b[j])) + for i in [gcciphers, gchashes, gcmacs, gcprps]: + for c in i.itervalues(): d[c.name.replace('-', '_')] = c + for c in gccrands.itervalues(): + d[c.name.replace('-', '_') + 'rand'] = c _init() +## A handy function for our work: add the methods of a named class to an +## existing class. This is how we write the Python-implemented parts of our +## mostly-C types. def _augment(c, cc): for i in cc.__dict__: a = cc.__dict__[i] @@ -60,6 +76,17 @@ def _augment(c, cc): continue setattr(c, i, a) +## Parsing functions tend to return the object parsed and the remainder of +## the input. This checks that the remainder is input and, if so, returns +## just the object. +def _checkend(r): + x, rest = r + if rest != '': + raise SyntaxError, 'junk at end of string' + return x + +#----- Bytestrings ---------------------------------------------------------- + class _tmp: def fromhex(x): return ByteString(_unhexify(x)) @@ -71,6 +98,8 @@ class _tmp: _augment(ByteString, _tmp) bytes = ByteString.fromhex +#----- Multiprecision integers and binary polynomials ----------------------- + class _tmp: def negp(x): return x < 0 def posp(x): return x > 0 @@ -83,21 +112,29 @@ class _tmp: def factorial(x): 'factorial(X) -> X!' if x < 0: raise ValueError, 'factorial argument must be > 0' - return MP.product(xrange(1, x + 1)) + return MPMul.product(xrange(1, x + 1)) factorial = staticmethod(factorial) _augment(MP, _tmp) -def _checkend(r): - x, rest = r - if rest != '': - raise SyntaxError, 'junk at end of string' - return x - class _tmp: - def reduce(x): return GReduce(x) + def zerop(x): return x == 0 + def reduce(x): return GFReduce(x) + def trace(x, y): return x.reduce().trace(y) + 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) _augment(GF, _tmp) class _tmp: + def product(*arg): + 'product(ITERABLE) or product(I, ...) -> PRODUCT' + return MPMul(*arg).done() + product = staticmethod(product) +_augment(MPMul, _tmp) + +#----- Abstract fields ------------------------------------------------------ + +class _tmp: def fromstring(str): return _checkend(Field.parse(str)) fromstring = staticmethod(fromstring) _augment(Field, _tmp) @@ -117,27 +154,7 @@ class _tmp: def __repr__(me): return '%s(%s)' % (repr(me.field), repr(me.value)) _augment(FE, _tmp) -class _groupmap (object): - def __init__(me, map, nth): - me.map = map - me.nth = nth - me.i = [None] * (max(map.values()) + 1) - def __repr__(me): - return '{%s}' % ', '.join(['%r: %r' % (k, me[k]) for k in me]) - 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) -eccurves = _groupmap(_base._eccurves, ECInfo._curven) -primegroups = _groupmap(_base._pgroups, DHInfo._groupn) -bingroups = _groupmap(_base._bingroups, BinDHInfo._groupn) +#----- Elliptic curves ------------------------------------------------------ class _tmp: def __repr__(me): @@ -147,7 +164,7 @@ class _tmp: def fromraw(me, s): return ecpt.fromraw(me, s) def pt(me, *args): - return ECPt(me, *args) + return me(*args) _augment(ECCurve, _tmp) class _tmp: @@ -162,7 +179,7 @@ _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) + (me.curve, me.G, me.r, me.h) def group(me): return ECGroup(me) _augment(ECInfo, _tmp) @@ -176,6 +193,8 @@ class _tmp: return '(%s, %s)' % (me.x, me.y) _augment(ECPtCurve, _tmp) +#----- Key sizes ------------------------------------------------------------ + class _tmp: def __repr__(me): return 'KeySZAny(%d)' % me.default def check(me, sz): return True @@ -185,7 +204,7 @@ _augment(KeySZAny, _tmp) class _tmp: def __repr__(me): return 'KeySZRange(%d, %d, %d, %d)' % \ - (me.default, me.min, me.max, me.mod) + (me.default, me.min, me.max, me.mod) 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' @@ -204,10 +223,12 @@ class _tmp: return found _augment(KeySZSet, _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) + (type(me).__name__, me.p, me.r, me.g) _augment(FGInfo, _tmp) class _tmp: @@ -228,7 +249,9 @@ class _tmp: return '%r(%r)' % (me.group, str(me)) _augment(GE, _tmp) -class PKCS1Crypt(object): +#----- RSA encoding techniques ---------------------------------------------- + +class PKCS1Crypt (object): def __init__(me, ep = '', rng = rand): me.ep = ep me.rng = rng @@ -237,7 +260,7 @@ class PKCS1Crypt(object): def decode(me, ct, nbits): return _base._p1crypt_decode(ct, nbits, me.ep, me.rng) -class PKCS1Sig(object): +class PKCS1Sig (object): def __init__(me, ep = '', rng = rand): me.ep = ep me.rng = rng @@ -246,7 +269,7 @@ class PKCS1Sig(object): def decode(me, msg, sig, nbits): return _base._p1sig_decode(msg, sig, nbits, me.ep, me.rng) -class OAEP(object): +class OAEP (object): def __init__(me, mgf = sha_mgf, hash = sha, ep = '', rng = rand): me.mgf = mgf me.hash = hash @@ -257,7 +280,7 @@ class OAEP(object): def decode(me, ct, nbits): return _base._oaep_decode(ct, nbits, me.mgf, me.hash, me.ep, me.rng) -class PSS(object): +class PSS (object): def __init__(me, mgf = sha_mgf, hash = sha, saltsz = None, rng = rand): me.mgf = mgf me.hash = hash @@ -269,7 +292,7 @@ class PSS(object): return _base._pss_encode(msg, nbits, me.mgf, me.hash, me.saltsz, me.rng) def decode(me, msg, sig, nbits): return _base._pss_decode(msg, sig, nbits, - me.mgf, me.hash, me.saltsz, me.rng) + me.mgf, me.hash, me.saltsz, me.rng) class _tmp: def encrypt(me, msg, enc): @@ -280,7 +303,7 @@ class _tmp: x = enc.decode(msg, me.pubop(sig), me.n.nbits) return x is None or x == msg except ValueError: - return False + return False _augment(RSAPub, _tmp) class _tmp: @@ -288,6 +311,57 @@ class _tmp: def sign(me, msg, enc): return me.privop(enc.encode(msg, me.n.nbits)) _augment(RSAPriv, _tmp) +#----- Built-in named curves and prime groups ------------------------------- + +class _groupmap (object): + def __init__(me, map, nth): + me.map = map + me.nth = nth + me.i = [None] * (max(map.values()) + 1) + def __repr__(me): + return '{%s}' % ', '.join(['%r: %r' % (k, me[k]) for k in me]) + 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) + +#----- Prime number generation ---------------------------------------------- + +class PrimeGenEventHandler (object): + def pg_begin(me, ev): + return me.pg_try(ev) + def pg_done(me, ev): + return PGEN_DONE + def pg_abort(me, ev): + return PGEN_TRY + def pg_fail(me, ev): + return PGEN_TRY + def pg_pass(me, ev): + return PGEN_TRY class SophieGermainStepJump (object): def pg_begin(me, ev): @@ -350,18 +424,6 @@ class SophieGermainTester (object): del me.lr del me.hr -class PrimeGenEventHandler (object): - def pg_begin(me, ev): - return me.pg_try(ev) - def pg_done(me, ev): - return PGEN_DONE - def pg_abort(me, ev): - return PGEN_TRY - def pg_fail(me, ev): - return PGEN_TRY - def pg_pass(me, ev): - return PGEN_TRY - class PrimitiveStepper (PrimeGenEventHandler): def __init__(me): pass @@ -452,20 +514,20 @@ class SimulTester (PrimeGenEventHandler): def sgprime(start, step = 2, name = 'p', event = pgen_nullev, nsteps = 0): start = MP(start) return pgen(start, name, SimulStepper(step = step), SimulTester(), event, - nsteps, RabinMiller.iters(start.nbits)) + nsteps, RabinMiller.iters(start.nbits)) def findprimitive(mod, hh = [], exp = None, name = 'g', event = pgen_nullev): return pgen(0, name, PrimitiveStepper(), PrimitiveTester(mod, hh, exp), - event, 0, 1) + event, 0, 1) def kcdsaprime(pbits, qbits, rng = rand, - event = pgen_nullev, name = 'p', nsteps = 0): + event = pgen_nullev, name = 'p', nsteps = 0): hbits = pbits - qbits h = pgen(rng.mp(hbits, 1), name + ' [h]', - PrimeGenStepper(2), PrimeGenTester(), - event, nsteps, RabinMiller.iters(hbits)) + PrimeGenStepper(2), PrimeGenTester(), + event, nsteps, RabinMiller.iters(hbits)) q = pgen(rng.mp(qbits, 1), name, SimulStepper(2 * h, 1, 2), - SimulTester(2 * h, 1), event, nsteps, RabinMiller.iters(qbits)) + SimulTester(2 * h, 1), event, nsteps, RabinMiller.iters(qbits)) p = 2 * q * h + 1 return p, q, h