def get_keystore(self, name):
_store = _normalize_store_name(name)
if _store in self._store_cache:
return self._store_cache[_store]
if not self._cp.has_section(_store):
raise InvalidKeystoreException("Store does not exist")
_opts = dict(self._cp.items(_store))
if "type" not in _opts or "uri" not in _opts:
raise InvalidKeystoreException(
"This store is not properly formated")
if _opts["type"] not in self._adapters:
raise UnkonwnAdapterException("Unkonwn keystore type '{}'".format(
_opts["type"]))
_uri = _opts["uri"]
_type = _opts["type"]
del _opts["type"]
del _opts["uri"]
ks = Keystore(self._adapters[_type])
ks.load(_uri, **_opts)
self._store_cache[_store] = ks
return ks
def initialize(self):
self.__kdesfire = unhexlify(Keystore().getMasterKey(self.uid)
or "00" * 8)
__km1 = gen_padded_random(16)
__km2 = gen_padded_random(16)
__kw1 = gen_padded_random(16)
def_key = unhexlify("00" * 8) # default key
__k = gen_padded_random(16)
self.select_application(0x00)
self.__authenticate(0x00, self.__kdesfire)
if Keystore().getMasterKey(self.uid) is None:
new_k = gen_padded_random(16)
self.change_key(0, 0, self.__kdesfire, self.__kdesfire, new_k)
self.__kdesfire = new_k
self.__create_application(0x01, 0x0B, 0x02)
self.select_application(0x01)
self.__authenticate(0x00, def_key) # default km1 value at init
# master key
#stupid_k = unhexlify("11"*16)
#self.change_key(0, 0, self.__kdesfire, self.__kdesfire, stupid_k)
#self.change_key(0, 0, stupid_k, stupid_k, len(self.__kdesfire) == 8 and
# self.__kdesfire + self.__kdesfire or self.__kdesfire)
# km1
self.change_key(1, 0, def_key, def_key, __km1)
# create files of aid 0x1
self.__create_file(1, 3, [0xFF, 0xE1], 128)
self.__create_file(2, 3, [0xFF, 0xE1], 128)
#
self.change_key(1, 1, __km1, def_key, __kw1)
sk = unhexlify(self.__authenticate(0x01, __kw1))
#E = self.__P_K_enc.encrypt(self.__k, '')[0]
E = self.__P_K_enc[0].public_encrypt(__k, RSA.pkcs1_padding)
self.__write_data(1, 0, hexstr_to_bytes(hexlify(E)), sk)
S = self.__P_K_shop.sign(hashlib.sha1(E).digest())
if DEBUG:
print "sign(enc(K)) is set to ", str(S)
self.__write_data(2, 0, hexstr_to_bytes(hexlify(S)), sk)
# APPLICATION 0
self.select_application(0x00)
self.__authenticate(0x00, self.__kdesfire)
self.__create_application(0x02, 0x0B, 0x02)
# APPLICATION 2
self.select_application(0x02)
self.change_key(2, 0, def_key, def_key, __km2)
self.__create_file(1, 3, [0xFF, 0xE1], 32)
self.__create_file(2, 3, [0x1F, 0x11], 2000)
# change k
self.change_key(2, 1, __km2, def_key, __k)
sk = unhexlify(self.__authenticate(0x01, __k))
self.__write_data(1, 0, encode_counter(0), sk)
self.__write_data(2, 0, str_to_bytes("\0" * 2000), sk)
def __init__(self, p_k_enc, p_k_shop, p_ca, cert, conn):
self.__P_K_enc = p_k_enc
self.__P_K_shop = p_k_shop
self.__P_ca = p_ca
self.__connection = conn
self.uid = bytes_to_hexstr(self.poll())
store = Keystore()
self.__kdesfire = unhexlify(store.getMasterKey(self.uid) or "00" * 8)
if len(self.__kdesfire) not in [8, 16]:
raise WrongKey("kdesfire from keystore doesn't have a good size " \
+ "(" + len(self.__kdesfire) + ")")
self.__cert = cert
def __init__(self, p_k_enc, p_k_shop, p_ca, cert, conn):
self.__P_K_enc = p_k_enc
self.__P_K_shop = p_k_shop
self.__P_ca = p_ca
self.__connection = conn
self.uid = bytes_to_hexstr(self.poll())
store = Keystore()
self.__kdesfire = unhexlify(store.getMasterKey(self.uid) or "00"*8)
if len(self.__kdesfire) not in [8, 16]:
raise WrongKey("kdesfire from keystore doesn't have a good size " \
+ "(" + len(self.__kdesfire) + ")")
self.__cert = cert
def change_key(self, aid, key_no, key_auth, old_key, new_key):
"""wrapper for the different ways of changing key
@pre: the key_auth is equal to the old_key if the key_no is 0
@post: if the master key is changed, it is backed-up externally
@return: on success, the new session key is returned"""
# master key
if key_no == 0 and aid == 0:
ret = self.change_key1(aid, key_no, old_key, new_key)
Keystore().setMasterKey(self.uid, hexlify(new_key))
if DEBUG:
print "Changed master key, new one is %s" \
% Keystore().getMasterKey(self.uid)
return ret
elif key_no == 0:
return self.change_key1(aid, key_no, old_key, new_key)
else:
return self.change_key2(aid, key_no, key_auth, old_key, new_key)
def init_keystore(keys_dir='./keystore/'):
keys = []
addresses = []
for file in glob.glob(os.path.join(keys_dir, '*')):
key = Keystore.load(keys_dir + file[-40:], "TFG1234")
keys.append(key)
addresses.append(normalize_address(key.keystore['address']))
return keys, addresses
from apply import validate_transaction, apply_transaction
from keystore import Keystore
import rlp
import netaddr
from netaddr import IPNetwork, IPAddress, IPSet
from utils import address, normalize_address
db = _EphemDB()
env = Env(_EphemDB())
chain = Chain(genesis=mk_genesis_data(env), env=env)
state = chain.state
add1 = "094a2c9f5b46416b9b9bd9f1efa1f3a73d46cec2"
add2 = "7719818983cb546d1badee634621dad4214cba25"
add3 = "a3e04410f475b813c01ca77ff12cb277991e62d2"
ks1 = Keystore.load("./keystore/094a2c9f5b46416b9b9bd9f1efa1f3a73d46cec2",
"TFG1234")
ks2 = Keystore.load("./keystore/7719818983cb546d1badee634621dad4214cba25",
"TFG1234")
ks3 = Keystore.load("./keystore/a3e04410f475b813c01ca77ff12cb277991e62d2",
"TFG1234")
"""
tx1 = Transaction(0,0,add2, 0, '192.152.0.0/12')
tx1.sign(ks1.privkey)
tx2 = Transaction(0,0,add3, 0, '192.152.0.0/16')
tx2.sign(ks2.privkey)
tx3 = Transaction(0,1,add1, 0, '192.152.0.0/24')
tx3.sign(ks3.privkey)
tx4 = Transaction(1,1,add2, 0, '192.152.0.0/25')
tx4.sign(ks3.privkey)
tx5 = Transaction(2,0,add1, 0, '192.152.0.0/26')
tx5.sign(ks3.privkey)
from keystore import Keystore
ks = Keystore.load("./keystore/7719818983cb546d1badee634621dad4214cba25",
"TFG1234")
print(ks.privkey.encode("HEX"))
print(ks.pubkey)
print(ks.address)
ks = Keystore.new("TFG1234")
ks.save(ks)