def db_serialize_node(session, tid, language):
"""
Serialize the public node configuration.
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used during serialization
:return: The serialization of the public node configuration
"""
node_dict = ConfigFactory(session, tid).serialize('public_node')
l10n_dict = ConfigL10NFactory(
session,
tid,
).serialize('node', language)
ret_dict = merge_dicts(node_dict, l10n_dict)
ret_dict['root_tenant'] = tid == 1
ret_dict['languages_enabled'] = models.EnabledLanguage.list(
session,
tid) if node_dict['wizard_done'] else list(LANGUAGES_SUPPORTED_CODES)
ret_dict['languages_supported'] = LANGUAGES_SUPPORTED
records = session.query(models.File.id, models.File.data).filter(
models.File.tid == tid, models.File.id.in_(['css', 'script']))
for x in records:
ret_dict[x[0]] = True
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
for varname in ['version', 'version_db', 'latest_version']:
ret_dict[varname] = root_tenant_node.get_val(varname)
if language not in models.EnabledLanguage.list(session, tid):
language = root_tenant_node.get_val('default_language')
root_tenant_l10n = ConfigL10NFactory(session, 1)
if ret_dict['mode'] != 'default':
ret_dict['footer'] = root_tenant_l10n.get_val('footer', language)
ret_dict['whistleblowing_question'] = root_tenant_l10n.get_val(
'whistleblowing_question', language)
ret_dict['whistleblowing_button'] = root_tenant_l10n.get_val(
'whistleblowing_button', language)
ret_dict['enable_disclaimer'] = root_tenant_node.get_val(
'enable_disclaimer')
ret_dict['disclaimer_title'] = root_tenant_l10n.get_val(
'disclaimer_title', language)
ret_dict['disclaimer_text'] = root_tenant_l10n.get_val(
'disclaimer_text', language)
records = session.query(models.File.id, models.File.data).filter(
models.File.tid == 1, models.File.id.in_(['css', 'script']))
for x in records:
if not ret_dict.get(x[0]):
ret_dict[x[0]] = True
return ret_dict
def db_serialize_node(session, tid, language):
"""
Serialize the public node configuration.
"""
node_dict = ConfigFactory(session, tid).serialize('public_node')
l10n_dict = ConfigL10NFactory(
session,
tid,
).serialize('node', language)
ret_dict = merge_dicts(node_dict, l10n_dict)
ret_dict['root_tenant'] = tid == 1
ret_dict['languages_enabled'] = models.EnabledLanguage.list(
session,
tid) if node_dict['wizard_done'] else list(LANGUAGES_SUPPORTED_CODES)
ret_dict['languages_supported'] = LANGUAGES_SUPPORTED
files = [u'logo', u'favicon', u'css', u'script']
records = session.query(models.File.id, models.File.data).filter(
models.File.tid == tid,
models.File.id.in_([u'logo', u'favicon', u'css', u'script']))
for x in records:
ret_dict[x[0]] = x[1] if x[0] == 'logo' else True
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
for varname in ['version', 'version_db', 'latest_version']:
ret_dict[varname] = root_tenant_node.get_val(varname)
if language not in models.EnabledLanguage.list(session, tid):
language = root_tenant_node.get_val(u'default_language')
root_tenant_l10n = ConfigL10NFactory(session, 1)
if ret_dict['mode'] != u'default':
ret_dict['footer'] = root_tenant_l10n.get_val(u'footer', language)
ret_dict['whistleblowing_question'] = root_tenant_l10n.get_val(
u'whistleblowing_question', language)
ret_dict['whistleblowing_button'] = root_tenant_l10n.get_val(
u'whistleblowing_button', language)
ret_dict['enable_disclaimer'] = root_tenant_node.get_val(
u'enable_disclaimer')
ret_dict['disclaimer_title'] = root_tenant_l10n.get_val(
u'disclaimer_title', language)
ret_dict['disclaimer_text'] = root_tenant_l10n.get_val(
u'disclaimer_text', language)
records = session.query(models.File.id, models.File.data).filter(
models.File.tid == 1,
models.File.id.in_([u'logo', u'favicon', u'css', u'script']))
for x in records:
if not ret_dict[x[0]]:
ret_dict[x[0]] = x[1] if x[0] == 'logo' else True
return ret_dict
def db_serialize_node(session, tid, language):
"""
Serialize the public node configuration.
"""
# Contexts and Receivers relationship
node_dict = ConfigFactory(session, tid).serialize('public_node')
l10n_dict = ConfigL10NFactory(
session,
tid,
).serialize('node', language)
ret_dict = merge_dicts(node_dict, l10n_dict)
ret_dict['root_tenant'] = tid == 1
ret_dict['languages_enabled'] = models.EnabledLanguage.list(
session,
tid) if node_dict['wizard_done'] else list(LANGUAGES_SUPPORTED_CODES)
ret_dict['languages_supported'] = LANGUAGES_SUPPORTED
files = [u'logo', u'favicon', u'css', u'script']
for x in files:
ret_dict[x] = db_get_file(session, tid, x)
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
for varname in ['version', 'version_db', 'latest_version']:
ret_dict[varname] = root_tenant_node.get_val(varname)
if language not in models.EnabledLanguage.list(session, tid):
language = root_tenant_node.get_val(u'default_language')
root_tenant_l10n = ConfigL10NFactory(session, 1)
if ret_dict['mode'] == u'whistleblowing.it' or ret_dict[
'mode'] == u'eat':
ret_dict['footer'] = root_tenant_l10n.get_val(u'footer', language)
ret_dict['whistleblowing_question'] = root_tenant_l10n.get_val(
u'whistleblowing_question', language)
ret_dict['whistleblowing_button'] = root_tenant_l10n.get_val(
u'whistleblowing_button', language)
ret_dict['enable_disclaimer'] = root_tenant_node.get_val(
u'enable_disclaimer')
ret_dict['disclaimer_title'] = root_tenant_l10n.get_val(
u'disclaimer_title', language)
ret_dict['disclaimer_text'] = root_tenant_l10n.get_val(
u'disclaimer_text', language)
for x in files:
if not ret_dict[x]:
ret_dict[x] = db_get_file(session, 1, x)
return ret_dict
def db_admin_serialize_node(session, tid, language, config_node='admin_node'):
"""
Transaction for fetching the node configuration as admin
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used on serialization
:param config_node: The set of variables to be serialized
:return: Return the serialized configuration for the specified tenant
"""
config = ConfigFactory(session, tid).serialize(config_node)
misc_dict = {
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': models.EnabledLanguage.list(session, tid),
'root_tenant': tid == 1,
'https_possible': tid == 1 or State.tenant_cache[1].reachable_via_web,
}
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
misc_dict['version'] = root_tenant_node.get_val('version')
misc_dict['latest_version'] = root_tenant_node.get_val(
'latest_version')
l10n_dict = ConfigL10NFactory(session, tid).serialize('node', language)
return utils.sets.merge_dicts(config, misc_dict, l10n_dict)
def db_admin_serialize_node(session, tid, language, config_node='admin_node'):
"""
Transaction for fetching the node configuration as admin
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used on serialization
:param config_node: The set of variables to be serialized
:return: Return the serialized configuration for the specified tenant
"""
config = ConfigFactory(session, tid).serialize(config_node)
logo = session.query(models.File.data).filter(models.File.tid == tid, models.File.id == 'logo').one_or_none()
misc_dict = {
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': db_get_languages(session, tid),
'root_tenant': tid == 1,
'https_possible': tid == 1 or State.tenant_cache[1].reachable_via_web,
'encryption_possible': tid == 1 or State.tenant_cache[1].encryption,
'logo': logo if logo else ''
}
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
misc_dict['version'] = root_tenant_node.get_val('version')
misc_dict['latest_version'] = root_tenant_node.get_val('latest_version')
l10n_dict = ConfigL10NFactory(session, tid).serialize('node', language)
return utils.sets.merge_dicts(config, misc_dict, l10n_dict)
def db_admin_serialize_node(session, tid, language, config_node='admin_node'):
config = ConfigFactory(session, tid).serialize(config_node)
# Contexts and Receivers relationship
configured = session.query(models.ReceiverContext).filter(
models.ReceiverContext.context_id == models.Context.id,
models.Context.tid).count() > 0
misc_dict = {
'encryption_available': GCE.ENCRYPTION_AVAILABLE,
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': models.EnabledLanguage.list(session, tid),
'configured': configured,
'root_tenant': tid == 1,
'https_possible': tid == 1 or State.tenant_cache[1].reachable_via_web,
}
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
misc_dict['version'] = root_tenant_node.get_val(u'version')
misc_dict['latest_version'] = root_tenant_node.get_val(
u'latest_version')
l10n_dict = ConfigL10NFactory(session, tid).serialize('node', language)
return utils.sets.merge_dicts(config, misc_dict, l10n_dict)
def db_admin_serialize_node(session, tid, language, config_node='admin_node'):
"""
Transaction for fetching the node configuration as admin
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used on serialization
:param config_node: The set of variables to be serialized
:return: Return the serialized configuration for the specified tenant
"""
ret = ConfigFactory(session, tid).serialize(config_node)
logo = session.query(models.File.id).filter(models.File.tid == tid, models.File.name == 'logo').one_or_none()
ret.update({
'changelog': read_file('/usr/share/globaleaks/CHANGELOG'),
'license': read_file('/usr/share/globaleaks/LICENSE'),
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': db_get_languages(session, tid),
'root_tenant': tid == 1,
'https_possible': tid == 1 or State.tenant_cache[1].reachable_via_web,
'encryption_possible': tid == 1 or State.tenant_cache[1].encryption,
'logo': True if logo else False
})
if 'version' in ret:
ret['update_available'] = ret['version'] != ret['latest_version']
ret.update(ConfigL10NFactory(session, tid).serialize('node', language))
return ret
def update_notification(session, tid, request, language):
ConfigFactory(session, tid).update('notification', request)
ConfigL10NFactory(session, tid).update('notification', request, language)
db_refresh_memory_variables(session, [tid])
return db_get_notification(session, tid, language)
def db_update_node(session, tid, user_session, request, language):
"""
Transaction to update the node configuration
:param session: An ORM session
:param tid: A tenant ID
:param user_session: The current user session
:param request: The request data
:param language: the language in which to localize data
:return: Return the serialized configuration for the specified tenant
"""
config = ConfigFactory(session, tid)
enable_escrow = not config.get_val('escrow') and request.get('escrow', False)
disable_escrow = user_session.ek and config.get_val('escrow') and not request.get('escrow', False)
config.update('node', request)
if request['enable_ricochet_panel'] and not request['ricochet_address']:
request['enable_ricochet_panel'] = False
# Validate that IP addresses/ranges we're getting are goo
if 'ip_filter_admin' in request and request['ip_filter_admin_enable'] and request['ip_filter_admin']:
parse_csv_ip_ranges_to_ip_networks(request['ip_filter_admin'])
if 'languages_enabled' in request and 'default_language' in request:
db_update_enabled_languages(session,
tid,
request['languages_enabled'],
request['default_language'])
if language in db_get_languages(session, tid):
ConfigL10NFactory(session, tid).update('node', request, language)
if enable_escrow:
crypto_escrow_prv_key, State.tenant_cache[tid].crypto_escrow_pub_key = GCE.generate_keypair()
user = db_get(session, models.User, models.User.id == user_session.user_id)
user.crypto_escrow_prv_key = Base64Encoder.encode(GCE.asymmetric_encrypt(user.crypto_pub_key, crypto_escrow_prv_key))
if tid == 1:
session.query(models.User).update({'password_change_needed': True}, synchronize_session=False)
else:
session.query(models.User).filter(models.User.tid == tid).update({'password_change_needed': True}, synchronize_session=False)
if disable_escrow:
if tid == 1:
session.query(models.User).update({'crypto_escrow_bkp1_key': ''}, synchronize_session=False)
else:
session.query(models.User).update({'crypto_escrow_bkp2_key': ''}, synchronize_session=False)
session.query(models.User).filter(models.User.tid == tid).update({'crypto_escrow_prv_key': ''}, synchronize_session=False)
config.set_val('crypto_escrow_pub_key', State.tenant_cache[tid].crypto_escrow_pub_key)
db_refresh_memory_variables(session, [tid])
if tid == 1:
log.setloglevel(config.get_val('log_level'))
return db_admin_serialize_node(session, tid, language)
def update_notification(session, tid, request, language):
config = ConfigFactory(session, tid)
if request['smtp_password'] == '':
del request['smtp_password']
config.update('notification', request)
config_l10n = ConfigL10NFactory(session, tid)
config_l10n.update('notification', request, language)
db_refresh_memory_variables(session, [tid])
return db_get_notification(session, tid, language)
def admin_serialize_notification(session, tid, language):
config_dict = ConfigFactory(session, tid).serialize('admin_notification')
conf_l10n_dict = ConfigL10NFactory(session,
tid).serialize('notification', language)
cmd_flags = {
'reset_templates': False,
'exception_email_pgp_key_remove': False,
'smtp_password': '',
}
return merge_dicts(config_dict, cmd_flags, conf_l10n_dict)
def db_update_node(session, tid, request, language):
"""
Update and serialize the node infos
:param tid:
:param request:
:param session: the session on which perform queries.
:param language: the language in which to localize data
:return: a dictionary representing the serialization of the node
"""
config = ConfigFactory(session, tid)
config.update('node', request)
if 'basic_auth' in request and request['basic_auth'] and request[
'basic_auth_username'] and request['basic_auth_password']:
config.set_val('basic_auth', True)
config.set_val('basic_auth_username', request['basic_auth_username'])
config.set_val('basic_auth_password', request['basic_auth_password'])
else:
config.set_val('basic_auth', False)
config.set_val('basic_auth_username', '')
config.set_val('basic_auth_password', '')
if request['enable_ricochet_panel'] and not request['ricochet_address']:
request['enable_ricochet_panel'] = False
# Validate that IP addresses/ranges we're getting are goo
if 'ip_filter_admin' in request and request[
'ip_filter_admin_enable'] and request['ip_filter_admin']:
parse_csv_ip_ranges_to_ip_networks(request['ip_filter_admin'])
if 'ip_filter_whistleblower_enable' in request and request[
'ip_filter_whistleblower_enable'] and request[
'ip_filter_whistleblower']:
parse_csv_ip_ranges_to_ip_networks(request['ip_filter_whistleblower'])
if 'languages_enabled' in request and 'default_language' in request:
db_update_enabled_languages(session, tid, request['languages_enabled'],
request['default_language'])
if language in models.EnabledLanguage.list(session, tid):
ConfigL10NFactory(session, tid).update('node', request, language)
db_refresh_memory_variables(session, [tid])
if tid == 1:
log.setloglevel(config.get_val('log_level'))
return db_admin_serialize_node(session, tid, language)
def update_notification(session, tid, request, language):
config = ConfigFactory(session, tid)
if request['smtp_password'] == '':
del request['smtp_password']
config.update('notification', request)
config_l10n = ConfigL10NFactory(session, tid)
config_l10n.update('notification', request, language)
if request.pop('reset_templates'):
config_l10n.reset('notification', load_appdata())
db_refresh_memory_variables(session, [tid])
return admin_serialize_notification(session, tid, language)
def db_get_notification(session, tid, language):
"""
Transaction to get the notification settings for the specified tenant
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used in the serialization
:return: the serialization of notification settings for the specified tenant
"""
ret = ConfigFactory(session, tid).serialize('notification')
ret.update(
ConfigL10NFactory(session, tid).serialize('notification', language))
ret['templates'] = ConfigL10NFilters['notification']
return ret
def db_admin_serialize_node(session, tid, language, config_node='admin_node'):
config = ConfigFactory(session, tid).serialize(config_node)
misc_dict = {
'languages_supported': LANGUAGES_SUPPORTED,
'languages_enabled': models.EnabledLanguage.list(session, tid),
'root_tenant': tid == 1,
'https_possible': tid == 1 or State.tenant_cache[1].reachable_via_web,
}
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
misc_dict['version'] = root_tenant_node.get_val('version')
misc_dict['latest_version'] = root_tenant_node.get_val('latest_version')
l10n_dict = ConfigL10NFactory(session, tid).serialize('node', language)
return utils.sets.merge_dicts(config, misc_dict, l10n_dict)
def db_get_notification(session, tid, language):
"""
Transaction to get the notification settings for the specified tenant
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used in the serialization
:return: the serialization of notification settings for the specified tenant
"""
config_dict = ConfigFactory(session, tid).serialize('admin_notification')
conf_l10n_dict = ConfigL10NFactory(session,
tid).serialize('notification', language)
additional_dict = {
'smtp_password': '',
'templates': ConfigL10NFilters['notification']
}
return merge_dicts(config_dict, conf_l10n_dict, additional_dict)
def db_get_notification(session, tid, language):
"""
Transaction to get the notification settings for the specified tenant
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used in the serialization
:return: the serialization of notification settings for the specified tenant
"""
config_dict = ConfigFactory(session, tid).serialize('admin_notification')
conf_l10n_dict = ConfigL10NFactory(session,
tid).serialize('notification', language)
cmd_flags = {
'reset_templates': False,
'exception_email_pgp_key_remove': False,
'smtp_password': '',
}
return merge_dicts(config_dict, cmd_flags, conf_l10n_dict)
def db_serialize_node(session, tid, language):
"""
Serialize the public node configuration.
:param session: An ORM session
:param tid: A tenant ID
:param language: The language to be used during serialization
:return: The serialization of the public node configuration
"""
languages = db_get_languages(session, tid)
ret = ConfigFactory(session, tid).serialize('public_node')
ret.update(ConfigL10NFactory(
session,
tid,
).serialize('node', language))
ret['root_tenant'] = tid == 1
ret['languages_enabled'] = languages if ret['wizard_done'] else list(
LANGUAGES_SUPPORTED_CODES)
ret['languages_supported'] = LANGUAGES_SUPPORTED
for x in special_files:
ret[x] = session.query(models.File.id).filter(
models.File.tid == tid, models.File.name == x).one_or_none()
if tid != 1:
root_tenant_node = ConfigFactory(session, 1)
for varname in ['version', 'version_db', 'latest_version']:
ret[varname] = root_tenant_node.get_val(varname)
if language not in languages:
language = root_tenant_node.get_val('default_language')
root_tenant_l10n = ConfigL10NFactory(session, 1)
if ret['mode'] != 'default':
ret['onionservice'] = ret[
'subdomain'] + '.' + root_tenant_node.get_val('onionservice')
if ret['mode'] not in ['default', 'demo']:
ret['disable_privacy_badge'] = root_tenant_node.get_val(
'disable_privacy_badge')
ret['footer'] = root_tenant_l10n.get_val('footer', language)
ret['whistleblowing_question'] = root_tenant_l10n.get_val(
'whistleblowing_question', language)
ret['whistleblowing_button'] = root_tenant_l10n.get_val(
'whistleblowing_button', language)
ret['enable_disclaimer'] = root_tenant_node.get_val(
'enable_disclaimer')
ret['disclaimer_title'] = root_tenant_l10n.get_val(
'disclaimer_title', language)
ret['disclaimer_text'] = root_tenant_l10n.get_val(
'disclaimer_text', language)
for x in special_files:
if not ret[x]:
ret[x] = session.query(models.File.id).filter(
models.File.tid == 1,
models.File.name == x).one_or_none()
return ret
def reset_templates(session, tid):
config_l10n = ConfigL10NFactory(session, tid)
config_l10n.reset('notification', load_appdata())