def unpack_msg(data, *args, **kwargs):
if not __ca.config['SECURIZER']:
return data
else:
# if 'key' in data:
# cipher_key = base64.b64decode(data.get('key'))
# else:
# try:
# cipher_key = session.get('cipher_key', None)
# except RuntimeError:
# cipher_key = None
# try:
# session['cipher_key'] = cipher_key
# except RuntimeError:
# pass
if not 'error' in data:
dim = None
if dim is None:
dim = Dimension.get_current()
if dim is None:
raise ValueError('No dimension found but SECURIZER set')
return _unpack_msg(data,
*args,
pub_key=dim.public,
priv_key=dim.private,
**kwargs)
else:
return data
def test_join_command(self, mock_now, mock_check, mock_current_app,
mock_current_app2, mock_time_sleep):
with virtual_network(self.app, self.app_join):
mock_now.return_value = now
mock_check.return_value = True
mock_current_app.dm.config.http_conf.get.side_effect = [
'/origin_key', '/origin_cert'
]
self.mock_dm.config.http_conf.__getitem__.side_effect = {
'keyfile': '/dest_key',
'certfile': '/dest_cert'
}.__getitem__
mock_current_app2.dm.cluster_manager.get_alive.return_value = [
self.s1.id
]
join(self.mock_dm, 'node1', self.token, port=5000)
# check if new server created
server_new = Server.query.get(self.join_server_id)
self.assertEqual(server_new.last_modified_at, now)
with self.app_join.app_context():
self.dim.pop('current')
self.assertDictEqual(self.dim,
Dimension.get_current().to_json())
s = Server.query.get(self.s1.id)
self.assertEqual(0, s.route.cost)
self.assertTrue(os.path.exists('/dest_key'))
self.assertTrue(os.path.exists('/dest_cert'))
def setUp(self):
"""Create and configure a new app instance for each test."""
# create the app with common test config
self.app = create_app('test')
self.app.config['SCHEME'] = 'http'
@self.app.route('/', methods=['GET', 'POST'])
def home():
return {'msg': 'default response'}
@self.app.route('/securized', methods=['GET', 'POST'])
@securizer
def securized():
return {'msg': 'default response'}
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client()
db.init_app(self.app)
db.create_all()
self.server = Server('me', port=5000, me=True)
db.session.add(self.server)
db.session.add(Dimension.from_json(self.json_dim))
db.session.commit()
self.token = create_access_token('test')
self.auth = HTTPBearerAuth(self.token)
self.url = 'https://me:5000/'
def fill_database(self, node):
db.create_all()
d = Dimension.from_json(self.dim)
d.current = True
s1 = Server(id='00000000-0000-0000-0000-000000000001', name='node1', created_on=now, me=node == 'node1')
g11 = Gate(id='00000000-0000-0000-0000-000000000011', server=s1, port=5000, dns=s1.name)
s2 = Server(id='00000000-0000-0000-0000-000000000002', name='node2', created_on=now, me=node == 'node2')
g12 = Gate(id='00000000-0000-0000-0000-000000000012', server=s2, port=5000, dns=s2.name)
s3 = Server(id='00000000-0000-0000-0000-000000000003', name='node3', created_on=now, me=node == 'node3')
g13 = Gate(id='00000000-0000-0000-0000-000000000013', server=s3, port=5000, dns=s3.name)
s4 = Server(id='00000000-0000-0000-0000-000000000004', name='node4', created_on=now, me=node == 'node4')
g14 = Gate(id='00000000-0000-0000-0000-000000000014', server=s4, port=5000, dns=s4.name)
if node == 'node1':
self.s1 = s1
self.s2 = s2
self.s3 = s3
self.s4 = s4
Route(s2, g12)
Route(s3, s2, 1)
elif node == 'node2':
Route(s1, g11)
Route(s3, g13)
elif node == 'node3':
Route(s1, s2, 1)
Route(s2, g12)
db.session.add_all([d, s1, s2, s3, s4])
db.session.commit()
def load_global_data_into_context():
from dimensigon.domain.entities import Server, Dimension
from dimensigon.web.decorators import set_source
global _dimension, _server
set_source()
g.server = Server.get_current()
g.dimension = Dimension.get_current()
def _fill_database(self, app: Flask):
with mock.patch('dimensigon.domain.entities.get_now') as mock_get_now:
mock_get_now.return_value = defaults.INITIAL_DATEMARK
node = app.config['SERVER_NAME']
with app.app_context():
db.create_all()
event.listen(db.session, 'after_commit', receive_after_commit)
set_initial(**self.initials)
d = Dimension.from_json(self.dim)
d.current = True
s1 = Server('node1',
created_on=defaults.INITIAL_DATEMARK,
id=self.SERVER1,
me=node == 'node1')
g11 = Gate(id='00000000-0000-0000-0000-000000000011',
server=s1,
port=5000,
dns=s1.name)
s2 = Server('node2',
created_on=defaults.INITIAL_DATEMARK,
id=self.SERVER2,
me=node == 'node2')
g12 = Gate(id='00000000-0000-0000-0000-000000000012',
server=s2,
port=5000,
dns=s2.name)
s3 = Server('node3',
created_on=defaults.INITIAL_DATEMARK,
id=self.SERVER3,
me=node == 'node3')
g13 = Gate(id='00000000-0000-0000-0000-000000000013',
server=s3,
port=5000,
dns=s3.name)
if node == 'node1':
Route(s2, g12)
Route(s3, g13)
elif node == 'node2':
Route(s1, g11)
Route(s3, g13)
elif node == 'node3':
Route(s1, g11)
Route(s2, g12)
self.fill_database()
db.session.add_all([d, s1, s2, s3])
db.session.commit()
if node == 'node1':
self.s1, self.s2, self.s3 = db.session.merge(
s1), db.session.merge(s2), db.session.merge(s3)
def generate_dimension(name):
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from dimensigon.domain.entities import Dimension
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=4096,
backend=default_backend()
)
priv_pem = private_key.private_bytes(encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption())
pub_pem = private_key.public_key().public_bytes(encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.PKCS1)
return Dimension(name=name, private=priv_pem, public=pub_pem)
def _fill_database(self):
with mock.patch('dimensigon.domain.entities.get_now') as mock_get_now:
mock_get_now.return_value = defaults.INITIAL_DATEMARK
db.create_all()
event.listen(db.session, 'after_commit', receive_after_commit)
set_initial(**self.initials)
d = Dimension.from_json(self.dim)
d.current = True
self.s1 = Server('node1',
created_on=defaults.INITIAL_DATEMARK,
id=self.SERVER,
me=True)
self.g11 = Gate(id='00000000-0000-0000-0000-000000000011',
server=self.s1,
port=5000,
dns=self.s1.name)
self.fill_database()
db.session.add_all([d, self.s1])
db.session.commit()
def pack_msg(data, *args, **kwargs):
if not __ca.config['SECURIZER']:
return data
else:
# if not ('symmetric_key' in kwargs or 'cipher_key' in kwargs):
# try:
# kwargs['cipher_key'] = session.get('cipher_key')
# except RuntimeError:
# pass
# if generate_key:
# kwargs.pop('symmetric_key', None)
# kwargs.pop('cipher_key', None)
dim = None
if dim is None:
dim = Dimension.get_current()
if dim is None:
raise ValueError('No dimension found but SECURIZER set')
return _pack_msg(data,
*args,
source=Server.get_current(),
pub_key=dim.public,
priv_key=dim.private,
**kwargs)