742 lines
24 KiB
Python
742 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# Libervia plugin for handling stateless file sharing encryption
|
|
# Copyright (C) 2009-2026 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program 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 Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
from enum import Enum, StrEnum, auto
|
|
import enum
|
|
from typing import TYPE_CHECKING, Self, cast
|
|
from typing import get_type_hints
|
|
|
|
from pydantic import BaseModel, ConfigDict, Field, computed_field
|
|
from twisted.internet import defer
|
|
from twisted.words.protocols.jabber import jid
|
|
from tx_xmpp import data_form
|
|
|
|
from libervia.backend.core import exceptions
|
|
from libervia.backend.core.constants import Const as C
|
|
from libervia.backend.core.core_types import SatXMPPEntity
|
|
from libervia.backend.core.i18n import D_, _
|
|
from libervia.backend.core.log import getLogger
|
|
|
|
if TYPE_CHECKING:
|
|
from libervia.backend.core.main import LiberviaBackend
|
|
|
|
log = getLogger(__name__)
|
|
IMPORT_NAME = "DATA-POLICY"
|
|
|
|
PLUGIN_INFO = {
|
|
C.PI_NAME: "Data Policy",
|
|
C.PI_IMPORT_NAME: IMPORT_NAME,
|
|
C.PI_TYPE: C.PLUG_TYPE_EXP,
|
|
C.PI_PROTOCOLS: [],
|
|
C.PI_DEPENDENCIES: [],
|
|
C.PI_MAIN: "DATA_POLICY",
|
|
C.PI_HANDLER: "no",
|
|
}
|
|
|
|
NS_DATA_POLICY_BASE = "urn:xmpp:data-policy"
|
|
NS_DATA_POLICY = f"{NS_DATA_POLICY_BASE}:0"
|
|
NS_DATA_POLICY_ID_PREFIX = f"{NS_DATA_POLICY_BASE}:identity:"
|
|
NS_DATA_POLICY_ID_SUFFIX = ":0"
|
|
NS_DATA_POLICY_ID_TPL = (
|
|
f"{NS_DATA_POLICY_ID_PREFIX}{{category}}:{{type}}{NS_DATA_POLICY_ID_SUFFIX}"
|
|
)
|
|
|
|
|
|
class IndividualScore(BaseModel):
|
|
score: int
|
|
description: str
|
|
|
|
|
|
class Score(BaseModel):
|
|
score: int
|
|
minimum: int
|
|
maximum: int
|
|
detail: list[IndividualScore]
|
|
|
|
|
|
class ScoredStrEnum(StrEnum):
|
|
_score_map = enum.nonmember({})
|
|
_min_score = enum.nonmember(0)
|
|
_max_score = enum.nonmember(0)
|
|
|
|
@classmethod
|
|
def get_score(cls, value: str) -> Score:
|
|
score, description = cls._score_map[value]
|
|
return Score(
|
|
score=score,
|
|
minimum=cls._min_score,
|
|
maximum=cls._max_score,
|
|
detail=[IndividualScore(score=score, description=description)],
|
|
)
|
|
|
|
def __init_subclass__(cls) -> None:
|
|
try:
|
|
score_map = cls._score_map
|
|
except AttributeError:
|
|
raise exceptions.InternalError('"_score_map" must be set.')
|
|
if not score_map:
|
|
raise exceptions.InternalError("ScoredEnum must set _score_map.")
|
|
|
|
if set(score_map.keys()) != set(cls):
|
|
raise exceptions.InternalError(
|
|
"All enum members must be present in _score_map."
|
|
)
|
|
|
|
all_scores = [score for score, _ in score_map.values()]
|
|
cls._min_score = min(all_scores)
|
|
cls._max_score = max(all_scores)
|
|
|
|
|
|
class AuthMechanism(ScoredStrEnum):
|
|
NO_AUTH = auto()
|
|
PLAIN = auto()
|
|
HIDDEN = auto()
|
|
RESTRICTED = auto()
|
|
|
|
_score_map = enum.nonmember(
|
|
{
|
|
NO_AUTH: (20, D_("No authentication is needed.")),
|
|
PLAIN: (-20, D_("Your login data are transmitted to this service.")),
|
|
HIDDEN: (
|
|
0,
|
|
D_("This service logs to your account, but doesn't get logging data."),
|
|
),
|
|
RESTRICTED: (
|
|
15,
|
|
D_("This service logs to your account in a restricted way."),
|
|
),
|
|
}
|
|
)
|
|
|
|
|
|
class DataTransmission(ScoredStrEnum):
|
|
PLAIN = auto()
|
|
ENCRYPTED = auto()
|
|
E2E = auto()
|
|
GRE = auto()
|
|
|
|
_score_map = enum.nonmember(
|
|
{
|
|
PLAIN: (
|
|
-20,
|
|
D_(
|
|
"Data is transmitted without encryption. This is highly insecure and "
|
|
"risks data interception."
|
|
),
|
|
),
|
|
ENCRYPTED: (
|
|
0,
|
|
D_(
|
|
"Data is encrypted during transmission but not end-to-end. The "
|
|
"service can view the data."
|
|
),
|
|
),
|
|
E2E: (
|
|
10,
|
|
D_(
|
|
"Data is end-to-end encrypted from the service. Only the service and "
|
|
"the recipient(s) can view the data."
|
|
),
|
|
),
|
|
GRE: (
|
|
30,
|
|
D_(
|
|
"Data uses Gateway Relayed Encryption, ensuring end-to-end security, "
|
|
"only your and your recipient(s) can view the data. Highly secure."
|
|
),
|
|
),
|
|
}
|
|
)
|
|
|
|
|
|
class AccessPolicy(ScoredStrEnum):
|
|
ADMINS = auto()
|
|
MODERATORS = auto()
|
|
ORGANIZATION_MEMBER = auto()
|
|
GOVERNMENT = auto()
|
|
ADVERTISERS = auto()
|
|
PARTNERS = auto()
|
|
NONE = auto()
|
|
|
|
_score_map = enum.nonmember(
|
|
{
|
|
ADMINS: (
|
|
-5,
|
|
D_(
|
|
"Service administrators can access user data for operational "
|
|
"purposes."
|
|
),
|
|
),
|
|
MODERATORS: (
|
|
-10,
|
|
D_("Moderators can access user data within their moderation scope."),
|
|
),
|
|
ORGANIZATION_MEMBER: (
|
|
-15,
|
|
D_("Any organization member can access user data."),
|
|
),
|
|
GOVERNMENT: (
|
|
-10,
|
|
D_(
|
|
"Government authorities can access user data under legal "
|
|
"requirements."
|
|
),
|
|
),
|
|
ADVERTISERS: (
|
|
-30,
|
|
D_("Third-party advertisers can access user data for targeted ads."),
|
|
),
|
|
PARTNERS: (
|
|
-20,
|
|
D_("Business partners can access user data under agreements."),
|
|
),
|
|
NONE: (20, D_("No entity other than the user can access user data.")),
|
|
}
|
|
)
|
|
|
|
|
|
class DataPolicy(BaseModel):
|
|
"""Represents a data policy form as defined in Data Policy XEP.
|
|
|
|
Fields correspond to the data policy specification and may be None when not provided.
|
|
"""
|
|
|
|
model_config = ConfigDict(use_enum_values=True)
|
|
|
|
auth_data: AuthMechanism | None = None
|
|
data_transmission: DataTransmission | None = None
|
|
encryption_algorithm: str | None = None
|
|
data_retention: str | None = None
|
|
data_deletion: bool | None = None
|
|
encryption_at_rest: bool | None = None
|
|
tos: str | None = None
|
|
data_export: bool | None = None
|
|
access_policy: set[AccessPolicy] | None = None
|
|
full_erasure: bool | None = None
|
|
backup_frequency: str | None = None
|
|
backup_retention: str | None = None
|
|
extra_info: str | None = None
|
|
|
|
@computed_field
|
|
@property
|
|
def score(self) -> Score:
|
|
"""Calculate a score based on the filled fields.
|
|
|
|
This score helps assess the quality of the data policy at a glance.
|
|
"""
|
|
total_score = 0
|
|
overall_min = 0
|
|
overall_max = 0
|
|
detail = []
|
|
|
|
fields_names = set(self.__class__.model_fields.keys())
|
|
|
|
for field_name in fields_names:
|
|
score = getattr(self, f"_{field_name}_score")
|
|
if score is not None:
|
|
total_score += score.score
|
|
overall_min += score.minimum
|
|
overall_max += score.maximum
|
|
detail.extend(score.detail)
|
|
|
|
return Score(
|
|
score=total_score, minimum=overall_min, maximum=overall_max, detail=detail
|
|
)
|
|
|
|
@property
|
|
def _auth_data_score(self) -> Score | None:
|
|
if self.auth_data is None:
|
|
return None
|
|
|
|
return AuthMechanism.get_score(self.auth_data)
|
|
|
|
@property
|
|
def _data_transmission_score(self) -> Score | None:
|
|
if self.data_transmission is None:
|
|
return None
|
|
|
|
return DataTransmission.get_score(self.data_transmission)
|
|
|
|
@property
|
|
def _encryption_algorithm_score(self) -> Score | None:
|
|
ENCRYPTION_ALGORITHM_SET = (10, D_("The encryption algorithm is {}."))
|
|
ENCRYPTION_ALGORITHM_UNSET = (
|
|
-10,
|
|
D_("The encryption algorithm is not specified."),
|
|
)
|
|
ALL = (ENCRYPTION_ALGORITHM_SET, ENCRYPTION_ALGORITHM_UNSET)
|
|
if not self.data_transmission or self.data_transmission not in (
|
|
DataTransmission.E2E,
|
|
DataTransmission.ENCRYPTED,
|
|
):
|
|
return None
|
|
|
|
if self.encryption_algorithm:
|
|
score, desc = ENCRYPTION_ALGORITHM_SET
|
|
desc = desc.format(self.encryption_algorithm)
|
|
else:
|
|
score, desc = ENCRYPTION_ALGORITHM_UNSET
|
|
|
|
return Score(
|
|
score=0,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _data_retention_score(self) -> Score | None:
|
|
if self.data_retention is None:
|
|
return None
|
|
|
|
DATA_RETENTION_0 = (10, D_("The service does not store data."))
|
|
DATA_RETENTION_INFINITE = (
|
|
-15,
|
|
D_("Data is stored indefinitely, which may pose privacy risks."),
|
|
)
|
|
DATA_RETENTION_UNKNOWN = (-10, D_("Data retention policy is unknown."))
|
|
DATA_RETENTION_DEFAULT = (0, D_("Data is stored for {days:.02f} day(s)."))
|
|
DATA_RETENTION_INVALID = (-20, D_("Invalid data retention policy ({value!r})."))
|
|
ALL = [
|
|
DATA_RETENTION_0,
|
|
DATA_RETENTION_INFINITE,
|
|
DATA_RETENTION_UNKNOWN,
|
|
DATA_RETENTION_DEFAULT,
|
|
DATA_RETENTION_INVALID,
|
|
]
|
|
|
|
value = self.data_retention
|
|
if value == "0":
|
|
score, desc = DATA_RETENTION_0
|
|
elif value == "infinite":
|
|
score, desc = DATA_RETENTION_INFINITE
|
|
elif value == "unknown":
|
|
score, desc = DATA_RETENTION_UNKNOWN
|
|
else:
|
|
try:
|
|
hours = int(value)
|
|
days = hours / 24
|
|
desc = DATA_RETENTION_DEFAULT[1].format(days=days)
|
|
score = DATA_RETENTION_DEFAULT[0]
|
|
except ValueError:
|
|
score, desc = DATA_RETENTION_INVALID
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _data_deletion_score(self) -> Score | None:
|
|
if self.data_deletion is None:
|
|
return None
|
|
|
|
DATA_DELETION_TRUE = (20, D_("Users can delete data on this service."))
|
|
DATA_DELETION_FALSE = (-10, D_("Users cannot delete data on this service."))
|
|
ALL = [DATA_DELETION_TRUE, DATA_DELETION_FALSE]
|
|
|
|
score, desc = DATA_DELETION_TRUE if self.data_deletion else DATA_DELETION_FALSE
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _encryption_at_rest_score(self) -> Score | None:
|
|
if self.encryption_at_rest is None:
|
|
return None
|
|
|
|
ENCRYPTION_AT_REST_TRUE = (10, D_("Data is encrypted at rest."))
|
|
ENCRYPTION_AT_REST_FALSE = (-5, D_("Data is not encrypted at rest."))
|
|
ALL = [ENCRYPTION_AT_REST_TRUE, ENCRYPTION_AT_REST_FALSE]
|
|
|
|
score, desc = (
|
|
ENCRYPTION_AT_REST_TRUE
|
|
if self.encryption_at_rest
|
|
else ENCRYPTION_AT_REST_FALSE
|
|
)
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _tos_score(self) -> Score:
|
|
TOS_SET = (5, D_("Terms of Service are linked."))
|
|
TOS_UNSET = (-5, D_("Terms of Service are not linked."))
|
|
ALL = [TOS_SET, TOS_UNSET]
|
|
score, desc = TOS_SET if self.tos else TOS_UNSET
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _data_export_score(self) -> Score | None:
|
|
if self.data_export is None:
|
|
return None
|
|
|
|
DATA_EXPORT_TRUE = (15, D_("Users can export their data."))
|
|
DATA_EXPORT_FALSE = (-10, D_("Users cannot export their data."))
|
|
ALL = [DATA_EXPORT_TRUE, DATA_EXPORT_FALSE]
|
|
|
|
score, desc = DATA_EXPORT_TRUE if self.data_export else DATA_EXPORT_FALSE
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _full_erasure_score(self) -> Score | None:
|
|
if self.full_erasure is None:
|
|
return None
|
|
|
|
FULL_ERASURE_TRUE = (20, D_("Users can fully erase their account and data."))
|
|
FULL_ERASURE_FALSE = (-20, D_("Users cannot fully erase their account and data."))
|
|
ALL = [FULL_ERASURE_TRUE, FULL_ERASURE_FALSE]
|
|
|
|
score, desc = FULL_ERASURE_TRUE if self.full_erasure else FULL_ERASURE_FALSE
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _backup_frequency_score(self) -> Score | None:
|
|
if self.backup_frequency is None:
|
|
return None
|
|
|
|
BACKUP_FREQUENCY_0 = (0, D_("The service does not do backups."))
|
|
BACKUP_FREQUENCY_DEFAULT = (5, D_("Backups are done every {days:.02f} day(s)."))
|
|
BACKUP_FREQUENCY_INVALID = (-20, D_("Invalid backup frequency {value!r}."))
|
|
ALL = [
|
|
BACKUP_FREQUENCY_0,
|
|
BACKUP_FREQUENCY_DEFAULT,
|
|
BACKUP_FREQUENCY_INVALID,
|
|
]
|
|
|
|
value = self.backup_frequency
|
|
if value == "0":
|
|
score, desc = BACKUP_FREQUENCY_0
|
|
else:
|
|
try:
|
|
hours = int(value)
|
|
days = hours / 24
|
|
desc = BACKUP_FREQUENCY_DEFAULT[1].format(days=days)
|
|
score = BACKUP_FREQUENCY_DEFAULT[0]
|
|
except ValueError:
|
|
score, desc = BACKUP_FREQUENCY_INVALID
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _backup_retention_score(self) -> Score | None:
|
|
if self.backup_retention is None:
|
|
return None
|
|
|
|
BACKUP_RETENTION_0 = (0, D_("No backups are done."))
|
|
BACKUP_RETENTION_INFINITE = (-10, D_("Backups are stored indefinitely."))
|
|
BACKUP_RETENTION_UNKNOWN = (-5, D_("Backup retention policy is unknown."))
|
|
BACKUP_RETENTION_DEFAULT = (0, D_("Backups are kept for {days:.02f} day(s)."))
|
|
BACKUP_RETENTION_INVALID = (-20, D_("Invalid backup retention {value!r}."))
|
|
ALL = [
|
|
BACKUP_RETENTION_0,
|
|
BACKUP_RETENTION_INFINITE,
|
|
BACKUP_RETENTION_UNKNOWN,
|
|
BACKUP_RETENTION_DEFAULT,
|
|
BACKUP_RETENTION_INVALID,
|
|
]
|
|
|
|
value = self.backup_retention
|
|
if value == "0":
|
|
score, desc = BACKUP_RETENTION_0
|
|
elif value == "infinite":
|
|
score, desc = BACKUP_RETENTION_INFINITE
|
|
elif value == "unknown":
|
|
score, desc = BACKUP_RETENTION_UNKNOWN
|
|
else:
|
|
try:
|
|
hours = int(value)
|
|
days = hours / 24
|
|
desc = BACKUP_RETENTION_DEFAULT[1].format(days=days)
|
|
score = BACKUP_RETENTION_DEFAULT[0]
|
|
except ValueError:
|
|
score, desc = BACKUP_RETENTION_INVALID
|
|
|
|
return Score(
|
|
score=score,
|
|
minimum=min(score for score, _ in ALL),
|
|
maximum=max(score for score, _ in ALL),
|
|
detail=[IndividualScore(score=score, description=desc)],
|
|
)
|
|
|
|
@property
|
|
def _access_policy_score(self) -> Score | None:
|
|
if self.access_policy is None:
|
|
return None
|
|
|
|
total_score = 0
|
|
overall_min = 0
|
|
overall_max = 0
|
|
details = []
|
|
|
|
for policy in self.access_policy:
|
|
policy_score = AccessPolicy.get_score(policy)
|
|
total_score += policy_score.score
|
|
overall_min += policy_score.minimum
|
|
overall_max += policy_score.maximum
|
|
details.extend(policy_score.detail)
|
|
|
|
return Score(
|
|
score=total_score, minimum=overall_min, maximum=overall_max, detail=details
|
|
)
|
|
|
|
@property
|
|
def _extra_info_score(self) -> Score | None:
|
|
if self.extra_info is None:
|
|
return None
|
|
|
|
return Score(score=0, minimum=0, maximum=0, detail=[])
|
|
|
|
@classmethod
|
|
def from_data_form(cls, form: data_form.Form) -> "DataPolicy | None":
|
|
"""Create a DataPolicy instance from a Wokkel Data Form.
|
|
|
|
@param form: The data form to parse.
|
|
@return: Parsed DataPolicy instance or None if form type doesn't match.
|
|
"""
|
|
if not form.formNamespace or not form.formNamespace.startswith(
|
|
NS_DATA_POLICY_BASE
|
|
):
|
|
return None
|
|
|
|
fields = cls.model_fields.keys()
|
|
kwargs = {}
|
|
|
|
for name in fields:
|
|
if name not in form:
|
|
continue
|
|
|
|
value = form.get(name)
|
|
|
|
match name:
|
|
case "access_policy":
|
|
if not value:
|
|
continue
|
|
|
|
policy_set = set()
|
|
policies = [value] if not isinstance(value, list) else value
|
|
for policy in policies:
|
|
if policy:
|
|
policy_set.add(AccessPolicy(policy))
|
|
if policy_set:
|
|
kwargs[name] = policy_set
|
|
|
|
case "auth_data":
|
|
if value:
|
|
kwargs[name] = AuthMechanism(value)
|
|
|
|
case "data_transmission":
|
|
if value:
|
|
kwargs[name] = DataTransmission(value)
|
|
|
|
case "extra_info":
|
|
if isinstance(value, list):
|
|
kwargs[name] = "\n".join(str(line) for line in value)
|
|
else:
|
|
kwargs[name] = str(value)
|
|
|
|
case _:
|
|
kwargs[name] = value
|
|
|
|
return cls(**kwargs)
|
|
|
|
def to_data_form(
|
|
self, category: str | None = None, type_: str | None = None
|
|
) -> data_form.Form:
|
|
"""Convert this model to a Wokkel Data Form.
|
|
|
|
@return: Form with type='result' containing all non-None fields.
|
|
"""
|
|
if category is not None:
|
|
if type_ is not None:
|
|
raise exceptions.InternalError(
|
|
'If "category" is set, "type_" must be set too.'
|
|
)
|
|
form_ns = NS_DATA_POLICY_ID_TPL.format(category=category, type=type_)
|
|
else:
|
|
form_ns = NS_DATA_POLICY
|
|
form_fields = []
|
|
|
|
for name in self.__class__.model_fields.keys():
|
|
value = getattr(self, name)
|
|
if value is None:
|
|
continue
|
|
|
|
match name:
|
|
case "auth_data" | "data_transmission":
|
|
form_fields.append(
|
|
data_form.Field(
|
|
fieldType="list-single",
|
|
var=name,
|
|
value=value.value,
|
|
)
|
|
)
|
|
case (
|
|
"data_deletion"
|
|
| "encryption_at_rest"
|
|
| "data_export"
|
|
| "full_erasure"
|
|
):
|
|
form_fields.append(
|
|
data_form.Field(
|
|
fieldType="boolean",
|
|
var=name,
|
|
value=value,
|
|
)
|
|
)
|
|
case "access_policy":
|
|
field_values = [policy.value for policy in value]
|
|
form_fields.append(
|
|
data_form.Field(
|
|
fieldType="list-multi",
|
|
var=name,
|
|
values=field_values,
|
|
)
|
|
)
|
|
case "extra_info":
|
|
lines = value.split("\n")
|
|
form_fields.append(
|
|
data_form.Field(
|
|
fieldType="text-multi",
|
|
var=name,
|
|
values=lines,
|
|
)
|
|
)
|
|
case _:
|
|
form_fields.append(
|
|
data_form.Field(
|
|
fieldType="text-single",
|
|
var=name,
|
|
value=str(value),
|
|
)
|
|
)
|
|
|
|
return data_form.Form(
|
|
formType="result",
|
|
formNamespace=form_ns,
|
|
fields=form_fields,
|
|
)
|
|
|
|
|
|
class DataPolicies(BaseModel):
|
|
main: DataPolicy
|
|
services: dict[str, DataPolicy] = Field(
|
|
default=dict(),
|
|
description=(
|
|
"Identity to data policy map. Identity is used as key with the "
|
|
'template "{identity}:{type}".'
|
|
),
|
|
)
|
|
|
|
|
|
class DATA_POLICY:
|
|
namespace = NS_DATA_POLICY
|
|
|
|
def __init__(self, host: "LiberviaBackend") -> None:
|
|
log.info(f"plugin {PLUGIN_INFO[C.PI_NAME]!r} initialization")
|
|
self.host = host
|
|
host.register_namespace("data-policy", NS_DATA_POLICY)
|
|
host.bridge.add_method(
|
|
"data_policy_get",
|
|
".plugin",
|
|
in_sign="ss",
|
|
out_sign="s",
|
|
method=self._data_policy_get,
|
|
async_=True,
|
|
)
|
|
|
|
def _data_policy_get(self, target: str, profile_key: str) -> defer.Deferred[str]:
|
|
client = self.host.get_client(profile_key)
|
|
d = defer.ensureDeferred(self.get_data_policy(client, jid.JID(target)))
|
|
d.addCallback(
|
|
lambda data_policies: (
|
|
"" if data_policies is None else data_policies.model_dump_json()
|
|
)
|
|
)
|
|
d = cast(defer.Deferred[str], d)
|
|
return d
|
|
|
|
async def get_data_policy(
|
|
self, client: SatXMPPEntity, target_jid: jid.JID
|
|
) -> DataPolicies | None:
|
|
infos = await self.host.memory.disco.get_infos(client, target_jid)
|
|
|
|
if NS_DATA_POLICY not in infos.extensions:
|
|
return None
|
|
|
|
# Main data policy.
|
|
data_policy = DataPolicy.from_data_form(infos.extensions[NS_DATA_POLICY])
|
|
if data_policy is None:
|
|
log.error(f"DataPolicy should be found at this point.")
|
|
return None
|
|
|
|
data_policies = DataPolicies(main=data_policy)
|
|
|
|
# Now we looks for identities data policies.
|
|
for namespace, form in infos.extensions.items():
|
|
if namespace.startswith(NS_DATA_POLICY_ID_PREFIX) and namespace.endswith(
|
|
NS_DATA_POLICY_ID_SUFFIX
|
|
):
|
|
identity_data = namespace[
|
|
len(NS_DATA_POLICY_ID_PREFIX) : -len(NS_DATA_POLICY_ID_SUFFIX)
|
|
]
|
|
try:
|
|
category, type_ = identity_data.split(":", 1)
|
|
except ValueError:
|
|
log.warning(
|
|
"Invalid namespace for identity data policy: " f"{namespace!r}"
|
|
)
|
|
else:
|
|
id_data_policy = DataPolicy.from_data_form(form)
|
|
if id_data_policy is not None:
|
|
data_policies.services[f"{category}:{type_}"] = id_data_policy
|
|
return data_policies
|