attackmap-analyzer-swift 0.2.0__py3-none-any.whl

attackmap_analyzer_swift/sbom.py

@@ -0,0 +1,58 @@
+"""CocoaPods SBOM: ``Podfile.lock`` (swift#1).
+
+``PODS:`` lists every resolved pod (``  - Name (1.2.3)``, sub-dependencies
+indented below it); ``DEPENDENCIES:`` lists the ones the Podfile asks for,
+which makes them direct. Subspecs (``Firebase/Core``) are folded into their
+root pod. A line-based reader: garbage or truncated input yields what it
+could read and never raises.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# `  - AFNetworking (4.0.1):` / `  - "GoogleUtilities/Environment (7.11.0)"`
+_POD_ENTRY = re.compile(r'^  - "?([^\s"(][^"(]{0,200}?) \(([^()\s]{1,64})\)"?:?\s*$')
+# `  - AFNetworking (~> 4.0)` / `  - Firebase/Core` / `  - MyPod (from `../MyPod`)`
+_DEPENDENCY = re.compile(r'^  - "?([^\s"(][^"(\s]{0,200})')
+_SECTION = re.compile(r"^([A-Z][A-Z ]{1,40}):")
+_MAX_LINES = 200_000
+
+
+@dataclass(frozen=True)
+class Pod:
+    name: str
+    version: str
+    line: int
+    direct: bool
+
+
+def _root(name: str) -> str:
+    return name.split("/", 1)[0].strip()
+
+
+def parse_podfile_lock(text: str) -> list[Pod]:
+    """Resolved pods (root names, one per pod) with direct/transitive."""
+    resolved: dict[str, tuple[str, int]] = {}
+    direct: set[str] = set()
+    section = ""
+    for number, line in enumerate(text.splitlines()[:_MAX_LINES], start=1):
+        header = _SECTION.match(line)
+        if header:
+            section = header.group(1)
+            continue
+        if section == "PODS":
+            m = _POD_ENTRY.match(line)
+            if m:
+                root = _root(m.group(1))
+                if root and root not in resolved:
+                    resolved[root] = (m.group(2), number)
+        elif section == "DEPENDENCIES":
+            m = _DEPENDENCY.match(line)
+            if m:
+                direct.add(_root(m.group(1)))
+    return [Pod(name, version, line, name in direct) for name, (version, line) in resolved.items()]
+
+
+__all__ = ["Pod", "parse_podfile_lock"]

attackmap_analyzer_swift/swiftsrc.py

@@ -0,0 +1,239 @@
+"""Linear Swift source helpers: bracket matching that understands Swift string
+literals (interpolation, multi-line, raw ``#"..."#``) and nested comments.
+
+Everything here runs on hostile input, so it is one forward pass per file with
+bounded work per character, never raises on garbage, and never recurses.
+"""
+
+from __future__ import annotations
+
+import bisect
+import functools
+import re
+from dataclasses import dataclass, field
+
+# Code mode: the next string start, comment start or bracket.
+_CODE_TOKEN = re.compile(r'#*"""|#*"|//|/\*|[()\[\]{}]')
+_BLOCK_COMMENT_TOKEN = re.compile(r"/\*|\*/")
+_OPEN_TO_CLOSE = {"(": ")", "[": "]", "{": "}"}
+
+
+@dataclass
+class Source:
+    """Bracket pairs (both directions) for code brackets, and the sorted
+    spans of string literals and comments (``masked``)."""
+
+    text: str
+    pairs: dict[int, int] = field(default_factory=dict)
+    rpairs: dict[int, int] = field(default_factory=dict)
+    masked: list[tuple[int, int]] = field(default_factory=list)
+    strings: list[tuple[int, int]] = field(default_factory=list)
+    _starts: list[int] = field(default_factory=list)
+
+    def in_masked(self, offset: int) -> bool:
+        """True when ``offset`` falls inside a string literal or comment."""
+        i = bisect.bisect_right(self._starts, offset) - 1
+        return i >= 0 and self.masked[i][0] <= offset < self.masked[i][1]
+
+    def masked_span(self, offset: int) -> tuple[int, int] | None:
+        """The string or comment span containing ``offset``, if any."""
+        i = bisect.bisect_right(self._starts, offset) - 1
+        if i >= 0 and self.masked[i][0] <= offset < self.masked[i][1]:
+            return self.masked[i]
+        return None
+
+    def close_of(self, offset: int) -> int:
+        """Offset of the bracket closing the one at ``offset``, or -1."""
+        return self.pairs.get(offset, -1)
+
+    def open_of(self, offset: int) -> int:
+        return self.rpairs.get(offset, -1)
+
+
+@functools.lru_cache(maxsize=8)
+def parse(text: str) -> Source:
+    src = Source(text)
+    stack: list[tuple[str, int]] = []
+    n = len(text)
+    pos = 0
+    while pos < n:
+        m = _CODE_TOKEN.search(text, pos)
+        if m is None:
+            break
+        tok = m.group(0)
+        start = m.start()
+        if tok == "//":
+            end = text.find("\n", start)
+            end = n if end < 0 else end
+            src.masked.append((start, end))
+            pos = end
+        elif tok == "/*":
+            end = _skip_block_comment(text, start)
+            src.masked.append((start, end))
+            pos = end
+        elif tok.endswith('"'):
+            end = _skip_string(text, start, tok)
+            src.masked.append((start, end))
+            src.strings.append((start, end))
+            pos = end
+        elif tok in _OPEN_TO_CLOSE:
+            stack.append((tok, start))
+            pos = m.end()
+        else:
+            # A closer: pop to its opener; an unmatched closer is ignored.
+            for depth in range(len(stack) - 1, max(-1, len(stack) - 8), -1):
+                if _OPEN_TO_CLOSE[stack[depth][0]] == tok:
+                    open_at = stack[depth][1]
+                    del stack[depth:]
+                    src.pairs[open_at] = start
+                    src.rpairs[start] = open_at
+                    break
+            pos = m.end()
+    src._starts = [s for s, _ in src.masked]
+    return src
+
+
+def _skip_block_comment(text: str, start: int) -> int:
+    """End offset of the (nestable) block comment starting at ``start``."""
+    depth = 0
+    pos = start
+    while True:
+        m = _BLOCK_COMMENT_TOKEN.search(text, pos)
+        if m is None:
+            return len(text)
+        depth += 1 if m.group(0) == "/*" else -1
+        pos = m.end()
+        if depth == 0:
+            return pos
+
+
+# Interpolations nested deeper than this end the literal (hostile input).
+_MAX_NESTING = 16
+
+
+@functools.lru_cache(maxsize=32)
+def _string_token(hashes: int, multiline: bool) -> re.Pattern[str]:
+    closer = ('"""' if multiline else '"') + "#" * hashes
+    escape = "\\" + "#" * hashes
+    alternatives = [re.escape(closer), re.escape(escape)]
+    if not multiline:
+        alternatives.append("\n")
+    return re.compile("|".join(alternatives))
+
+
+def _skip_string(text: str, start: int, opener: str, depth: int = 0) -> int:
+    """End offset of the string literal starting at ``start``. Interpolations
+    (``\\(...)``) are skipped as code, including strings nested in them."""
+    hashes = len(opener) - len(opener.lstrip("#"))
+    multiline = opener.endswith('"""')
+    token = _string_token(hashes, multiline)
+    escape_len = 1 + hashes
+    pos = start + len(opener)
+    n = len(text)
+    while pos < n:
+        m = token.search(text, pos)
+        if m is None:
+            return n
+        tok = m.group(0)
+        if tok == "\n":
+            return m.start()  # unterminated single-line string
+        if tok.startswith("\\"):
+            after = m.start() + escape_len
+            if after < n and text[after] == "(":
+                if depth >= _MAX_NESTING:
+                    return n
+                pos = _skip_interpolation(text, after, depth + 1)
+            else:
+                pos = after + 1  # escaped character
+            continue
+        return m.end()
+    return n
+
+
+_INTERP_TOKEN = re.compile(r'#*"""|#*"|[()]')
+
+
+def _skip_interpolation(text: str, paren: int, depth: int) -> int:
+    """Offset just past the ``)`` closing the interpolation at ``paren``."""
+    parens = 0
+    pos = paren
+    n = len(text)
+    while pos < n:
+        m = _INTERP_TOKEN.search(text, pos)
+        if m is None:
+            return n
+        tok = m.group(0)
+        if tok == "(":
+            parens += 1
+            pos = m.end()
+        elif tok == ")":
+            parens -= 1
+            pos = m.end()
+            if parens == 0:
+                return pos
+        else:
+            pos = _skip_string(text, m.start(), tok, depth)
+    return n
+
+
+# ---------- Small helpers over a parsed Source ----------
+
+_STRING_LITERAL = re.compile(r'"((?:[^"\\\n]|\\.)*)"')
+
+
+def string_value(text: str) -> str | None:
+    """The value of a plain, interpolation-free string literal expression
+    (``"users"``), else None."""
+    stripped = text.strip()
+    m = _STRING_LITERAL.fullmatch(stripped)
+    if m is None or "\\(" in m.group(1):
+        return None
+    return m.group(1)
+
+
+def split_args(src: Source, open_paren: int, close_paren: int) -> list[tuple[int, int]]:
+    """Top-level argument spans between a matched pair of brackets."""
+    text = src.text
+    spans: list[tuple[int, int]] = []
+    pos = open_paren + 1
+    start = pos
+    while pos < close_paren:
+        ch = text[pos]
+        if ch in "([{":
+            close = src.close_of(pos)
+            if close < 0 or close > close_paren:
+                break
+            pos = close + 1
+            continue
+        if ch == '"' or (ch == "#" and pos + 1 < close_paren and text[pos + 1] in '#"'):
+            i = bisect.bisect_right(src._starts, pos) - 1
+            if i >= 0 and src.masked[i][0] == pos:
+                pos = max(src.masked[i][1], pos + 1)
+                continue
+        if ch == "/" and src.in_masked(pos):
+            i = bisect.bisect_right(src._starts, pos) - 1
+            pos = max(src.masked[i][1], pos + 1)
+            continue
+        if ch == ",":
+            spans.append((start, pos))
+            start = pos + 1
+        pos += 1
+    if text[start:close_paren].strip():
+        spans.append((start, close_paren))
+    return spans
+
+
+_LABEL = re.compile(r"\s*([A-Za-z_]\w*)\s*:(?!:)")
+
+
+def arg_label(text: str) -> tuple[str | None, str]:
+    """Split ``label: value`` into (label, value); (None, text) if unlabeled."""
+    m = _LABEL.match(text)
+    if m is None:
+        return None, text.strip()
+    return m.group(1), text[m.end():].strip()
+
+
+def clip(text: str, limit: int = 200) -> str:
+    text = " ".join(text.split())
+    return text if len(text) <= limit else text[: limit - 1] + "…"

attackmap_analyzer_swift-0.2.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: attackmap-analyzer-swift
+Version: 0.2.0
+Summary: Swift ecosystem analyzer plugin for AttackMap: Vapor/Hummingbird routes with route-level auth, the iOS/macOS app attack surface, and a SwiftPM/CocoaPods/Carthage SBOM.
+Author: AttackMap Contributors
+Author-email: Matthew Davis <mlaify@mlaify.io>
+Maintainer-email: Matthew Davis <mlaify@mlaify.io>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mlaify/attackmap-analyzer-swift
+Project-URL: Repository, https://github.com/mlaify/attackmap-analyzer-swift
+Project-URL: Issues, https://github.com/mlaify/attackmap-analyzer-swift/issues
+Project-URL: Changelog, https://github.com/mlaify/attackmap-analyzer-swift/blob/main/CHANGELOG.md
+Project-URL: AttackMap core, https://github.com/mlaify/AttackMap
+Keywords: security,static-analysis,appsec,defensive-security,attackmap,attackmap-plugin,swift
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.7.0
+Provides-Extra: core
+Requires-Dist: attackmap>=0.6.0; extra == "core"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: attackmap>=0.6.0; extra == "dev"
+Dynamic: license-file
+
+# attackmap-analyzer-swift
+
+> [!IMPORTANT]
+> **Active development, slow pace.** AttackMap is under active development, but
+> progress may be slow until more contributors or co-maintainers join. Help is
+> very welcome with the core engine, an analyzer, the macOS app, or the docs —
+> see [CONTRIBUTING.md](CONTRIBUTING.md) or open an issue on
+> [mlaify/AttackMap](https://github.com/mlaify/AttackMap/issues) to say hello.
+> Security reports are still welcome at [security@mlaify.io](mailto:security@mlaify.io).
+
+Swift ecosystem analyzer plugin for [AttackMap](https://github.com/mlaify/AttackMap).
+Auto-discovered via the `attackmap.analyzers` entry point once installed.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+> **Status: experimental.** Vapor / Hummingbird routes with route-level auth, the
+> iOS/macOS app attack surface, and a SwiftPM + CocoaPods + Carthage dependency SBOM.
+> Requires an AttackMap core with the app-surface contract (mlaify/AttackMap#347).
+
+## Install
+
+```bash
+uv tool install attackmap --with attackmap-analyzer-swift \
+  --index mlaify=https://pkg.mlaify.io/pypi/simple/ --index-strategy first-index
+# or from source:
+pip install git+https://github.com/mlaify/attackmap-analyzer-swift.git    # alongside attackmap
+```
+
+The analyzer is **experimental and opt-in** (`enabled_by_default=False`): installing
+it does not make it run on every scan. Select it explicitly:
+
+```bash
+attackmap analyze /path/to/swift/project -m swift
+```
+
+Files are walked with `attackmap.sdk.iter_repo_files`: `.build/`, `DerivedData/`,
+`Pods/`, `Carthage/` and AttackMap's shared skip list (`build/`, `.git/`,
+`node_modules/`, ...) are pruned by their name *inside* the repo, and symlinks out
+of the repo are not followed.
+
+## What it does today
+
+- **SwiftPM detection** — recognizes `Package.swift`, `.xcodeproj` / `.xcworkspace`,
+  and `.swift` sources; emits a `SwiftPM` framework hint.
+- **Server-side routes** ([AttackMap#187](https://github.com/mlaify/AttackMap/issues/187)) —
+  Vapor 4 and Hummingbird 1.x/2.x route registrations (`app.get("users", ":id")`,
+  `on(.POST, ...)`, `webSocket`/`ws`, `router.get("/x")`, chained
+  `group.get(use:).post(use:)`), with prefixes from `grouped(...)` / `group(...)`
+  (closures, bindings and chains), and from where a `RouteCollection` or controller
+  is mounted (`register(collection:)`, `addRoutes(to:)`, `addRoutes(_:atPath:)`) when
+  every mount in the same Swift package agrees. Each route carries `auth`, `guards`
+  and `guard_evidence` (AttackMap#256): `required` when Vapor's
+  `X.guardMiddleware()` / `X.redirectMiddleware(...)`, Hummingbird's
+  `IsAuthenticatedMiddleware` or an `*Authorization*Middleware` applies, or the
+  handler calls `req.auth.require(...)` / `context.requireIdentity()` or guards on
+  the caller's identity with a 401. An authenticator alone (`UserAuthenticator()`,
+  `SessionAuthenticator`) leaves the route `unknown`, since it only identifies callers
+  who send credentials. Role checks in the handler (`guard user.roles.contains(.admin)`)
+  are reported as guards. Paths the code computes (`SiteURL.faq.pathComponents`) are
+  kept as `$(SiteURL.faq)`, and an unknown mount as `$(TypeName)`. Test targets
+  (`Tests/`, `*Tests/`) are skipped.
+- **iOS/macOS app attack surface** ([AttackMap#188](https://github.com/mlaify/AttackMap/issues/188)) —
+  reported as `AppSurfaceIssue`s, which core turns into `apple-*` findings with CWE/OWASP ids.
+  - `Info.plist` (XML or binary, read with `plistlib`, never executed): App Transport
+    Security exceptions, i.e. `NSAllowsArbitraryLoads` (medium; low when a scoped key makes
+    iOS 10+ ignore it), `...InWebContent` / `...ForMedia`, and per-domain
+    `NSExceptionAllowsInsecureHTTPLoads` or a TLS minimum below 1.2 (low). Each custom
+    `CFBundleURLSchemes` scheme is an entry point and an `apple-custom-url-scheme` finding
+    (low); the handlers (`application(_:open:options:)`,
+    `scene(_:openURLContexts:)`, `.onOpenURL`) are reported as entry points.
+  - `*.entitlements`: `cs.disable-library-validation`, `allow-dyld-environment-variables`,
+    `allow-unsigned-executable-memory`, `disable-executable-page-protection` (medium);
+    `get-task-allow` outside a Debug/Dev entitlements file (low); `applinks:` universal-link
+    domains as entry points.
+  - `*.xcconfig`: secret-named build settings (`API_KEY`, `CLIENT_SECRET`, `AUTH_TOKEN`)
+    with a literal value (not `$(...)`, not a placeholder), reported as hard-coded secrets
+    with the value masked.
+  - Swift code:
+    - `evaluateJavaScript("...'\(value)'...")` where a value is interpolated *inside a JS
+      string literal* and isn't visibly encoded inline or where it was bound (`sanitized`,
+      `escaped`, `json`, ...). Medium when the value is named like input, else low.
+    - Secret-named values or keys written to `UserDefaults` (`set(_:forKey:)`,
+      `@AppStorage("authToken")`), or copied to `UIPasteboard.general`.
+    - `NSXPCListener` services (entry points), and a `shouldAcceptNewConnection` that
+      returns `true` without checking the peer: no audit token / PID / code-signing
+      requirement, no validate/verify helper, and the connection isn't passed to any call.
+      High when a `NSXPCListener(machServiceName:)` is registered in the same file or
+      target (top-level directory); otherwise low, since a bundled XPC service or anonymous
+      listener is reachable only by its parent app or an endpoint holder.
+    - `NSClassFromString` / `NSSelectorFromString` / `dlopen` on a string built at the
+      call site.
+    - URL-scheme and universal-link handlers as entry points.
+- **Dependency SBOM** — parses `Package.resolved` (formats **v1**, **v2**, and **v3**,
+  including the copy Xcode stashes under `*.xcworkspace/xcshareddata/swiftpm/`) into
+  the scan's dependency inventory, marking direct vs. transitive by cross-referencing
+  the `Package.swift` manifest. SwiftPM pins carry their repository URL, which
+  `--cve` matches against OSV's `SwiftURL` ecosystem. CocoaPods `Podfile.lock` pods
+  are inventoried (`cocoapods`; direct when listed under `DEPENDENCIES:`, subspecs
+  folded into their pod); OSV has no CocoaPods database, so they aren't CVE-matched.
+  Carthage `Cartfile.resolved` pins are inventoried as `carthage` (direct when the
+  `Cartfile` lists them, a leading `v` dropped from tag versions) with the repository URL,
+  so `--cve` matches them against OSV's `SwiftURL` ecosystem like SwiftPM pins.
+- **Framework hints** — flags server-side frameworks (Vapor, Hummingbird, Kitura,
+  Perfect) when declared in the manifest.
+- **Entrypoints** — `main.swift` and `@main`.
+
+- **Objective-C / Objective-C++** ([AttackMap#190](https://github.com/mlaify/AttackMap/issues/190)) —
+  a second analyzer in this package, `objc` (opt-in: `-m objc`), for `.m`/`.mm` files that
+  look like Objective-C (not MATLAB). It runs the same project-file checks (Info.plist,
+  entitlements, xcconfig, Cartfile.resolved) and, in code: URL-scheme / universal-link / XPC
+  entry points, `evaluateJavaScript:` with a `stringWithFormat:` `%@` inside a JS string
+  literal, secret-named values or keys in `NSUserDefaults` or on the pasteboard, XPC
+  listeners that return `YES` without checking the peer, `NSClassFromString` /
+  `NSSelectorFromString` / `dlopen` on built strings, and the native weaknesses shared with
+  the C/C++ plugins: a non-literal, non-localized format with no arguments
+  (`[NSString stringWithFormat:msg]`, `NSLog(msg)`) as `format_string`, and `/bin/sh -c`
+  with a built command or `system()`/`popen()` on a non-literal as `native_command_exec`.
+  `NSFileManager`/`NSURL` file sinks aren't reported (no Objective-C taint pass yet).
+  When both analyzers run, core's merge drops the duplicate project-file signals.
+
+## Roadmap
+
+- Taint for Swift/Objective-C sources (URL-scheme parameters to WKWebView / file sinks).
+
+Part of the [Swift analyzer epic](https://github.com/mlaify/AttackMap/issues/204).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+```
+
+## License
+
+[MIT](LICENSE). Copyright (c) 2026 Matthew Davis and AttackMap Contributors.

attackmap_analyzer_swift-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+attackmap_analyzer_swift/__init__.py,sha256=gUAWMW11wZcslK-XzBfwzddIEFlWSODewiZNrxgPRoQ,112
+attackmap_analyzer_swift/analyzer.py,sha256=bUXmKQiAFOwcpAWzpLu4EvJ_xk0dj8Cdk8OdNGxjArI,12595
+attackmap_analyzer_swift/apple_surface.py,sha256=4lZ9oAF4PpMWKxAWkEcxy9djTa4y8oUDoOoZBoeIGpk,32041
+attackmap_analyzer_swift/objc.py,sha256=ZIpQazCaiZbSAHQ1wgmxz9RNwVsMgc6vNksOuocXI9c,22134
+attackmap_analyzer_swift/routes.py,sha256=uBFbKTtm7WYCsp5FS1vuqGVcrsP6H2EeAwrL170i9SA,51659
+attackmap_analyzer_swift/sbom.py,sha256=104s2rzvolkSMf5d_7NBkPag5WftxfTf-pAsz71horI,1939
+attackmap_analyzer_swift/swiftsrc.py,sha256=r_PEIg27qnSCfQxZib7XwUYsY_nW86aBZVdhzr9qXco,7964
+attackmap_analyzer_swift-0.2.0.dist-info/licenses/LICENSE,sha256=vtPQVGUyxq359j0JmD3_eJaXyHmaHyjzaMOtaLwJc88,1097
+attackmap_analyzer_swift-0.2.0.dist-info/METADATA,sha256=ly99GJ5RKdXfvyWvuunYbF8f9nYS6L3KEehaEr0PeLM,10027
+attackmap_analyzer_swift-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+attackmap_analyzer_swift-0.2.0.dist-info/entry_points.txt,sha256=e_-1ufbXrCrWOFAD3aldobb7-EPOM9WKHy3eWcTKEp0,114
+attackmap_analyzer_swift-0.2.0.dist-info/top_level.txt,sha256=zEpqb9TzFle_vNrDOOdgaAnLxKCsWflwn-qx7-SZJR0,25
+attackmap_analyzer_swift-0.2.0.dist-info/RECORD,,

attackmap_analyzer_swift-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

attackmap_analyzer_swift-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[attackmap.analyzers]
+objc = attackmap_analyzer_swift:ObjCAnalyzer
+swift = attackmap_analyzer_swift:SwiftAnalyzer

attackmap_analyzer_swift-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Davis and AttackMap Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

attackmap_analyzer_swift-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+attackmap_analyzer_swift