fluidattacks_core_models 12.0.0__py3-none-any.whl

fluidattacks_core/models/scanners/__init__.py

@@ -0,0 +1,67 @@
+from fluidattacks_core.models.scanners.apk_config import ApkConfig, ApkEnvironment
+from fluidattacks_core.models.scanners.common_config import (
+    FalsePositivesConfig,
+    LocalesEnum,
+    OutputConfig,
+    OutputFormat,
+)
+from fluidattacks_core.models.scanners.containers_sca_config import (
+    ContainerImageConfig,
+    ContainerScaItem,
+    ContainersScaConfig,
+    DockerCredentialsConfig,
+    EcrCredentialsConfig,
+)
+from fluidattacks_core.models.scanners.cspm_config import AwsCredentials, AwsRole, CspmConfig
+from fluidattacks_core.models.scanners.dast_config import (
+    DastApiAuth,
+    DastApiConfig,
+    DastConfig,
+    DastUrl,
+)
+from fluidattacks_core.models.scanners.loader import build_config, load_yaml_mapping
+from fluidattacks_core.models.scanners.sast_config import SastConfig
+from fluidattacks_core.models.scanners.sbom_config import (
+    SbomAwsCredentials,
+    SbomConfig,
+    SbomDockerCredentials,
+    SbomOutputConfig,
+    SbomPlatformOverrides,
+    SourceType,
+)
+from fluidattacks_core.models.scanners.sca_config import ScaConfig
+from fluidattacks_core.models.scanners.scan_config import ScanConfig
+from fluidattacks_core.models.scanners.sniffs_config import SniffsConfig
+
+__all__ = [
+    "ApkConfig",
+    "ApkEnvironment",
+    "AwsCredentials",
+    "AwsRole",
+    "ContainerImageConfig",
+    "ContainerScaItem",
+    "ContainersScaConfig",
+    "CspmConfig",
+    "DastApiAuth",
+    "DastApiConfig",
+    "DastConfig",
+    "DastUrl",
+    "DockerCredentialsConfig",
+    "EcrCredentialsConfig",
+    "FalsePositivesConfig",
+    "LocalesEnum",
+    "OutputConfig",
+    "OutputFormat",
+    "SastConfig",
+    "SbomAwsCredentials",
+    "SbomConfig",
+    "SbomDockerCredentials",
+    "SbomOutputConfig",
+    "SbomPlatformOverrides",
+    "ScaConfig",
+    "ScanConfig",
+    "SniffsConfig",
+    "SourceType",
+    "build_config",
+    "load_yaml_mapping",
+]

fluidattacks_core/models/scanners/apk_config.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel, StrictBool
+
+
+class ApkEnvironment(BaseModel):
+    model_config = {"extra": "forbid"}
+    apk_file_path: str
+    environment_id: str | None = None
+
+    def __eq__(self, other: object) -> bool:
+        """Compare only on apk_file_path, ignoring environment_id."""
+        if not isinstance(other, ApkEnvironment):
+            return NotImplemented
+        return self.apk_file_path == other.apk_file_path
+
+    def __hash__(self) -> int:
+        """Hash only on apk_file_path, ignoring environment_id."""
+        return hash(self.apk_file_path)
+
+
+class ApkConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    include: list[str] = []
+    exclude: list[str] = []
+    use_sast_analysis: StrictBool = True
+    environments: list[ApkEnvironment] | None = None
+    feature_preview: StrictBool | None = None

fluidattacks_core/models/scanners/common_config.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class LocalesEnum(Enum):
+    EN = "EN"
+    ES = "ES"
+
+
+class OutputFormat(Enum):
+    CSV = "CSV"
+    SARIF = "SARIF"
+    ALL = "ALL"
+
+
+class OutputConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    file_path: str
+    format: OutputFormat
+
+
+class FalsePositivesConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    findings: list[str] = []
+    method_names: list[str] = []
+    cve: list[str] = []

fluidattacks_core/models/scanners/containers_sca_config.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, StrictBool
+
+
+class EcrCredentialsConfig(BaseModel):
+    model_config = {"extra": "allow"}
+    access_key_id: str | None = None
+    secret_access_key: str | None = None
+    session_token: str | None = None
+    role_arn: str | None = None
+    external_id: str | None = None
+    aws_region: str | None = None
+
+
+class DockerCredentialsConfig(BaseModel):
+    model_config = {"extra": "allow"}
+    docker_username: str
+    docker_password: str
+
+
+class ContainerImageConfig(BaseModel):
+    model_config = {"extra": "allow"}
+    use_docker_daemon: StrictBool | None = None
+    os_override: str | None = None
+    arch_override: str | None = None
+    ecr_credentials: EcrCredentialsConfig | None = None
+    docker_credentials: DockerCredentialsConfig | None = None
+
+
+class ContainerScaItem(BaseModel):
+    model_config = {"extra": "allow"}
+    image_uri: str
+    image_config: ContainerImageConfig | None = None
+
+
+class ContainersScaConfig(BaseModel):
+    model_config = {"extra": "allow"}
+    images: list[ContainerScaItem]

fluidattacks_core/models/scanners/cspm_config.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, Field, StrictBool, field_validator, model_validator
+
+from fluidattacks_core.models.scanners.loader import LoaderValidationInfo, resolve_env_var
+
+
+class AwsCredentials(BaseModel):
+    model_config = {"extra": "forbid"}
+    access_key_id: str
+    secret_access_key: str
+    session_token: str | None = None
+    environment_id: str | None = None
+
+    @field_validator("access_key_id", "secret_access_key", "session_token", mode="before")
+    @classmethod
+    def _resolve_credentials(cls, v: object, info: LoaderValidationInfo) -> object:
+        return resolve_env_var(v, info)
+
+    @model_validator(mode="after")
+    def _validate_key_session_token_pairing(self) -> "AwsCredentials":
+        is_temporary = self.access_key_id.startswith("ASIA")
+        if is_temporary and not self.session_token:
+            msg = "Temporary credentials (ASIA key) require a session_token"
+            raise ValueError(msg)
+        if not is_temporary and self.session_token:
+            msg = "Static credentials (AKIA key) must not include a session_token"
+            raise ValueError(msg)
+        return self
+
+
+class AwsRole(BaseModel):
+    model_config = {"extra": "forbid"}
+    role: str = Field(repr=False)
+    external_id: str | None = Field(default=None, repr=False)
+    environment_id: str | None = None
+
+    @field_validator("role", "external_id", mode="before")
+    @classmethod
+    def _resolve_credentials(cls, v: object, info: LoaderValidationInfo) -> object:
+        return resolve_env_var(v, info)
+
+
+class CspmConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    aws_credentials: list[AwsCredentials | AwsRole] = []
+    feature_preview: StrictBool | None = None

fluidattacks_core/models/scanners/dast_config.py

@@ -0,0 +1,47 @@
+from pydantic import BaseModel, StrictBool, field_validator
+
+from fluidattacks_core.models.scanners.loader import LoaderValidationInfo, resolve_env_var
+
+
+class DastUrl(BaseModel):
+    model_config = {"extra": "forbid"}
+    url: str
+    environment_id: str | None = None
+
+    def __eq__(self, other: object) -> bool:
+        """Compare only on url, ignoring environment_id."""
+        if not isinstance(other, DastUrl):
+            return NotImplemented
+        return self.url == other.url
+
+    def __hash__(self) -> int:
+        """Hash only on url, ignoring environment_id."""
+        return hash(self.url)
+
+
+class DastApiAuth(BaseModel):
+    model_config = {"extra": "forbid"}
+    type: str
+    key: str
+    value: str
+
+    @field_validator("key", "value", mode="before")
+    @classmethod
+    def _resolve_credentials(cls, v: object, info: LoaderValidationInfo) -> object:
+        return resolve_env_var(v, info)
+
+
+class DastApiConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    base_url: str
+    api_specs: list[str]
+    authentication: list[DastApiAuth] = []
+    environment_id: str | None = None
+
+
+class DastConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    urls: list[DastUrl] = []
+    api: list[DastApiConfig] = []
+    feature_preview: StrictBool | None = None
+    strict_connectivity: StrictBool = False

fluidattacks_core/models/scanners/loader.py

@@ -0,0 +1,74 @@
+import logging
+import os
+import re
+from collections.abc import Mapping
+from pathlib import Path
+from typing import TypeVar, cast
+
+import yaml
+from pydantic import BaseModel
+from pydantic import ValidationInfo as _PydanticValidationInfo
+
+LoaderValidationInfo = _PydanticValidationInfo[dict[str, bool] | None]
+
+T = TypeVar("T", bound=BaseModel)
+
+LOGGER = logging.getLogger(__name__)
+
+_ENV_PLACEHOLDER = re.compile(r"\$\{([A-Z_][A-Z0-9_]*)\}")
+
+
+def _sub_env_var(m: re.Match[str]) -> str:
+    var_name = m.group(1)
+    value = os.environ.get(var_name)
+    if value is None:
+        LOGGER.warning("env var '%s' not set; substituting empty string", var_name)
+        return ""
+    LOGGER.info("env var '%s' set", var_name)
+    return value
+
+
+def resolve_env_var(v: object, info: LoaderValidationInfo) -> object:
+    if not isinstance(v, str) or not (info.context or {}).get("resolve_env"):
+        return v
+    matches = list(_ENV_PLACEHOLDER.finditer(v))
+    if not matches:
+        return v
+    LOGGER.info("resolving %d placeholder(s) in field value", len(matches))
+    if len(matches) == 1 and matches[0].span() == (0, len(v)):
+        var_name = matches[0].group(1)
+        value = os.environ.get(var_name)
+        if value is None:
+            LOGGER.warning("env var '%s' not set; field will be None", var_name)
+            return None
+        LOGGER.info("env var '%s' set", var_name)
+        return value
+    return _ENV_PLACEHOLDER.sub(_sub_env_var, v)
+
+
+def load_yaml_mapping(path: str) -> Mapping[str, object]:
+    file_path = Path(path)
+    with file_path.open(encoding="utf-8") as file:
+        data = cast("object", yaml.safe_load(file))
+
+    if data is None:
+        return {}
+
+    if not isinstance(data, Mapping):
+        msg = "YAML root must be a mapping"
+        raise TypeError(msg)
+
+    return data
+
+
+def build_config(path: str, model_class: type[T]) -> T:
+    raw_data = load_yaml_mapping(path)
+    config = model_class.model_validate(raw_data, context={"resolve_env": True})
+    extras = cast("Mapping[str, object] | None", config.model_extra)
+    if extras:
+        LOGGER.warning(
+            "Some keys were not recognized: %s. "
+            "The analysis will be performed only using the supported keys",
+            ", ".join(sorted(extras)),
+        )
+    return config

fluidattacks_core/models/scanners/sast_config.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, StrictBool
+
+
+class SastConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    include: list[str] | None = None
+    exclude: list[str] | None = None
+    recursion_limit: int | None = None
+    use_inspects: StrictBool | None = None
+    file_size_limit: StrictBool | None = None
+    multifile: StrictBool | None = None
+    use_report_soon: StrictBool | None = None
+    report_drafts: StrictBool | None = None
+    include_sniffs: StrictBool | None = None
+    feature_preview: str | None = None

fluidattacks_core/models/scanners/sbom_config.py

@@ -0,0 +1,57 @@
+from enum import Enum
+
+from pydantic import BaseModel, StrictBool
+
+
+class SourceType(Enum):
+    DIRECTORY = "dir"
+    DOCKER = "docker"
+    DOCKER_DAEMON = "docker-daemon"
+    ECR = "ecr"
+    ECR_WITH_CREDENTIALS = "ecr-with-credentials"
+
+
+class SbomDockerCredentials(BaseModel):
+    model_config = {"extra": "forbid"}
+    username: str | None = None
+    password: str | None = None
+    use_docker_daemon: StrictBool | None = None
+
+
+class SbomPlatformOverrides(BaseModel):
+    model_config = {"extra": "forbid"}
+    os_override: str | None = None
+    arch_override: str | None = None
+
+
+class SbomAwsCredentials(BaseModel):
+    model_config = {"extra": "forbid"}
+    external_id: str | None = None
+    role: str | None = None
+    region: str | None = None
+    access_key_id: str | None = None
+    secret_access_key: str | None = None
+    session_token: str | None = None
+
+
+class SbomOutputConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    name: str
+    format: str
+
+
+class SbomConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    include: list[str] | None = None
+    exclude: list[str] | None = None
+    output: SbomOutputConfig | None = None
+    source: str | None = None
+    source_type: SourceType | None = None
+    image_uri: str | None = None
+    environment_id: str | None = None
+    docker_credentials: SbomDockerCredentials | None = None
+    platform_overrides: SbomPlatformOverrides | None = None
+    aws_credentials: SbomAwsCredentials | None = None
+    include_package_metadata: StrictBool | None = None
+    include_package_advisories: StrictBool | None = None
+    feature_preview: StrictBool | None = None

fluidattacks_core/models/scanners/sca_config.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, StrictBool
+
+
+class ScaExclusion(BaseModel):
+    model_config = {"extra": "forbid"}
+    CVE: str
+    paths: list[str]
+
+
+class ScaConfig(BaseModel):
+    model_config = {"extra": "forbid"}
+    include: list[str] | None = None
+    exclude: list[str] | None = None
+    use_spots_sca: StrictBool | None = None
+    feature_preview: StrictBool | None = None
+    exclusions: list[ScaExclusion] = []

fluidattacks_core/models/scanners/scan_config.py

@@ -0,0 +1,39 @@
+from pydantic import BaseModel, StrictBool
+
+from fluidattacks_core.models.scanners.apk_config import ApkConfig
+from fluidattacks_core.models.scanners.common_config import (
+    FalsePositivesConfig,
+    LocalesEnum,
+    OutputConfig,
+)
+from fluidattacks_core.models.scanners.containers_sca_config import ContainersScaConfig
+from fluidattacks_core.models.scanners.cspm_config import CspmConfig
+from fluidattacks_core.models.scanners.dast_config import DastConfig
+from fluidattacks_core.models.scanners.sast_config import SastConfig
+from fluidattacks_core.models.scanners.sbom_config import SbomConfig
+from fluidattacks_core.models.scanners.sca_config import ScaConfig
+from fluidattacks_core.models.scanners.sniffs_config import SniffsConfig
+
+
+class ScanConfig(BaseModel):
+    model_config = {"extra": "allow"}
+    working_dir: str | None = None
+    namespace: str | None = None
+    commit: str | None = None
+    language: LocalesEnum | None = None
+    execution_id: str | None = None
+    checks: list[str] | None = None
+    strict: StrictBool | None = None
+    strictness_threshold: str | None = None
+    tracing_opt_out: StrictBool | None = None
+    debug: StrictBool | None = None
+    output: OutputConfig | None = None
+    sast: SastConfig | None = None
+    sca: ScaConfig | None = None
+    containers_sca: ContainersScaConfig | None = None
+    sbom: SbomConfig | None = None
+    dast: DastConfig | None = None
+    cspm: CspmConfig | None = None
+    apk: ApkConfig | None = None
+    false_positives_identified: FalsePositivesConfig | None = None
+    ss: SniffsConfig | None = None

fluidattacks_core/models/scanners/sniffs_config.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, StrictBool
+
+
+class SniffsConfig(BaseModel):
+    model_config = {"extra": "allow"}
+    include: list[str] | None = None
+    exclude: list[str] | None = None
+    min_entropy: float | None = None
+    feature_preview: StrictBool | None = None

fluidattacks_core/models/state_machines/__init__.py

@@ -0,0 +1,35 @@
+from fluidattacks_core.models.state_machines.root_scanner import (
+    ContextualizesScanInput,
+    ContextualizesScanOptions,
+    PerRootScanOptions,
+    StateMachineExecutePerRootInput,
+    TJobNameSegment,
+    TracesScanInput,
+    TracesScanOptions,
+    TStorageKey,
+)
+from fluidattacks_core.models.state_machines.types import (
+    StateMachine,
+    StateMachineCloningInput,
+    StateMachineExecuteScannerInput,
+    StateMachineExecuteSiftsInput,
+    StateMachineRequestSbomMailInput,
+    TCloningTrigger,
+)
+
+__all__ = [
+    "ContextualizesScanInput",
+    "ContextualizesScanOptions",
+    "PerRootScanOptions",
+    "StateMachine",
+    "StateMachineCloningInput",
+    "StateMachineExecutePerRootInput",
+    "StateMachineExecuteScannerInput",
+    "StateMachineExecuteSiftsInput",
+    "StateMachineRequestSbomMailInput",
+    "TCloningTrigger",
+    "TJobNameSegment",
+    "TStorageKey",
+    "TracesScanInput",
+    "TracesScanOptions",
+]

fluidattacks_core/models/state_machines/root_scanner.py

@@ -0,0 +1,105 @@
+import re
+from hashlib import sha256
+from typing import Annotated, Generic, TypeVar
+
+from pydantic import (
+    AfterValidator,
+    BaseModel,
+    ConfigDict,
+    Field,
+    StringConstraints,
+    computed_field,
+)
+
+MACHINE_NAME_DIGEST_LENGTH = 18
+MAX_EXECUTION_NAME = 80
+
+STORAGE_KEY_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]*\Z")
+UNSAFE_NAME_CHARS = re.compile(r"[^A-Za-z0-9_-]")
+
+
+def _ensure_storage_key(value: str) -> str:
+    if not STORAGE_KEY_PATTERN.fullmatch(value) or ".." in value:
+        msg = f"invalid storage key: {value!r}"
+        raise ValueError(msg)
+    return value
+
+
+TStorageKey = Annotated[str, AfterValidator(_ensure_storage_key)]
+TVisibleAscii = Annotated[str, StringConstraints(pattern=r"^[!-~]+$")]
+TJobNameSegment = Annotated[
+    str, StringConstraints(min_length=1, pattern=r"^[A-Za-z0-9][A-Za-z0-9_-]*$")
+]
+
+
+class PerRootScanOptions(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True, revalidate_instances="always")
+    config_id: TStorageKey
+    group_name: TStorageKey
+    root_nickname: TStorageKey
+    user_email: TVisibleAscii = Field(..., min_length=1)
+
+
+class ContextualizesScanOptions(PerRootScanOptions):
+    pass
+
+
+class TracesScanOptions(PerRootScanOptions):
+    root_id: TStorageKey
+    commit: Annotated[str, StringConstraints(pattern=r"^[0-9a-f]{40}$")]
+
+
+TOptions = TypeVar("TOptions", bound=PerRootScanOptions)
+
+
+class StateMachineExecutePerRootInput(BaseModel, Generic[TOptions]):
+    model_config = ConfigDict(extra="forbid", frozen=True, serialize_by_alias=True)
+    job_definition: str = Field(..., min_length=1, serialization_alias="jobDefinition")
+    job_queue: str = Field(..., min_length=1, serialization_alias="jobQueue")
+    scanner_name: TJobNameSegment = Field(..., serialization_alias="scannerName")
+    options: TOptions = Field(..., exclude=True)
+
+    @computed_field(alias="configId")  # type: ignore[prop-decorator]
+    @property
+    def config_id(self) -> str:
+        return self.options.config_id
+
+    @computed_field(alias="groupName")  # type: ignore[prop-decorator]
+    @property
+    def group_name(self) -> str:
+        return self.options.group_name
+
+    @computed_field(alias="rootNickname")  # type: ignore[prop-decorator]
+    @property
+    def root_nickname(self) -> str:
+        return self.options.root_nickname
+
+    @computed_field(alias="executionOptions")  # type: ignore[prop-decorator]
+    @property
+    def execution_options(self) -> str:
+        return self.options.model_dump_json()
+
+    def to_wire(self) -> dict[str, str]:
+        return self.model_dump(mode="json", by_alias=True)
+
+    def get_machine_name(self) -> str:
+        digest = sha256(
+            (
+                f"{self.options.group_name}\x00{self.options.root_nickname}"
+                f"\x00{self.scanner_name}\x00{self.options.config_id}"
+            ).encode()
+        ).hexdigest()[:MACHINE_NAME_DIGEST_LENGTH]
+        readable = UNSAFE_NAME_CHARS.sub(
+            "_",
+            f"{self.options.group_name}_{self.options.root_nickname}_{self.scanner_name}",
+        )
+        budget = MAX_EXECUTION_NAME - MACHINE_NAME_DIGEST_LENGTH - 1
+        return f"{readable[:budget]}_{digest}"
+
+
+class ContextualizesScanInput(StateMachineExecutePerRootInput[ContextualizesScanOptions]):
+    pass
+
+
+class TracesScanInput(StateMachineExecutePerRootInput[TracesScanOptions]):
+    pass

fluidattacks_core/models/state_machines/types.py

@@ -0,0 +1,99 @@
+from datetime import datetime
+from functools import cached_property
+from typing import Literal, NamedTuple
+from uuid import uuid4
+
+from pydantic import BaseModel, Field, computed_field
+
+TCloningTrigger = Literal[
+    "clone_with_warp_scheduler",
+    "clone_no_special_network",
+    "root_activation",
+    "upload_git_root_file_mutation",
+    "add_git_root_mutation",
+    "migration",
+    "update_git_root_mutation",
+    "execute_machine_flow",
+    "sync_git_root_mutation",
+    "update_group_mutation",
+    "update_group_managed_mutation",
+    "reattack",
+    "clone_roots_that_have_not_cloned",
+    "re_queue_reattacks_scheduler",
+]
+
+
+class StateMachine(NamedTuple):
+    arn: str
+    name: str
+    creation_date: datetime
+
+
+class StateMachineCloningInput(BaseModel):
+    model_config = {"extra": "forbid"}
+    group_name: str = Field(..., serialization_alias="groupName")
+    network_name: str | None = Field(default=None, serialization_alias="networkName")
+    roots: list[str] = Field(..., serialization_alias="roots")
+    user_email: str = Field(..., serialization_alias="userEmail")
+    trigger: TCloningTrigger = Field(serialization_alias="trigger")
+    execute_sifts: bool = Field(..., serialization_alias="executeSifts")
+    cloning_job_queue: str = Field(
+        default="integrates_clone", serialization_alias="cloningJobQueue"
+    )
+
+    @computed_field(alias="configId")  # type: ignore[prop-decorator]
+    @cached_property
+    def config_id(self) -> str:
+        return str(uuid4().time)
+
+    def get_machine_name(self) -> str:
+        return f"{self.group_name}_{self.trigger}-{self.config_id}"
+
+
+class StateMachineExecuteScannerInput(BaseModel):
+    model_config = {"extra": "forbid"}
+    config_id: str = Field(
+        default_factory=lambda: str(uuid4().time), serialization_alias="configId"
+    )
+    group_name: str = Field(..., serialization_alias="groupName")
+    image_refs: list[str] | None = Field(default=None, serialization_alias="imageRefs")
+    job_definition: str = Field(..., serialization_alias="jobDefinition")
+    job_queue: str = Field(..., serialization_alias="jobQueue")
+    job_origin: str = Field(..., serialization_alias="jobOrigin", exclude=True)
+    network_name: str | None = Field(default=None, serialization_alias="networkName")
+    roots: list[str] = Field(..., min_length=1, serialization_alias="roots")
+    scanner_name: str = Field(..., serialization_alias="scannerName")
+    user_email: str = Field(..., serialization_alias="userEmail")
+
+    def get_machine_name(self) -> str:
+        return f"{self.group_name}_{self.job_origin}_{self.scanner_name}_{self.config_id}"
+
+
+class StateMachineExecuteSiftsInput(BaseModel):
+    model_config = {"extra": "forbid"}
+    config_id: str = Field(
+        default_factory=lambda: str(uuid4().time), serialization_alias="configId"
+    )
+    group_name: str = Field(..., serialization_alias="groupName")
+    root_nickname: str = Field(..., serialization_alias="rootNickname")
+    trigger: TCloningTrigger = Field(..., serialization_alias="trigger")
+    user_email: str = Field(..., serialization_alias="userEmail")
+
+    def get_machine_name(self) -> str:
+        return f"{self.group_name}_{self.trigger}_execute_sifts_{self.config_id}"
+
+
+class StateMachineRequestSbomMailInput(BaseModel):
+    model_config = {"extra": "forbid"}
+    config_id: str = Field(
+        default_factory=lambda: str(uuid4().time), serialization_alias="configId"
+    )
+    group_name: str = Field(..., serialization_alias="groupName")
+    item_kind: Literal["root", "image"] = Field(..., serialization_alias="itemKind")
+    item_name: str = Field(..., serialization_alias="itemName")
+    notification_id: str = Field(..., serialization_alias="notificationId")
+    user_email: str = Field(..., serialization_alias="userEmail")
+    sbom_format: str = Field(..., serialization_alias="sbomFormat")
+
+    def get_machine_name(self) -> str:
+        return f"{self.group_name}_request_sbom_mail_{self.config_id}"

fluidattacks_core_models-12.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.5
+Name: fluidattacks_core_models
+Version: 12.0.0
+Summary: Fluid Attacks Core Models Library
+Author-email: Development <development@fluidattacks.com>
+License: MPL-2.0
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.12.3
+Requires-Dist: pyyaml>=6.0.2

fluidattacks_core_models-12.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+fluidattacks_core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_core/models/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_core/models/scanners/__init__.py,sha256=dsVrg8xfgSoqdfui5bHysLDITmpErDfJoB6K6kdhKYI,1873
+fluidattacks_core/models/scanners/apk_config.py,sha256=KpR5DKXSO5-P8DMAbOhMnyWwb92Uxdv_XYBGYTErRE8,839
+fluidattacks_core/models/scanners/common_config.py,sha256=YvlaE2ClSSnVD5UFMVWeu5eiMR70GMIzyDvG2oekeRI,471
+fluidattacks_core/models/scanners/containers_sca_config.py,sha256=vSXHwck7IzcP2jNBm4IB3TClcVriS-r9mEVCMsigVQU,1047
+fluidattacks_core/models/scanners/cspm_config.py,sha256=CFG-LVjlbPBSdpCpXtZdYs0oEJu2FOGDHF0fXLdvdZc,1703
+fluidattacks_core/models/scanners/dast_config.py,sha256=cGZnYcJGWEFdV0g_RNl-HKwDhPyIHYO2PlMg2eOim7I,1336
+fluidattacks_core/models/scanners/loader.py,sha256=l9kOUbDlCv-0R3LmJbOkwoXGUC7qNE4dEWiBZPVllr8,2297
+fluidattacks_core/models/scanners/sast_config.py,sha256=iWy9icaE3UGvfBWLF5GMWBtLxYLbc6wPvTF3Yph4vfA,529
+fluidattacks_core/models/scanners/sbom_config.py,sha256=ZisA15KwVnT587qO9wDKTYXDmfl1elOqKoJTUDWgHes,1638
+fluidattacks_core/models/scanners/sca_config.py,sha256=SWh5gLS803vr7_9hdO4-7Y3PDof8TitLBdPUa16Kt9g,422
+fluidattacks_core/models/scanners/scan_config.py,sha256=OShUdsFAA31bmUh2cJcf9ODhmLMnakHQ7dliVbiyWbc,1583
+fluidattacks_core/models/scanners/sniffs_config.py,sha256=mHebiayRToLn0EjT4xbxiwmEi-LNc6VpuhQnUzoqtE4,271
+fluidattacks_core/models/state_machines/__init__.py,sha256=wSsH_I1Y-Md-Ele3EftdwbdA7HBl8VG1JwyC5_REQEY,938
+fluidattacks_core/models/state_machines/root_scanner.py,sha256=FQZk7-zuE1D12GjFHLERpIW3Idd3fkLhq6pmFPDvKbo,3365
+fluidattacks_core/models/state_machines/types.py,sha256=5wPuLTEjapYvQg9DYAgmo2BaDxZQl1ZKMtiKX_izkJo,3967
+fluidattacks_core_models-12.0.0.dist-info/METADATA,sha256=k3KybJsmyKRQ7ZaBuDtbgLBMVMFQl4LlSTyvO6IAC0E,592
+fluidattacks_core_models-12.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+fluidattacks_core_models-12.0.0.dist-info/RECORD,,

fluidattacks_core_models-12.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any