-# -*-python-*-
-#
-# $Id$
-#
-# Setup for Catacomb/Python bindings
-#
-# (c) 2004 Straylight/Edgeware
-#
-
-#----- Licensing notice -----------------------------------------------------
-#
-# This file is part of the Python interface to Catacomb.
-#
-# Catacomb/Python is free software; you can redistribute it and/or modify
-# 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 --------------------------------------------------------------
+### -*-python-*-
+###
+### Setup for Catacomb/Python bindings
+###
+### (c) 2004 Straylight/Edgeware
+###
+
+###----- Licensing notice ---------------------------------------------------
+###
+### This file is part of the Python interface to Catacomb.
+###
+### Catacomb/Python is free software; you can redistribute it and/or modify
+### 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.
import _base
import types as _types
from binascii import hexlify as _hexify, unhexlify as _unhexify
from sys import argv as _argv
-#----- Basic stuff ----------------------------------------------------------
+###--------------------------------------------------------------------------
+### Basic stuff.
## For the benefit of the default keyreporter, we need the program na,e.
_base._ego(_argv[0])
'DHInfo', 'BinDHInfo', 'RSAPriv', 'BBSPriv',
'PrimeFilter', 'RabinMiller',
'Group', 'GE',
- 'KeyData']:
+ 'KeySZ', 'KeyData']:
c = d[i]
pre = '_' + i + '_'
plen = len(pre)
raise SyntaxError, 'junk at end of string'
return x
-#----- Bytestrings ----------------------------------------------------------
+###--------------------------------------------------------------------------
+### Bytestrings.
class _tmp:
def fromhex(x):
_augment(ByteString, _tmp)
bytes = ByteString.fromhex
-#----- Multiprecision integers and binary polynomials -----------------------
+###--------------------------------------------------------------------------
+### 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)
+ q, r = divmod(a, b)
+ if r == 0: return q
+ g = b.gcd(r)
+ me = super(BaseRat, cls).__new__(cls)
+ me._n = a//g
+ me._d = b//g
+ return me
+ @property
+ def numer(me): return me._n
+ @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 __add__(me, you):
+ n, d = _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)
+ return type(me)(me._n*d - n*me._d, d*me._d)
+ def __rsub__(me, you):
+ n, d = _split_rat(you)
+ return type(me)(n*me._d - me._n*d, d*me._d)
+ def __mul__(me, you):
+ n, d = _split_rat(you)
+ return type(me)(me._n*n, me._d*d)
+ def __div__(me, you):
+ n, d = _split_rat(you)
+ return type(me)(me._n*d, me._d*n)
+ def __rdiv__(me, you):
+ n, d = _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)
+
+class IntRat (BaseRat):
+ RING = MP
+
+class GFRat (BaseRat):
+ RING = GF
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 factorial(x):
- 'factorial(X) -> X!'
- if x < 0: raise ValueError, 'factorial argument must be > 0'
- return MPMul.product(xrange(1, x + 1))
- factorial = staticmethod(factorial)
+ def __div__(me, you): return IntRat(me, you)
+ def __rdiv__(me, you): return IntRat(you, me)
_augment(MP, _tmp)
class _tmp:
+ 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)
+ def __div__(me, you): return GFRat(me, you)
+ def __rdiv__(me, you): return GFRat(you, me)
_augment(GF, _tmp)
class _tmp:
product = staticmethod(product)
_augment(MPMul, _tmp)
-#----- Abstract fields ------------------------------------------------------
+###--------------------------------------------------------------------------
+### Abstract fields.
class _tmp:
def fromstring(str): return _checkend(Field.parse(str))
class _tmp:
def __repr__(me): return '%s(%sL)' % (type(me).__name__, me.p)
+ def __hash__(me): return 0x114401de ^ hash(me.p)
def ec(me, a, b): return ECPrimeProjCurve(me, a, b)
_augment(PrimeField, _tmp)
_augment(BinField, _tmp)
class _tmp:
+ def __hash__(me): return 0x23e4701c ^ hash(me.p)
+_augment(BinPolyField, _tmp)
+
+class _tmp:
+ def __hash__(me):
+ h = 0x9a7d6240
+ h ^= hash(me.p)
+ h ^= 2*hash(me.beta) & 0xffffffff
+ return h
+_augment(BinNormField, _tmp)
+
+class _tmp:
def __str__(me): return str(me.value)
def __repr__(me): return '%s(%s)' % (repr(me.field), repr(me.value))
_augment(FE, _tmp)
-#----- Elliptic curves ------------------------------------------------------
+###--------------------------------------------------------------------------
+### Elliptic curves.
class _tmp:
def __repr__(me):
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:
+ def __hash__(me):
+ h = 0x6751d341
+ h ^= hash(me.field)
+ h ^= 2*hash(me.a) ^ 0xffffffff
+ h ^= 5*hash(me.b) ^ 0xffffffff
+ return h
+_augment(ECPrimeCurve, _tmp)
+
+class _tmp:
+ def __hash__(me):
+ h = 0x2ac203c5
+ h ^= hash(me.field)
+ h ^= 2*hash(me.a) ^ 0xffffffff
+ h ^= 5*hash(me.b) ^ 0xffffffff
+ return h
+_augment(ECBinCurve, _tmp)
+
+class _tmp:
def __repr__(me):
if not me: return 'ECPt()'
return 'ECPt(%s, %s)' % (me.ix, me.iy)
def __repr__(me):
return 'ECInfo(curve = %r, G = %r, r = %s, h = %s)' % \
(me.curve, me.G, me.r, me.h)
+ def __hash__(me):
+ h = 0x9bedb8de
+ h ^= hash(me.curve)
+ h ^= 2*hash(me.G) & 0xffffffff
+ return h
def group(me):
return ECGroup(me)
_augment(ECInfo, _tmp)
return '(%s, %s)' % (me.x, me.y)
_augment(ECPtCurve, _tmp)
-#----- Key sizes ------------------------------------------------------------
+###--------------------------------------------------------------------------
+### Key sizes.
class _tmp:
def __repr__(me): return 'KeySZAny(%d)' % me.default
return found
_augment(KeySZSet, _tmp)
-#----- Abstract groups ------------------------------------------------------
+###--------------------------------------------------------------------------
+### Abstract groups.
class _tmp:
def __repr__(me):
_augment(Group, _tmp)
class _tmp:
+ def __hash__(me):
+ info = me.info
+ h = 0xbce3cfe6
+ h ^= hash(info.p)
+ h ^= 2*hash(info.r) & 0xffffffff
+ h ^= 5*hash(info.g) & 0xffffffff
+ return h
+_augment(PrimeGroup, _tmp)
+
+class _tmp:
+ def __hash__(me):
+ info = me.info
+ h = 0x80695949
+ h ^= hash(info.p)
+ h ^= 2*hash(info.r) & 0xffffffff
+ h ^= 5*hash(info.g) & 0xffffffff
+ return h
+_augment(BinGroup, _tmp)
+
+class _tmp:
+ def __hash__(me): return 0x0ec23dab ^ hash(me.info)
+_augment(ECGroup, _tmp)
+
+class _tmp:
def __repr__(me):
return '%r(%r)' % (me.group, str(me))
_augment(GE, _tmp)
-#----- RSA encoding techniques ----------------------------------------------
+###--------------------------------------------------------------------------
+### RSA encoding techniques.
class PKCS1Crypt (object):
def __init__(me, ep = '', rng = rand):
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:
def sign(me, msg, enc): return me.privop(enc.encode(msg, me.n.nbits))
_augment(RSAPriv, _tmp)
-#----- Built-in named curves and prime groups -------------------------------
+###--------------------------------------------------------------------------
+### Built-in named curves and prime groups.
class _groupmap (object):
def __init__(me, map, nth):
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 ----------------------------------------------
+###--------------------------------------------------------------------------
+### Prime number generation.
class PrimeGenEventHandler (object):
def pg_begin(me, ev):
~mdw / catacomb-python / blobdiff