pyoaev 1.18.20__py3-none-any.whl

pyoaev/apis/injector_contract.py

@@ -0,0 +1,56 @@
+from typing import Any, Dict
+
+from pyoaev import exceptions as exc
+from pyoaev.apis.inputs.search import InjectorContractSearchPaginationInput
+from pyoaev.base import RESTManager, RESTObject
+from pyoaev.mixins import CreateMixin, DeleteMixin, UpdateMixin
+from pyoaev.utils import RequiredOptional
+
+
+class InjectorContract(RESTObject):
+    pass
+
+
+class InjectorContractManager(CreateMixin, UpdateMixin, DeleteMixin, RESTManager):
+    _path = "/injector_contracts"
+    _obj_cls = InjectorContract
+    _create_attrs = RequiredOptional(
+        required=(
+            "contract_content",
+            "contract_id",
+            "contract_labels",
+            "injector_id",
+        ),
+        optional=(
+            "contract_attack_patterns_ids",
+            "contract_attack_patterns_external_ids",
+            "contract_vulnerability_external_ids",
+            "contract_manual",
+            "contract_platforms",
+            "external_contract_id",
+            "is_atomic_testing",
+        ),
+    )
+    _update_attrs = RequiredOptional(
+        required=(
+            "contract_content",
+            "contract_labels",
+        ),
+        optional=(
+            "contract_attack_patterns_ids",
+            "contract_vulnerability_ids",
+            "contract_vulnerability_external_ids",
+            "contract_manual",
+            "contract_platforms",
+            "is_atomic_testing",
+        ),
+    )
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def search(
+        self, input: InjectorContractSearchPaginationInput, **kwargs: Any
+    ) -> Dict[str, Any]:
+        path = f"{self.path}/search"
+        # force the serialisation here since we only need a naive serialisation to json
+        result = self.openaev.http_post(path, post_data=input.to_dict(), **kwargs)
+        return result

pyoaev/apis/inputs/search.py

@@ -0,0 +1,72 @@
+from typing import Any, Dict, List
+
+
+class Filter:
+    def __init__(self, key: str, mode: str, operator: str, values: List[str]):
+        self.key = key
+        self.mode = mode
+        self.operator = operator
+        self.values = values
+
+    def to_dict(self) -> dict[str, Any]:
+        return {k: v for k, v in self.__dict__.items() if v is not None}
+
+
+class FilterGroup:
+    def __init__(self, mode: str, filters: List[Filter]):
+        self.mode = mode
+        self.filters = filters
+
+    def to_dict(self) -> dict[str, Any]:
+        dictionary: dict[str, Any] = {"mode": self.mode}
+        if self.filters:
+            filter_dicts: List[dict[str, Any]] = []
+            for filter_ in self.filters:
+                filter_dicts.append(filter_.to_dict())
+            dictionary["filters"] = filter_dicts
+        return dictionary
+
+
+class SearchPaginationInput:
+    def __init__(
+        self,
+        page: int,
+        size: int,
+        filter_group: FilterGroup,
+        text_search: str,
+        sorts: Dict[str, str],
+    ):
+        self.size = size
+        self.page = page
+        self.filterGroup = filter_group
+        self.text_search = text_search
+        self.sorts = sorts
+
+    def to_dict(self) -> dict[str, Any]:
+        dictionary: dict[str, Any] = {"page": self.page, "size": self.size}
+        if self.sorts:
+            dictionary["sorts"] = self.sorts
+        if self.text_search:
+            dictionary["textSearch"] = self.text_search
+        if self.filterGroup:
+            dictionary["filterGroup"] = self.filterGroup.to_dict()
+        return dictionary
+
+
+class InjectorContractSearchPaginationInput(SearchPaginationInput):
+    def __init__(
+        self,
+        page: int,
+        size: int,
+        filter_group: FilterGroup,
+        text_search: str = None,
+        sorts: Dict[str, str] = None,
+        include_full_details: bool = True,
+    ):
+        super().__init__(page, size, filter_group, text_search, sorts)
+        self.include_full_details = include_full_details
+
+    def to_dict(self) -> dict[str, Any]:
+        dictionary: dict[str, Any] = super().to_dict()
+        dictionary["include_full_details"] = self.include_full_details
+        return dictionary

pyoaev/apis/kill_chain_phase.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict, List
+
+from pyoaev import exceptions as exc
+from pyoaev.base import RESTManager, RESTObject
+
+
+class KillChainPhase(RESTObject):
+    _id_attr = "phase_id"
+
+
+class KillChainPhaseManager(RESTManager):
+    _path = "/kill_chain_phases"
+    _obj_cls = KillChainPhase
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def upsert(
+        self, kill_chain_phases: List[Dict[str, Any]], **kwargs: Any
+    ) -> Dict[str, Any]:
+        data = {"kill_chain_phases": kill_chain_phases}
+        path = f"{self.path}/upsert"
+        result = self.openaev.http_post(path, post_data=data, **kwargs)
+        return result

pyoaev/apis/me.py

@@ -0,0 +1,17 @@
+from typing import Any, cast
+
+from pyoaev.base import RESTManager, RESTObject
+from pyoaev.mixins import GetWithoutIdMixin, UpdateMixin
+
+
+class Me(RESTObject):
+    _id_attr = None
+    _repr_attr = "user_email"
+
+
+class MeManager(GetWithoutIdMixin, UpdateMixin, RESTManager):
+    _path = "/me"
+    _obj_cls = Me
+
+    def get(self, **kwargs: Any) -> Me:
+        return cast(Me, super().get(**kwargs))

pyoaev/apis/organization.py

@@ -0,0 +1,11 @@
+from pyoaev.base import RESTManager, RESTObject
+from pyoaev.mixins import ListMixin, UpdateMixin
+
+
+class Organization(RESTObject):
+    pass
+
+
+class OrganizationManager(ListMixin, UpdateMixin, RESTManager):
+    _path = "/organizations"
+    _obj_cls = Organization

pyoaev/apis/payload.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+
+from pyoaev import exceptions as exc
+from pyoaev.base import RESTManager, RESTObject
+
+
+class Payload(RESTObject):
+    _id_attr = "payload_id"
+
+
+class PayloadManager(RESTManager):
+    _path = "/payloads"
+    _obj_cls = Payload
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def upsert(self, payload: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]:
+        path = f"{self.path}/upsert"
+        result = self.openaev.http_post(path, post_data=payload, **kwargs)
+        return result
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def deprecate(
+        self, payloads_processed: Dict[str, Any], **kwargs: Any
+    ) -> Dict[str, Any]:
+        path = f"{self.path}/deprecate"
+        result = self.openaev.http_post(path, post_data=payloads_processed, **kwargs)
+        return result

pyoaev/apis/security_platform.py

@@ -0,0 +1,33 @@
+from typing import Any, Dict
+
+from pyoaev import exceptions as exc
+from pyoaev.base import RESTManager, RESTObject
+from pyoaev.mixins import CreateMixin, GetMixin, ListMixin, UpdateMixin
+from pyoaev.utils import RequiredOptional
+
+
+class SecurityPlatform(RESTObject):
+    pass
+
+
+class SecurityPlatformManager(
+    GetMixin, ListMixin, CreateMixin, UpdateMixin, RESTManager
+):
+    _path = "/security_platforms"
+    _obj_cls = SecurityPlatform
+    _create_attrs = RequiredOptional(
+        required=("asset_name", "security_platform_type"),
+        optional=(
+            "asset_description",
+            "security_platform_logo_light",
+            "security_platform_logo_dark",
+        ),
+    )
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def upsert(
+        self, security_platform: Dict[str, Any], **kwargs: Any
+    ) -> Dict[str, Any]:
+        path = f"{self.path}/upsert"
+        result = self.openaev.http_post(path, post_data=security_platform, **kwargs)
+        return result

pyoaev/apis/tag.py

@@ -0,0 +1,19 @@
+from typing import Any, Dict
+
+from pyoaev import exceptions as exc
+from pyoaev.base import RESTManager, RESTObject
+
+
+class Tag(RESTObject):
+    _id_attr = "tag_id"
+
+
+class TagManager(RESTManager):
+    _path = "/tags"
+    _obj_cls = Tag
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def upsert(self, data: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]:
+        path = f"{self.path}/upsert"
+        result = self.openaev.http_post(path, post_data=data, **kwargs)
+        return result

pyoaev/apis/team.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict
+
+from pyoaev import exceptions as exc
+from pyoaev.base import RESTManager, RESTObject
+from pyoaev.mixins import CreateMixin, ListMixin, UpdateMixin
+from pyoaev.utils import RequiredOptional
+
+
+class Team(RESTObject):
+    _id_attr = "team_id"
+
+
+class TeamManager(CreateMixin, ListMixin, UpdateMixin, RESTManager):
+    _path = "/teams"
+    _obj_cls = Team
+    _create_attrs = RequiredOptional(
+        required=("team_name",),
+        optional=("team_description", "team_organization", "team_tags"),
+    )
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def upsert(self, team: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]:
+        path = f"{self.path}/upsert"
+        result = self.openaev.http_post(path, post_data=team, **kwargs)
+        return result

pyoaev/apis/user.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict
+
+from pyoaev import exceptions as exc
+from pyoaev.base import RESTManager, RESTObject
+from pyoaev.mixins import CreateMixin, ListMixin, UpdateMixin
+from pyoaev.utils import RequiredOptional
+
+
+class User(RESTObject):
+    _id_attr = "user_id"
+
+
+class UserManager(CreateMixin, ListMixin, UpdateMixin, RESTManager):
+    _path = "/players"
+    _obj_cls = User
+    _create_attrs = RequiredOptional(
+        required=("user_email",),
+        optional=(
+            "user_firstname",
+            "user_lastname",
+            "user_organization",
+            "user_country",
+            "user_tags",
+        ),
+    )
+
+    @exc.on_http_error(exc.OpenAEVUpdateError)
+    def upsert(self, user: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]:
+        path = f"{self.path}/upsert"
+        result = self.openaev.http_post(path, post_data=user, **kwargs)
+        return result

pyoaev/backends/__init__.py

@@ -0,0 +1,14 @@
+"""
+Defines http backends for processing http requests
+"""
+
+from .backend import RequestsBackend, RequestsResponse, TokenAuth
+
+DefaultBackend = RequestsBackend
+DefaultResponse = RequestsResponse
+
+__all__ = [
+    "DefaultBackend",
+    "DefaultResponse",
+    "TokenAuth",
+]

pyoaev/backends/backend.py

@@ -0,0 +1,136 @@
+import dataclasses
+import json
+from typing import TYPE_CHECKING, Any, BinaryIO, Dict, Optional, Union
+
+import requests
+from requests import PreparedRequest
+from requests.auth import AuthBase
+from requests.structures import CaseInsensitiveDict
+from requests_toolbelt.multipart.encoder import MultipartEncoder  # type: ignore
+
+from pyoaev.backends import protocol
+
+
+class Auth:
+    def __init__(self, token: str):
+        self.token = token
+
+
+class TokenAuth(Auth, AuthBase):
+    def __call__(self, r: PreparedRequest) -> PreparedRequest:
+        r.headers["Authorization"] = f"Bearer {self.token}"
+        return r
+
+
+@dataclasses.dataclass
+class SendData:
+    content_type: str
+    data: Optional[Union[Dict[str, Any], MultipartEncoder]] = None
+    json: Optional[Union[Dict[str, Any], bytes]] = None
+
+    def __post_init__(self) -> None:
+        if self.json is not None and self.data is not None:
+            raise ValueError(
+                f"`json` and `data` are mutually exclusive. Only one can be set. "
+                f"json={self.json!r}  data={self.data!r}"
+            )
+
+
+class RequestsResponse(protocol.BackendResponse):
+    def __init__(self, response: requests.Response) -> None:
+        self._response: requests.Response = response
+
+    @property
+    def response(self) -> requests.Response:
+        return self._response
+
+    @property
+    def status_code(self) -> int:
+        return self._response.status_code
+
+    @property
+    def headers(self) -> CaseInsensitiveDict[str]:
+        return self._response.headers
+
+    @property
+    def content(self) -> bytes:
+        return self._response.content
+
+    @property
+    def reason(self) -> str:
+        return self._response.reason
+
+    def json(self) -> Any:
+        return self._response.json()
+
+
+class RequestsBackend(protocol.Backend):
+    def __init__(self, session: Optional[requests.Session] = None) -> None:
+        self._client: requests.Session = session or requests.Session()
+
+    @property
+    def client(self) -> requests.Session:
+        return self._client
+
+    @staticmethod
+    def prepare_send_data(
+        files: Optional[Dict[str, Any]] = None,
+        post_data: Optional[Union[Dict[str, Any], bytes, BinaryIO]] = None,
+        raw: bool = False,
+    ) -> SendData:
+        if files is not None:
+            json_data = {"input": (None, json.dumps(post_data), "application/json")}
+            post_data = {**files, **json_data}
+            multipart_encoder = MultipartEncoder(fields=post_data)
+            return SendData(
+                data=multipart_encoder, content_type=multipart_encoder.content_type
+            )
+
+        if raw and post_data:
+            return SendData(data=post_data, content_type="application/octet-stream")
+
+        if TYPE_CHECKING:
+            assert not isinstance(post_data, BinaryIO)
+
+        return SendData(json=post_data, content_type="application/json")
+
+    def http_request(
+        self,
+        method: str,
+        url: str,
+        json: Optional[Union[Dict[str, Any], bytes]] = None,
+        data: Optional[Union[Dict[str, Any], MultipartEncoder]] = None,
+        params: Optional[Any] = None,
+        timeout: Optional[float] = None,
+        verify: Optional[Union[bool, str]] = True,
+        stream: Optional[bool] = False,
+        **kwargs: Any,
+    ) -> RequestsResponse:
+        """Make HTTP request
+
+        Args:
+            method: The HTTP method to call ('get', 'post', 'put', 'delete', etc.)
+            url: The full URL
+            data: The data to send to the server in the body of the request
+            json: Data to send in the body in json by default
+            timeout: The timeout, in seconds, for the request
+            verify: Whether SSL certificates should be validated. If
+                the value is a string, it is the path to a CA file used for
+                certificate validation.
+            stream: Whether the data should be streamed
+
+        Returns:
+            A requests Response object.
+        """
+        response: requests.Response = self._client.request(
+            method=method,
+            url=url,
+            params=params,
+            data=data,
+            timeout=timeout,
+            stream=stream,
+            verify=verify,
+            json=json,
+            **kwargs,
+        )
+        return RequestsResponse(response=response)

pyoaev/backends/protocol.py

@@ -0,0 +1,32 @@
+import abc
+import sys
+from typing import Any, Dict, Optional, Union
+
+import requests
+from requests_toolbelt.multipart.encoder import MultipartEncoder  # type: ignore
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from typing_extensions import Protocol
+
+
+class BackendResponse(Protocol):
+    @abc.abstractmethod
+    def __init__(self, response: requests.Response) -> None: ...
+
+
+class Backend(Protocol):
+    @abc.abstractmethod
+    def http_request(
+        self,
+        method: str,
+        url: str,
+        json: Optional[Union[Dict[str, Any], bytes]],
+        data: Optional[Union[Dict[str, Any], MultipartEncoder]],
+        params: Optional[Any],
+        timeout: Optional[float],
+        verify: Optional[Union[bool, str]],
+        stream: Optional[bool],
+        **kwargs: Any,
+    ) -> BackendResponse: ...