def decode_int_val(self, obj):
tlv = self.handle_tag_dec(obj)
# map to an Int, given the length of the value part
bit_len = tlv[1]()*8
V = Int('V', Type='int%s'%bit_len, Repr=self._REPR_INT)
V.map(str(tlv[2]))
tlv.set(V)
#
obj._val = V()
def decode_int_val(self, obj):
tlv = self.handle_tag_dec(obj)
# map to an Int, given the length of the value part
bit_len = tlv[1]() * 8
V = Int('V', Type='int%s' % bit_len, Repr=self._REPR_INT)
V.map(str(tlv[2]))
tlv.set(V)
#
obj._val = V()
def map(self, s=""):
Layer.map(self, s)
# map extensions
if len(s) >= len(self) + 2:
s = s[len(self) :]
# add extensions length
extl = Int("ext_length", Type="uint16")
extl.map(s)
self.append(extl)
s = s[2:]
l = extl()
if len(s) > l:
# truncate the buffer
s = s[:l]
elif len(s) < l:
# error
return
# add extensions
while s:
self.append(Extension())
self[-1].map(s)
s = s[len(self[-1]) :]
def decode_enum_val(self, obj):
tlv = self.handle_tag_dec(obj)
# map to an Int, given the length of the value part
bit_len = tlv[1]()*8
if bit_len:
V = Int('V', Type='int%s'%bit_len, Repr=self._REPR_ENUM)
V.map(str(tlv[2]))
if self._ENUM_BUILD_TYPE:
V.Dict = dict([(i[1], i[0]) for i in obj._cont.items()])
tlv.set(V)
#
val_int = V()
enum_int = obj._cont.values()
if val_int in enum_int:
obj._val = obj._cont.keys()[enum_int.index(val_int)]
elif obj._ext is not None:
# if extended index value is unknown,
# the decoded value cannot be retrieved
# WNG: we put a dummy string here as value
obj._val = '_ext_%i' % val_int
elif self._SAFE:
raise(ASN1_BER_DECODER('%s: invalid ENUMERATED identifier %s' \
% (obj.get_fullname(), val_int)))
def decode_enum_val(self, obj):
tlv = self.handle_tag_dec(obj)
# map to an Int, given the length of the value part
bit_len = tlv[1]() * 8
if bit_len:
V = Int('V', Type='int%s' % bit_len, Repr=self._REPR_ENUM)
V.map(str(tlv[2]))
if self._ENUM_BUILD_TYPE:
V.Dict = dict([(i[1], i[0]) for i in obj._cont.items()])
tlv.set(V)
#
val_int = V()
enum_int = obj._cont.values()
if val_int in enum_int:
obj._val = obj._cont.keys()[enum_int.index(val_int)]
elif obj._ext is not None:
# if extended index value is unknown,
# the decoded value cannot be retrieved
# WNG: we put a dummy string here as value
obj._val = '_ext_%i' % val_int
elif self._SAFE:
raise(ASN1_BER_DECODER('%s: invalid ENUMERATED identifier %s' \
% (obj.get_fullname(), val_int)))
class DH_Bytes(object):
'''
Diffie-Hellman computation.
Uses Python bytes of size SIZE as input / output.
Instance attributes:
SIZE: size of Diffie-Hellman exchanged values
TYPE: libmich Int.Type to be used, according to SIZE
MOD: modulus
GEN: generator
priv: user's private value
pub: user's public value, corresponding to the local priv one
pub_peer: peer's public value, corresponding to the received one
shkey: shared key computed from the pub_peer and priv ones
1) Initialize DH modulus and generator
dh = DH(mod, gen)
2) Generate or set the user's private value, and compute the user's public
value
dh.set_private() # automatic generation from randint(3, MOD-1)
dh.set_private_manual(priv) # manual setting with bytes
3) Get the user's public value to be sent to peer
pub = dh.get_public()
4) Compute shared secret from the received peer's public value
dh.compute_shared_key(pub_peer)
5) Get the computed shared secret
key = dh.get_shared_key()
'''
SIZE = 2048
MOD = 3
GEN = 2
def __init__(self, mod=None, gen=None, size=None):
if size and 0 < size <= 2**20:
self.SIZE = size
self.TYPE = 'uint{0}'.format(self.SIZE)
self.MOD = Int('MOD', Pt=self.MOD, Type=self.TYPE)
self.GEN = Int('GEN', Pt=self.GEN, Type=self.TYPE)
#
if mod:
if len(mod) < self.SIZE//8:
mod = b'\0'*(self.SIZE//8 - len(mod)) + mod
elif len(mod) > self.SIZE//8:
mod = mod[-self.SIZE//8:]
self.MOD.map(mod)
if gen:
if len(gen) < self.SIZE//8:
gen = b'\0'*(self.SIZE//8 - len(gen)) + gen
elif len(gen) > self.SIZE//8:
gen = gen[-self.SIZE//8:]
self.GEN.map(gen)
#
self.priv = None
self.pub = None
self.pub_peer = None
self.shkey = None
def set_private(self):
self.priv = Int('priv', Pt=_rand.randint(3, self.MOD()-1),
Type=self.TYPE)
if _with_gmpy:
pub = int(pow(gmpy.mpz(self.GEN()),
gmpy.mpz(self.priv()),
gmpy.mpz(self.MOD())))
else:
pub = pow(self.GEN(), self.priv(), self.MOD())
self.pub = Int('pub', Pt=pub, Type=self.TYPE)
def set_private_manual(self, priv):
if len(priv) < self.SIZE//8:
priv = b'\0'*(self.SIZE//8 - len(priv)) + priv
elif len(priv) > self.SIZE//8:
priv = priv[-self.SIZE//8:]
self.priv = Int('priv', Type=self.TYPE)
self.priv.map(priv)
if self.priv() >= self.MOD():
self.priv < self.priv() % self.MOD()
#
if _with_gmpy:
pub = int(pow(gmpy.mpz(self.GEN()),
gmpy.mpz(self.priv()),
gmpy.mpz(self.MOD())))
else:
pub = pow(self.GEN(), self.priv(), self.MOD())
self.pub = Int('pub', Pt=pub, Type=self.TYPE)
def get_public(self):
return bytes(self.pub)
def compute_shared_key(self, pub_peer):
if len(pub_peer) < self.SIZE//8:
pub_peer = b'\0'*(self.SIZE//8 - len(pub_peer)) + pub_peer
elif len(pub_peer) > self.SIZE//8:
pub_peer = pub_peer[-self.SIZE//8:]
self.pub_peer = Int('pub_peer', Type=self.TYPE)
self.pub_peer.map(pub_peer)
#
if _with_gmpy:
shk = int(pow(gmpy.mpz(self.pub_peer()),
gmpy.mpz(self.priv()),
gmpy.mpz(self.MOD())))
else:
shk = pow(self.pub_peer(), self.priv(), self.MOD())
self.shkey = Int('shkey', Pt=shk, Type=self.TYPE)
def get_shared_key(self):
return bytes(self.shkey)
