fluidattacks_core_resolves 1.0.0__py3-none-any.whl

fluidattacks_core/resolves/__init__.py

@@ -0,0 +1,51 @@
+from fluidattacks_core.resolves._entries import (
+    AddressRecord,
+    Entry,
+    EntryKind,
+    NameRecord,
+    Outcome,
+    RecordType,
+    Refusal,
+    Resolution,
+    SeenBy,
+    Sighting,
+)
+from fluidattacks_core.resolves._envelope import (
+    SCHEMA_VERSION,
+    ResolvesOutput,
+    SeedStatus,
+)
+from fluidattacks_core.resolves._hosts import HOST_PATTERN, MAX_HOST_LENGTH, Host, ensure_host
+from fluidattacks_core.resolves._instants import EVIDENCE_DATE_PATTERN, EvidenceDate
+from fluidattacks_core.resolves._schema import (
+    SCHEMA_PATH,
+    build_schema,
+    load_schema,
+    render_schema,
+)
+
+__all__ = [
+    "EVIDENCE_DATE_PATTERN",
+    "HOST_PATTERN",
+    "MAX_HOST_LENGTH",
+    "SCHEMA_PATH",
+    "SCHEMA_VERSION",
+    "AddressRecord",
+    "Entry",
+    "EntryKind",
+    "EvidenceDate",
+    "Host",
+    "NameRecord",
+    "Outcome",
+    "RecordType",
+    "Refusal",
+    "Resolution",
+    "ResolvesOutput",
+    "SeedStatus",
+    "SeenBy",
+    "Sighting",
+    "build_schema",
+    "ensure_host",
+    "load_schema",
+    "render_schema",
+]

fluidattacks_core/resolves/_entries.py

@@ -0,0 +1,129 @@
+from enum import StrEnum
+from typing import Annotated, ClassVar, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, StringConstraints
+
+from fluidattacks_core.resolves._hosts import Host
+from fluidattacks_core.resolves._instants import EvidenceDate
+
+
+class EntryKind(StrEnum):
+    """What an entry is: a name seen, an answer it gave, or the lack of one."""
+
+    RECORD = "record"
+    RESOLUTION = "resolution"
+    SIGHTING = "sighting"
+
+
+class RecordType(StrEnum):
+    """The DNS record types a scan reports, spelled as the protocol does."""
+
+    A = "A"
+    AAAA = "AAAA"
+    CNAME = "CNAME"
+    MX = "MX"
+    NS = "NS"
+    TXT = "TXT"
+
+
+class SeenBy(StrEnum):
+    """Which part of the run saw a name, not what it later found about it.
+
+    Named as the contextualizer contract names it, and deliberately not
+    `source`: the platform spells an organization's source entity that way,
+    and this is a module of the scanner, not one of those.
+    """
+
+    AXFR = "axfr"
+    CRT_NAME = "crt.name"
+    CRT_SH = "crt.sh"
+    RECORDS = "records"
+    SEED = "seed"
+    URLSCAN = "urlscan.io"
+
+
+class Outcome(StrEnum):
+    """What resolving a name amounted to when it yielded no usable record.
+
+    Typed rather than described, so a consumer can tell a name that does not
+    exist from one whose address the scan refused to dial.
+    """
+
+    ABSENT = "absent"
+    DELEGATED = "delegated"
+    NONEXISTENT = "nonexistent"
+    REFUSED = "refused"
+    UNKNOWN = "unknown"
+
+
+RecordValue = Annotated[str, StringConstraints(min_length=1, max_length=4096)]
+Port = Annotated[int, Field(ge=1, le=65535)]
+
+# An address literal is at most 45 characters in its longest IPv6 spelling.
+RefusedAddress = Annotated[str, StringConstraints(min_length=1, max_length=45)]
+
+
+class _Observed(BaseModel):
+    """What every entry says: which host, under which seed, seen by whom and when."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid", strict=True)
+
+    seed: Host
+    host: Host
+    seen_by: SeenBy
+    evidence_date: EvidenceDate
+
+
+class Sighting(_Observed):
+    """A name a module saw, before anything was asked of it."""
+
+    kind: Literal[EntryKind.SIGHTING]
+
+
+class AddressRecord(_Observed):
+    """An A or AAAA answer, the only kind of record a port probe can follow.
+
+    `open_ports` absent means the round did not probe; empty means it probed
+    and found none. The envelope's seed status says whether it got to ask.
+    """
+
+    kind: Literal[EntryKind.RECORD]
+    record_type: Literal[RecordType.A, RecordType.AAAA]
+    record_value: RecordValue
+    open_ports: tuple[Port, ...] | None = None
+
+
+class NameRecord(_Observed):
+    """An answer that names something else, so there is nothing to probe."""
+
+    kind: Literal[EntryKind.RECORD]
+    record_type: Literal[RecordType.CNAME, RecordType.MX, RecordType.NS, RecordType.TXT]
+    record_value: RecordValue
+
+
+class Resolution(_Observed):
+    """A name that was asked and yielded no usable record, and why."""
+
+    kind: Literal[EntryKind.RESOLUTION]
+    outcome: Literal[Outcome.ABSENT, Outcome.DELEGATED, Outcome.NONEXISTENT, Outcome.UNKNOWN]
+
+
+class Refusal(_Observed):
+    """A name whose address the scan declined to dial.
+
+    The address travels apart from any `record_value`, which only ever holds
+    an answer a scan may act on: a reader walking entries can never mistake an
+    address the screen withheld for one it may publish.
+    """
+
+    kind: Literal[EntryKind.RESOLUTION]
+    outcome: Literal[Outcome.REFUSED]
+    refused_address: RefusedAddress
+
+
+Record = Annotated[AddressRecord | NameRecord, Field(discriminator="record_type")]
+Resolved = Annotated[Resolution | Refusal, Field(discriminator="outcome")]
+
+# Which type an entry is follows from `kind`, then from `record_type` or
+# `outcome`, so a field foreign to the kind is an unknown field, not a rule.
+Entry = Annotated[Sighting | Record | Resolved, Field(discriminator="kind")]

fluidattacks_core/resolves/_envelope.py

@@ -0,0 +1,73 @@
+from collections.abc import Mapping
+from enum import StrEnum
+from typing import Annotated, ClassVar
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from fluidattacks_core.resolves._entries import Entry
+from fluidattacks_core.resolves._hosts import Host
+
+SCHEMA_VERSION = 1
+
+
+class SeedStatus(StrEnum):
+    """How much of one seed's surface the run covered.
+
+    A consumer that treats absence as a removal must be able to refuse
+    anything but `complete`. It is per seed because a run takes several and
+    gives up on the ones it cannot enumerate, so one status for the file would
+    make a whole run unusable when a single seed failed.
+    """
+
+    COMPLETE = "complete"
+    FAILED = "failed"
+    PARTIAL = "partial"
+
+
+class ResolvesOutput(BaseModel):
+    """One scan's report over the seeds it was given.
+
+    Scanner vocabulary only: hosts, records, addresses and ports. Nothing
+    about assets, scope or groups, none of which is observable from outside
+    the surface being scanned.
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid", strict=True)
+
+    schema_version: int = Field(ge=SCHEMA_VERSION, le=SCHEMA_VERSION)
+    # Keyed by seed, so one seed cannot be declared twice with two statuses.
+    # The key grammar reaches the schema as `patternProperties`, which alone
+    # lets a non-matching key through; closing the object makes it refuse.
+    seeds: Annotated[
+        Mapping[Host, SeedStatus],
+        Field(min_length=1, json_schema_extra={"additionalProperties": False}),
+    ]
+    entries: tuple[Entry, ...] = ()
+
+    @model_validator(mode="after")
+    def _reject_an_entry_of_an_undeclared_seed(self) -> "ResolvesOutput":
+        # An entry is read against its seed's status, so a seed the file does
+        # not declare leaves its entries with none.
+        stray = sorted({entry.seed for entry in self.entries} - self.seeds.keys())
+        if stray:
+            msg = f"entries name seeds the run does not declare: {', '.join(stray)}"
+            raise ValueError(msg)
+
+        return self
+
+    @model_validator(mode="after")
+    def _reject_repeated_entries(self) -> "ResolvesOutput":
+        # Two modules seeing one name are two facts (68 of 2320 rows on a
+        # real run), while the same fact with different ports or dates is one
+        # fact stated twice, and a run may state each fact once.
+        asserted = [_asserted(entry) for entry in self.entries]
+        if len(set(asserted)) != len(asserted):
+            msg = "entries must not repeat what they report about one host"
+            raise ValueError(msg)
+
+        return self
+
+
+def _asserted(entry: Entry) -> frozenset[tuple[str, object]]:
+    # What an entry claims about its host, not how or when it was learned.
+    return frozenset(entry.model_dump(exclude={"evidence_date", "open_ports"}).items())

fluidattacks_core/resolves/_hosts.py

@@ -0,0 +1,57 @@
+import re
+from typing import Annotated
+
+from pydantic import AfterValidator, StringConstraints
+
+# A name is at most 253 octets on the wire.
+MAX_HOST_LENGTH = 253
+
+# The canonical spelling, so a validator reading only the schema refuses what
+# `ensure_host` refuses: lowercase ascii labels of letters, digits and inner
+# hyphens, at least two of them, and no root label.
+HOST_PATTERN = r"^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$"
+
+_FORBIDDEN = re.compile("[\\x00-\\x1f\\x7f\\u202a-\\u202e\\u2066-\\u2069]")
+
+
+def ensure_host(value: str) -> str:
+    """Reject, never normalize, anything but the canonical spelling of a host.
+
+    One spelling per host, so a consumer that folds `A.example.com`,
+    `a.example.com.` and `a.example.com` into a single identity can never be
+    handed three of them as separate entries. A producer resolving names has
+    the canonical form already; anything else is a bug upstream, and repairing
+    it here would hide it.
+    """
+    if not value:
+        msg = "host must not be empty"
+        raise ValueError(msg)
+
+    if _FORBIDDEN.search(value):
+        msg = f"host must not hold control or bidi characters: {value!r}"
+        raise ValueError(msg)
+
+    if not value.isascii():
+        msg = f"host must be in its ascii form: {value!r}"
+        raise ValueError(msg)
+
+    if value != value.lower():
+        msg = f"host must be lowercase: {value!r}"
+        raise ValueError(msg)
+
+    if value.endswith("."):
+        msg = f"host must not carry the root label: {value!r}"
+        raise ValueError(msg)
+
+    if ".." in value or value.startswith("."):
+        msg = f"host must not hold an empty label: {value!r}"
+        raise ValueError(msg)
+
+    return value
+
+
+Host = Annotated[
+    str,
+    StringConstraints(min_length=1, max_length=MAX_HOST_LENGTH, pattern=HOST_PATTERN),
+    AfterValidator(ensure_host),
+]

fluidattacks_core/resolves/_instants.py

@@ -0,0 +1,9 @@
+from typing import Annotated
+
+from pydantic import StringConstraints
+
+# The one shape the producer's own type emits, and a strict subset of the
+# platform's `#isoDate`, so nothing downstream has to guess a spelling.
+EVIDENCE_DATE_PATTERN = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$"
+
+EvidenceDate = Annotated[str, StringConstraints(pattern=EVIDENCE_DATE_PATTERN)]

fluidattacks_core/resolves/_schema.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+
+from fluidattacks_core.resolves._envelope import SCHEMA_VERSION, ResolvesOutput
+
+SCHEMA_PATH = Path(__file__).parent / "schemas" / "resolves_output.schema.json"
+
+# Versioned: a validator caches by $id, so v2 must not answer to v1's uri.
+_SCHEMA_ID = f"https://fluidattacks.com/schemas/resolves_output/v{SCHEMA_VERSION}.json"
+
+# Declared, or a validator defaulting to draft-07 reads `$defs` differently.
+_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema"
+
+
+def build_schema() -> dict[str, object]:
+    """Render the canonical JSONSchema the Rust producer validates against.
+
+    Structural only. The host grammar and the rules conditional on `kind` are
+    not expressed here, so the producer implements them and the fixtures are
+    what prove the implementations agree.
+    """
+    schema = ResolvesOutput.model_json_schema()
+
+    # Spread first, or a pydantic-emitted `$id` would silently win.
+    return {**schema, "$schema": _SCHEMA_DIALECT, "$id": _SCHEMA_ID}
+
+
+def render_schema() -> str:
+    return json.dumps(build_schema(), indent=2, sort_keys=True) + "\n"
+
+
+def load_schema() -> dict[str, object]:
+    content: dict[str, object] = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+
+    return content

fluidattacks_core/resolves/schemas/resolves_output.schema.json

@@ -0,0 +1,445 @@
+{
+  "$defs": {
+    "AddressRecord": {
+      "additionalProperties": false,
+      "description": "An A or AAAA answer, the only kind of record a port probe can follow.\n\n`open_ports` absent means the round did not probe; empty means it probed\nand found none. The envelope's seed status says whether it got to ask.",
+      "properties": {
+        "evidence_date": {
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+          "title": "Evidence Date",
+          "type": "string"
+        },
+        "host": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Host",
+          "type": "string"
+        },
+        "kind": {
+          "const": "record",
+          "title": "Kind",
+          "type": "string"
+        },
+        "open_ports": {
+          "anyOf": [
+            {
+              "items": {
+                "maximum": 65535,
+                "minimum": 1,
+                "type": "integer"
+              },
+              "type": "array"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Open Ports"
+        },
+        "record_type": {
+          "enum": [
+            "A",
+            "AAAA"
+          ],
+          "title": "Record Type",
+          "type": "string"
+        },
+        "record_value": {
+          "maxLength": 4096,
+          "minLength": 1,
+          "title": "Record Value",
+          "type": "string"
+        },
+        "seed": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Seed",
+          "type": "string"
+        },
+        "seen_by": {
+          "$ref": "#/$defs/SeenBy"
+        }
+      },
+      "required": [
+        "seed",
+        "host",
+        "seen_by",
+        "evidence_date",
+        "kind",
+        "record_type",
+        "record_value"
+      ],
+      "title": "AddressRecord",
+      "type": "object"
+    },
+    "NameRecord": {
+      "additionalProperties": false,
+      "description": "An answer that names something else, so there is nothing to probe.",
+      "properties": {
+        "evidence_date": {
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+          "title": "Evidence Date",
+          "type": "string"
+        },
+        "host": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Host",
+          "type": "string"
+        },
+        "kind": {
+          "const": "record",
+          "title": "Kind",
+          "type": "string"
+        },
+        "record_type": {
+          "enum": [
+            "CNAME",
+            "MX",
+            "NS",
+            "TXT"
+          ],
+          "title": "Record Type",
+          "type": "string"
+        },
+        "record_value": {
+          "maxLength": 4096,
+          "minLength": 1,
+          "title": "Record Value",
+          "type": "string"
+        },
+        "seed": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Seed",
+          "type": "string"
+        },
+        "seen_by": {
+          "$ref": "#/$defs/SeenBy"
+        }
+      },
+      "required": [
+        "seed",
+        "host",
+        "seen_by",
+        "evidence_date",
+        "kind",
+        "record_type",
+        "record_value"
+      ],
+      "title": "NameRecord",
+      "type": "object"
+    },
+    "Refusal": {
+      "additionalProperties": false,
+      "description": "A name whose address the scan declined to dial.\n\nThe address travels apart from any `record_value`, which only ever holds\nan answer a scan may act on: a reader walking entries can never mistake an\naddress the screen withheld for one it may publish.",
+      "properties": {
+        "evidence_date": {
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+          "title": "Evidence Date",
+          "type": "string"
+        },
+        "host": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Host",
+          "type": "string"
+        },
+        "kind": {
+          "const": "resolution",
+          "title": "Kind",
+          "type": "string"
+        },
+        "outcome": {
+          "const": "refused",
+          "title": "Outcome",
+          "type": "string"
+        },
+        "refused_address": {
+          "maxLength": 45,
+          "minLength": 1,
+          "title": "Refused Address",
+          "type": "string"
+        },
+        "seed": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Seed",
+          "type": "string"
+        },
+        "seen_by": {
+          "$ref": "#/$defs/SeenBy"
+        }
+      },
+      "required": [
+        "seed",
+        "host",
+        "seen_by",
+        "evidence_date",
+        "kind",
+        "outcome",
+        "refused_address"
+      ],
+      "title": "Refusal",
+      "type": "object"
+    },
+    "Resolution": {
+      "additionalProperties": false,
+      "description": "A name that was asked and yielded no usable record, and why.",
+      "properties": {
+        "evidence_date": {
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+          "title": "Evidence Date",
+          "type": "string"
+        },
+        "host": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Host",
+          "type": "string"
+        },
+        "kind": {
+          "const": "resolution",
+          "title": "Kind",
+          "type": "string"
+        },
+        "outcome": {
+          "enum": [
+            "absent",
+            "delegated",
+            "nonexistent",
+            "unknown"
+          ],
+          "title": "Outcome",
+          "type": "string"
+        },
+        "seed": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Seed",
+          "type": "string"
+        },
+        "seen_by": {
+          "$ref": "#/$defs/SeenBy"
+        }
+      },
+      "required": [
+        "seed",
+        "host",
+        "seen_by",
+        "evidence_date",
+        "kind",
+        "outcome"
+      ],
+      "title": "Resolution",
+      "type": "object"
+    },
+    "SeedStatus": {
+      "description": "How much of one seed's surface the run covered.\n\nA consumer that treats absence as a removal must be able to refuse\nanything but `complete`. It is per seed because a run takes several and\ngives up on the ones it cannot enumerate, so one status for the file would\nmake a whole run unusable when a single seed failed.",
+      "enum": [
+        "complete",
+        "failed",
+        "partial"
+      ],
+      "title": "SeedStatus",
+      "type": "string"
+    },
+    "SeenBy": {
+      "description": "Which part of the run saw a name, not what it later found about it.\n\nNamed as the contextualizer contract names it, and deliberately not\n`source`: the platform spells an organization's source entity that way,\nand this is a module of the scanner, not one of those.",
+      "enum": [
+        "axfr",
+        "crt.name",
+        "crt.sh",
+        "records",
+        "seed",
+        "urlscan.io"
+      ],
+      "title": "SeenBy",
+      "type": "string"
+    },
+    "Sighting": {
+      "additionalProperties": false,
+      "description": "A name a module saw, before anything was asked of it.",
+      "properties": {
+        "evidence_date": {
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$",
+          "title": "Evidence Date",
+          "type": "string"
+        },
+        "host": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Host",
+          "type": "string"
+        },
+        "kind": {
+          "const": "sighting",
+          "title": "Kind",
+          "type": "string"
+        },
+        "seed": {
+          "maxLength": 253,
+          "minLength": 1,
+          "pattern": "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
+          "title": "Seed",
+          "type": "string"
+        },
+        "seen_by": {
+          "$ref": "#/$defs/SeenBy"
+        }
+      },
+      "required": [
+        "seed",
+        "host",
+        "seen_by",
+        "evidence_date",
+        "kind"
+      ],
+      "title": "Sighting",
+      "type": "object"
+    }
+  },
+  "$id": "https://fluidattacks.com/schemas/resolves_output/v1.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "description": "One scan's report over the seeds it was given.\n\nScanner vocabulary only: hosts, records, addresses and ports. Nothing\nabout assets, scope or groups, none of which is observable from outside\nthe surface being scanned.",
+  "properties": {
+    "entries": {
+      "default": [],
+      "items": {
+        "discriminator": {
+          "mapping": {
+            "record": {
+              "discriminator": {
+                "mapping": {
+                  "A": "#/$defs/AddressRecord",
+                  "AAAA": "#/$defs/AddressRecord",
+                  "CNAME": "#/$defs/NameRecord",
+                  "MX": "#/$defs/NameRecord",
+                  "NS": "#/$defs/NameRecord",
+                  "TXT": "#/$defs/NameRecord"
+                },
+                "propertyName": "record_type"
+              },
+              "oneOf": [
+                {
+                  "$ref": "#/$defs/AddressRecord"
+                },
+                {
+                  "$ref": "#/$defs/NameRecord"
+                }
+              ]
+            },
+            "resolution": {
+              "discriminator": {
+                "mapping": {
+                  "absent": "#/$defs/Resolution",
+                  "delegated": "#/$defs/Resolution",
+                  "nonexistent": "#/$defs/Resolution",
+                  "refused": "#/$defs/Refusal",
+                  "unknown": "#/$defs/Resolution"
+                },
+                "propertyName": "outcome"
+              },
+              "oneOf": [
+                {
+                  "$ref": "#/$defs/Resolution"
+                },
+                {
+                  "$ref": "#/$defs/Refusal"
+                }
+              ]
+            },
+            "sighting": "#/$defs/Sighting"
+          },
+          "propertyName": "kind"
+        },
+        "oneOf": [
+          {
+            "$ref": "#/$defs/Sighting"
+          },
+          {
+            "discriminator": {
+              "mapping": {
+                "A": "#/$defs/AddressRecord",
+                "AAAA": "#/$defs/AddressRecord",
+                "CNAME": "#/$defs/NameRecord",
+                "MX": "#/$defs/NameRecord",
+                "NS": "#/$defs/NameRecord",
+                "TXT": "#/$defs/NameRecord"
+              },
+              "propertyName": "record_type"
+            },
+            "oneOf": [
+              {
+                "$ref": "#/$defs/AddressRecord"
+              },
+              {
+                "$ref": "#/$defs/NameRecord"
+              }
+            ]
+          },
+          {
+            "discriminator": {
+              "mapping": {
+                "absent": "#/$defs/Resolution",
+                "delegated": "#/$defs/Resolution",
+                "nonexistent": "#/$defs/Resolution",
+                "refused": "#/$defs/Refusal",
+                "unknown": "#/$defs/Resolution"
+              },
+              "propertyName": "outcome"
+            },
+            "oneOf": [
+              {
+                "$ref": "#/$defs/Resolution"
+              },
+              {
+                "$ref": "#/$defs/Refusal"
+              }
+            ]
+          }
+        ]
+      },
+      "title": "Entries",
+      "type": "array"
+    },
+    "schema_version": {
+      "maximum": 1,
+      "minimum": 1,
+      "title": "Schema Version",
+      "type": "integer"
+    },
+    "seeds": {
+      "additionalProperties": false,
+      "minProperties": 1,
+      "patternProperties": {
+        "^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$": {
+          "$ref": "#/$defs/SeedStatus"
+        }
+      },
+      "propertyNames": {
+        "maxLength": 253,
+        "minLength": 1
+      },
+      "title": "Seeds",
+      "type": "object"
+    }
+  },
+  "required": [
+    "schema_version",
+    "seeds"
+  ],
+  "title": "ResolvesOutput",
+  "type": "object"
+}

fluidattacks_core_resolves-1.0.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.5
+Name: fluidattacks_core_resolves
+Version: 1.0.0
+Summary: Fluid Attacks Core Resolves 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<3,>=2.12.3

fluidattacks_core_resolves-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fluidattacks_core/resolves/__init__.py,sha256=qjwArhHSwEAXsth3aaYyrhQgpIzuf_J6Y2K61G2IuNE,1052
+fluidattacks_core/resolves/_entries.py,sha256=8R9L8KSLT5SJU3bBlNsnA_3U-jXeQtjjVC7AS794OoM,3920
+fluidattacks_core/resolves/_envelope.py,sha256=BXov1PdNelLe-z12GRI2-dekVKJxozH_X5L5-d6RKm0,2847
+fluidattacks_core/resolves/_hosts.py,sha256=XTvPc82EntY5ep_H5KkfQtuC1mUisOdVgZTj_gfmfVo,1889
+fluidattacks_core/resolves/_instants.py,sha256=C9igJ6Yq7b1MgLqoyzWjI2uMe1cc5rEngrb1zKOrJUs,370
+fluidattacks_core/resolves/_schema.py,sha256=C4mA8G-9fzTuxu_7rOp3-f2cDb4vrpY9_8yziOPzg00,1265
+fluidattacks_core/resolves/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_core/resolves/schemas/resolves_output.schema.json,sha256=CjLaj0ej0G6AJS_0sRwXqiNO5OkmnvkdO4fvxP_Vozk,13038
+fluidattacks_core_resolves-1.0.0.dist-info/METADATA,sha256=vWWXE3ck83N_zGRszYPFh7KWK2EsZ4QFzW_6ZnCOoQY,569
+fluidattacks_core_resolves-1.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+fluidattacks_core_resolves-1.0.0.dist-info/RECORD,,

fluidattacks_core_resolves-1.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