mrok 0.1.9__tar.gz → 0.2.1__tar.gz

{mrok-0.1.9 → mrok-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.1.9
+Version: 0.2.1
 Summary: MPT Extensions OpenZiti Orchestrator
 Author: SoftwareOne AG
 License:                                  Apache License
@@ -206,6 +206,7 @@ License:                                  Apache License
            limitations under the License.
 License-File: LICENSE.txt
 Requires-Python: <4,>=3.12
+Requires-Dist: asn1crypto<2.0.0,>=1.5.1
 Requires-Dist: cryptography<46.0.0,>=45.0.7
 Requires-Dist: dynaconf<4.0.0,>=3.2.11
 Requires-Dist: fastapi-pagination<0.15.0,>=0.14.1

{mrok-0.1.9 → mrok-0.2.1}/mrok/controller/app.py

@@ -8,7 +8,8 @@ from fastapi.routing import APIRoute, APIRouter
 from mrok.conf import get_settings
 from mrok.controller.auth import authenticate
 from mrok.controller.openapi import generate_openapi_spec
-from mrok.controller.routes import router as extensions_router
+from mrok.controller.routes.extensions import router as extensions_router
+from mrok.controller.routes.instances import router as instances_router
 
 logger = logging.getLogger(__name__)
 
@@ -52,6 +53,7 @@ def setup_app():
     app.include_router(
         extensions_router, prefix="/extensions", dependencies=[Depends(authenticate)]
     )
+    app.include_router(instances_router, prefix="/instances", dependencies=[Depends(authenticate)])
 
     settings = get_settings()
 

mrok-0.2.1/mrok/controller/routes/instances.py

@@ -0,0 +1,71 @@
+import logging
+
+from fastapi import APIRouter, HTTPException, status
+
+from mrok.controller.dependencies import ZitiManagementAPI
+from mrok.controller.openapi import examples
+from mrok.controller.pagination import LimitOffsetPage, paginate
+from mrok.controller.schemas import InstanceRead
+
+logger = logging.getLogger("mrok.controller")
+
+router = APIRouter()
+
+
+async def fetch_instance_or_404(mgmt_api: ZitiManagementAPI, id_or_instance_id: str):
+    identity = await mgmt_api.search_identity(id_or_instance_id)
+    if not identity:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+    return identity
+
+
+@router.get(
+    "/{id_or_instance_id}",
+    response_model=InstanceRead,
+    responses={
+        200: {
+            "description": "Instance",
+            "content": {"application/json": {"example": examples.INSTANCE_RESPONSE}},
+        },
+    },
+    dependencies=[],
+    tags=["Instances"],
+)
+async def get_instance_by_id_or_instance_id(
+    mgmt_api: ZitiManagementAPI,
+    id_or_instance_id: str,
+):
+    identity = await fetch_instance_or_404(mgmt_api, id_or_instance_id)
+    return InstanceRead(**identity)
+
+
+@router.get(
+    "",
+    response_model=LimitOffsetPage[InstanceRead],
+    responses={
+        200: {
+            "description": "List of Instances",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "data": [examples.INSTANCE_RESPONSE],
+                        "$meta": {
+                            "pagination": {
+                                "total": 1,
+                                "limit": 10,
+                                "offset": 0,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    tags=["Instances"],
+)
+async def get_instances(
+    mgmt_api: ZitiManagementAPI,
+):
+    return await paginate(mgmt_api, "/identities", InstanceRead)

{mrok-0.1.9 → mrok-0.2.1}/mrok/ziti/pki.py

@@ -1,9 +1,9 @@
 import base64
 
+from asn1crypto import cms
 from cryptography import x509
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.hazmat.primitives.serialization.pkcs7 import load_der_pkcs7_certificates
 from cryptography.x509.oid import NameOID
 
 from mrok.ziti.api import ZitiManagementAPI
@@ -16,11 +16,16 @@ async def get_ca_certificates(mgmt_api: ZitiManagementAPI) -> str:
     if not _ca_certificates:
         cas_pkcs7 = await mgmt_api.fetch_ca_certificates()
         pkcs7_bytes = base64.b64decode(cas_pkcs7)
-        pkcs7_certs = load_der_pkcs7_certificates(pkcs7_bytes)
+
+        content_info = cms.ContentInfo.load(pkcs7_bytes)
+        certs = content_info["content"]["certificates"]
+
         ca_certificates = []
-        for cert in pkcs7_certs:
-            cert_pem = cert.public_bytes(serialization.Encoding.PEM)
-            ca_certificates.append(cert_pem.decode("utf-8"))
+        for cert in certs:
+            crypt_cert = x509.load_der_x509_certificate(cert.dump())
+            pem = crypt_cert.public_bytes(serialization.Encoding.PEM).decode("utf-8")
+            ca_certificates.append(pem)
+
         _ca_certificates = "\n".join(ca_certificates)
     return _ca_certificates
 

{mrok-0.1.9 → mrok-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mrok"
-version = "0.1.9"
+version = "0.2.1"
 description = "MPT Extensions OpenZiti Orchestrator"
 readme = { file = "README.md", content-type = "text/markdown" }
 authors = [
@@ -9,6 +9,7 @@ authors = [
 license = { file = "LICENSE.txt" }
 requires-python = ">=3.12,<4"
 dependencies = [
+    "asn1crypto>=1.5.1,<2.0.0",
     "cryptography>=45.0.7,<46.0.0",
     "dynaconf>=3.2.11,<4.0.0",
     "fastapi-pagination>=0.14.1,<0.15.0",

mrok-0.1.9/tests/controller/test_instances.py → mrok-0.2.1/tests/controller/test_extensions.py

@@ -1,15 +1,227 @@
 from urllib.parse import quote
 
 import pytest
+from dynaconf.base import LazySettings
 from httpx import AsyncClient
 from pytest_httpx import HTTPXMock
 from pytest_mock import MockerFixture
 
 from mrok.ziti.api import ZitiClientAPI, ZitiManagementAPI
 from mrok.ziti.constants import MROK_SERVICE_TAG_NAME, MROK_VERSION_TAG_NAME
+from mrok.ziti.errors import (
+    ConfigTypeNotFoundError,
+    MrokError,
+    ProxyIdentityNotFoundError,
+    ServiceAlreadyRegisteredError,
+    ServiceNotFoundError,
+)
 from tests.conftest import SettingsFactory
 
 
+@pytest.mark.asyncio
+async def test_list_extensions(
+    api_client: AsyncClient, settings_factory: SettingsFactory, httpx_mock: HTTPXMock
+):
+    settings = settings_factory()
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?limit=5&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 10, "limit": 5, "offset": 0}},
+            "data": [{"id": f"svc{i}", "name": "svc"} for i in range(5)],
+        },
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?limit=5&offset=5",
+        json={
+            "meta": {"pagination": {"totalCount": 10, "limit": 5, "offset": 5}},
+            "data": [{"id": f"svc{5 + i}", "name": "svc"} for i in range(5)],
+        },
+    )
+    response = await api_client.get("/extensions?limit=5&offset=0")
+    assert response.status_code == 200
+    page_1 = response.json()
+    assert len(page_1["data"]) == 5
+    assert page_1["$meta"]["pagination"]["offset"] == 0
+
+    response = await api_client.get("/extensions?limit=5&offset=5")
+    assert response.status_code == 200
+    page_2 = response.json()
+    assert len(page_2["data"]) == 5
+    assert page_2["$meta"]["pagination"]["offset"] == 5
+
+    assert sorted(page_1["data"], key=lambda x: x["id"]) != sorted(
+        page_2["data"], key=lambda x: x["id"]
+    )
+
+
+@pytest.mark.asyncio
+async def test_register_extension(mocker: MockerFixture, api_client: AsyncClient):
+    mocked_register = mocker.patch(
+        "mrok.controller.routes.extensions.register_extension",
+        return_value={
+            "id": "a1b2cd",
+            "name": "ext-1234-5678",
+            "tags": {
+                MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+                "account": "ACC-1234-5678",
+            },
+        },
+    )
+
+    response = await api_client.post(
+        "/extensions",
+        json={
+            "extension": {"id": "EXT-1234-5678"},
+            "tags": {"account": "ACC-1234-5678"},
+        },
+    )
+    assert response.status_code == 201
+    assert response.json() == {
+        "id": "a1b2cd",
+        "extension": {"id": "EXT-1234-5678"},
+        "name": "ext-1234-5678",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+            "account": "ACC-1234-5678",
+        },
+    }
+    assert mocked_register.call_count == 1
+    assert isinstance(mocked_register.mock_calls[0].args[0], LazySettings)
+    assert isinstance(mocked_register.mock_calls[0].args[1], ZitiManagementAPI)
+    assert mocked_register.mock_calls[0].args[2] == "EXT-1234-5678"
+    assert mocked_register.mock_calls[0].args[3] == {"account": "ACC-1234-5678"}
+
+
+@pytest.mark.asyncio
+async def test_register_extension_already_exists(mocker: MockerFixture, api_client: AsyncClient):
+    mocker.patch(
+        "mrok.controller.routes.extensions.register_extension",
+        side_effect=ServiceAlreadyRegisteredError("Extension `EXT-1234-5678` already registered."),
+    )
+
+    response = await api_client.post(
+        "/extensions",
+        json={
+            "extension": {"id": "EXT-1234-5678"},
+            "tags": {"account": "ACC-1234-5678"},
+        },
+    )
+    assert response.status_code == 400
+    assert response.json() == {"detail": "Extension `EXT-1234-5678` already registered."}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exc_type", [ProxyIdentityNotFoundError, ConfigTypeNotFoundError])
+async def test_register_extension_mrok_not_configured(
+    mocker: MockerFixture,
+    api_client: AsyncClient,
+    exc_type: MrokError,
+):
+    mocker.patch(
+        "mrok.controller.routes.extensions.register_extension",
+        side_effect=exc_type("this is the error."),  # type: ignore
+    )
+
+    response = await api_client.post(
+        "/extensions",
+        json={
+            "extension": {"id": "EXT-1234-5678"},
+            "tags": {"account": "ACC-1234-5678"},
+        },
+    )
+    assert response.status_code == 400
+    assert response.json() == {"detail": "OpenZiti not configured properly: this is the error."}
+
+
+@pytest.mark.asyncio
+async def test_get_extension(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        f'(id="EXT-1234-5678" or name="ext-1234-5678") and tags.{MROK_VERSION_TAG_NAME} != null'
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "svc1",
+                    "name": "ext-1234-5678",
+                    "tags": {MROK_VERSION_TAG_NAME: "0.0.0.dev0"},
+                }
+            ],
+        },
+    )
+
+    response = await api_client.get("/extensions/EXT-1234-5678")
+    assert response.status_code == 200
+    assert response.json() == {
+        "id": "svc1",
+        "extension": {"id": "EXT-1234-5678"},
+        "name": "ext-1234-5678",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_extension_not_found(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        f'(id="EXT-1234-5678" or name="ext-1234-5678") and tags.{MROK_VERSION_TAG_NAME} != null'
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/services?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 0}},
+            "data": [],
+        },
+    )
+
+    response = await api_client.get("/extensions/EXT-1234-5678")
+    assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_delete_extension(
+    mocker: MockerFixture,
+    api_client: AsyncClient,
+):
+    mocker.patch(
+        "mrok.controller.routes.extensions.unregister_extension",
+    )
+
+    response = await api_client.delete("/extensions/EXT-1234-5678")
+    assert response.status_code == 204
+
+
+@pytest.mark.asyncio
+async def test_delete_extension_not_found(
+    mocker: MockerFixture,
+    api_client: AsyncClient,
+):
+    mocker.patch(
+        "mrok.controller.routes.extensions.unregister_extension",
+        side_effect=ServiceNotFoundError("not found"),
+    )
+
+    response = await api_client.delete("/extensions/EXT-1234-5678")
+    assert response.status_code == 404
+
+
 @pytest.mark.asyncio
 async def test_list_instances(
     mocker: MockerFixture,
@@ -19,7 +231,8 @@ async def test_list_instances(
 ):
     settings = settings_factory()
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     query = quote(f'tags.{MROK_SERVICE_TAG_NAME} = "ext-1234-5678"')
     httpx_mock.add_response(
@@ -58,10 +271,11 @@ async def test_list_instances(
 @pytest.mark.asyncio
 async def test_register_instance(mocker: MockerFixture, api_client: AsyncClient):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     mocked_register = mocker.patch(
-        "mrok.controller.routes.register_instance",
+        "mrok.controller.routes.extensions.register_instance",
         return_value=(
             {
                 "id": "a1b2cd",
@@ -114,7 +328,8 @@ async def test_get_instance(
     httpx_mock: HTTPXMock,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     settings = settings_factory()
     query = quote(
@@ -161,7 +376,8 @@ async def test_get_instance_by_instance_id(
     httpx_mock: HTTPXMock,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     settings = settings_factory()
     query = quote(f'(id="ins1" or name="ins1") and tags.{MROK_VERSION_TAG_NAME} != null')
@@ -205,7 +421,8 @@ async def test_get_instance_not_found(
     httpx_mock: HTTPXMock,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
     settings = settings_factory()
     query = quote(
@@ -231,11 +448,11 @@ async def test_delete_instance(
     api_client: AsyncClient,
 ):
     mocker.patch(
-        "mrok.controller.routes.fetch_instance_or_404",
+        "mrok.controller.routes.extensions.fetch_instance_or_404",
         return_value={"name": "ins-1234-5678.ext-1234-5678"},
     )
     mocker.patch(
-        "mrok.controller.routes.unregister_instance",
+        "mrok.controller.routes.extensions.unregister_instance",
     )
 
     response = await api_client.delete("/extensions/EXT-1234-5678/instances/INS-1234-5678-0001")
@@ -243,7 +460,7 @@ async def test_delete_instance(
 
 
 @pytest.mark.asyncio
-async def test_delete_extension_not_found(
+async def test_delete_instance_extension_not_found(
     mocker: MockerFixture,
     api_client: AsyncClient,
     settings_factory: SettingsFactory,
@@ -251,7 +468,8 @@ async def test_delete_extension_not_found(
 ):
     settings = settings_factory()
     mocker.patch(
-        "mrok.controller.routes.fetch_extension_or_404", return_value={"name": "ext-1234-5678"}
+        "mrok.controller.routes.extensions.fetch_extension_or_404",
+        return_value={"name": "ext-1234-5678"},
     )
 
     query = quote(

mrok-0.2.1/tests/controller/test_instances.py

@@ -0,0 +1,157 @@
+from urllib.parse import quote
+
+import pytest
+from httpx import AsyncClient
+from pytest_httpx import HTTPXMock
+
+from mrok.ziti.constants import MROK_SERVICE_TAG_NAME, MROK_VERSION_TAG_NAME
+from tests.conftest import SettingsFactory
+
+
+@pytest.mark.asyncio
+async def test_list_instances(
+    api_client: AsyncClient,
+    settings_factory: SettingsFactory,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?&limit=10&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 15, "limit": 10, "offset": 0}},
+            "data": [{"id": f"ins{i}", "name": "ins.svc"} for i in range(10)],
+        },
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?&limit=10&offset=10",
+        json={
+            "meta": {"pagination": {"totalCount": 15, "limit": 10, "offset": 10}},
+            "data": [{"id": f"ins{i}", "name": "ins.svc"} for i in range(11, 16)],
+        },
+    )
+    response = await api_client.get("/instances?limit=10&offset=0")
+    assert response.status_code == 200
+    page_1 = response.json()
+    assert len(page_1["data"]) == 10
+    assert page_1["$meta"]["pagination"]["offset"] == 0
+
+    response = await api_client.get("/instances?limit=10&offset=10")
+    assert response.status_code == 200
+    page_2 = response.json()
+    assert len(page_2["data"]) == 5
+    assert page_2["$meta"]["pagination"]["offset"] == 10
+
+    assert sorted(page_1["data"], key=lambda x: x["id"]) != sorted(
+        page_2["data"], key=lambda x: x["id"]
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_instance(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        '(id="INS-1234-1234-0001.ext-1234-1234" or name="ins-1234-1234-0001.ext-1234-1234") '
+        f"and tags.{MROK_VERSION_TAG_NAME} != null"
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "ins1",
+                    "name": "ins-1234-1234-0001.ext-1234-1234",
+                    "tags": {
+                        MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+                        MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+                    },
+                }
+            ],
+        },
+    )
+
+    response = await api_client.get("/instances/INS-1234-1234-0001.ext-1234-1234")
+    assert response.status_code == 200
+    assert response.json() == {
+        "id": "ins1",
+        "identity": None,
+        "extension": {"id": "EXT-1234-1234"},
+        "instance": {"id": "INS-1234-1234-0001"},
+        "name": "ins-1234-1234-0001.ext-1234-1234",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+            MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+        },
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_instance_by_instance_id(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(f'(id="ins1" or name="ins1") and tags.{MROK_VERSION_TAG_NAME} != null')
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 1}},
+            "data": [
+                {
+                    "id": "ins1",
+                    "name": "ins-1234-1234-0001.ext-1234-1234",
+                    "tags": {
+                        MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+                        MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+                    },
+                }
+            ],
+        },
+    )
+
+    response = await api_client.get("/instances/ins1")
+    assert response.status_code == 200
+    assert response.json() == {
+        "id": "ins1",
+        "extension": {"id": "EXT-1234-1234"},
+        "instance": {"id": "INS-1234-1234-0001"},
+        "name": "ins-1234-1234-0001.ext-1234-1234",
+        "tags": {
+            MROK_VERSION_TAG_NAME: "0.0.0.dev0",
+            MROK_SERVICE_TAG_NAME: "ext-1234-1234",
+        },
+        "identity": None,
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_instance_not_found(
+    settings_factory: SettingsFactory,
+    api_client: AsyncClient,
+    httpx_mock: HTTPXMock,
+):
+    settings = settings_factory()
+    query = quote(
+        '(id="INS-1234-1234-0001.ext-1234-1234" or name="ins-1234-1234-0001.ext-1234-1234") '
+        f"and tags.{MROK_VERSION_TAG_NAME} != null"
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{settings.ziti.api.management}/edge/management/v1/identities?filter={query}",
+        json={
+            "meta": {"pagination": {"totalCount": 10}},
+            "data": [],
+        },
+    )
+
+    response = await api_client.get("/instances/INS-1234-1234-0001.ext-1234-1234")
+    assert response.status_code == 404

{mrok-0.1.9 → mrok-0.2.1}/uv.lock

@@ -37,6 +37,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2f/f5/c36551e93acba41a59939ae6a0fb77ddb3f2e8e8caa716410c65f7341f72/asgi_lifespan-2.1.0-py3-none-any.whl", hash = "sha256:ed840706680e28428c01e14afb3875d7d76d3206f3d5b2f2294e059b5c23804f", size = 10895, upload-time = "2023-03-28T17:35:47.772Z" },
 ]
 
+[[package]]
+name = "asn1crypto"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/cf/d547feed25b5244fcb9392e288ff9fdc3280b10260362fc45d37a798a6ee/asn1crypto-1.5.1.tar.gz", hash = "sha256:13ae38502be632115abf8a24cbe5f4da52e3b5231990aff31123c805306ccb9c", size = 121080, upload-time = "2022-03-15T14:46:52.889Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c9/7f/09065fd9e27da0eda08b4d6897f1c13535066174cc023af248fc2a8d5e5a/asn1crypto-1.5.1-py2.py3-none-any.whl", hash = "sha256:db4e40728b728508912cbb3d44f19ce188f218e9eba635821bb4b68564f8fd67", size = 105045, upload-time = "2022-03-15T14:46:51.055Z" },
+]
+
 [[package]]
 name = "asttokens"
 version = "3.0.0"
@@ -672,6 +681,7 @@ name = "mrok"
 version = "0.0.0.dev0"
 source = { editable = "." }
 dependencies = [
+    { name = "asn1crypto" },
     { name = "cryptography" },
     { name = "dynaconf" },
     { name = "fastapi", extra = ["standard"] },
@@ -708,6 +718,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "asn1crypto", specifier = ">=1.5.1,<2.0.0" },
     { name = "cryptography", specifier = ">=45.0.7,<46.0.0" },
     { name = "dynaconf", specifier = ">=3.2.11,<4.0.0" },
     { name = "fastapi", extras = ["standard"], specifier = ">=0.119.0,<0.120.0" },