local-image-gen-security 0.1.0__tar.gz

local_image_gen_security-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

local_image_gen_security-0.1.0/NOTICE

@@ -0,0 +1,5 @@
+local-image-gen-security (the LIGSP checker)
+Copyright 2026 33rd-kk
+
+Licensed under the Apache License, Version 2.0 (see LICENSE). It uses
+only Python's standard library and includes no third-party code.

local_image_gen_security-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: local-image-gen-security
+Version: 0.1.0
+Summary: Checks a local image-generation setup (ComfyUI, A1111 / Forge, hubs, model folders) against the Local Image Generation Security Profile: read-only, only where you point it
+Author: 33rd-kk
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/33rd-kk/local-image-gen-security
+Project-URL: Issues, https://github.com/33rd-kk/local-image-gen-security/issues
+Keywords: security,comfyui,stable-diffusion,image-generation,safetensors,checker
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# ligsp: the LIGSP checker
+
+Checks the image-generation servers and model folders you name against the
+Local Image Generation Security Profile ([profile.md](https://github.com/33rd-kk/local-image-gen-security/blob/main/profile.md)). It is
+read-only, and it contacts only the places you point it at.
+
+```
+ligsp check http://127.0.0.1:8188                      # a ComfyUI
+ligsp check http://127.0.0.1:7860 --models D:\models   # A1111 / Forge and a model folder
+ligsp check http://127.0.0.1:3000 --redact             # a report you can share
+ligsp check --private C:\latentry                       # who can read Latentry's settings and keys
+```
+
+Common default ports: ComfyUI 8188, Comfy Desktop 8000, A1111 / Forge 7860,
+Latentry 3000, InvokeAI 9090, SwarmUI 7801. It tries no port you did not
+name.
+
+## What it checks
+
+| ID | What |
+|---|---|
+| NET-1 | Whether a server on 127.0.0.1 also answers on this computer's network addresses (IPv4 and IPv6) |
+| NET-2 | Whether it can be used from the network without a login or pairing |
+| BE-1 | A server on another computer reached over plain HTTP |
+| WEB-1 | Whether other websites may read its answers (CORS) |
+| WEB-2 | Whether it answers for any host name (DNS rebinding) |
+| WEB-3 | Protective headers on its page |
+| EXT-1 | An extension installer on the server (ComfyUI-Manager), and how many node packs or A1111 extensions it runs (counts only, never names) |
+| DATA-4 | Who besides you can read a hub's private files (`--private FILE` or a folder; Latentry's settings and keys are found by name). Only permissions are read, never content. |
+| MOD-1 | Weight files in a pickle format (`.ckpt`, `.pt`, `.pth`, `.bin`, `.pkl`), files named `.safetensors` that are really pickles, and safetensors headers that do not read |
+
+Exit code 0 when nothing failed, 1 when something failed, 2 for a usage
+error. `--json FILE` (or `-`) writes the same report as JSON.
+
+## What it does not do
+
+- It sends only GET, HEAD and OPTIONS, only to a fixed list of endpoints
+  known to change nothing, with no query strings, to the URLs you give and
+  to the same port on this computer's own addresses. One function sends
+  every request, and it refuses anything else (`transport.py`). A safe
+  method alone is not enough: some servers act on a GET (ComfyUI-Manager
+  removes or restores snapshots on one). It never queues a job, uploads a
+  file or changes a setting.
+- It reads only the fields it needs. ComfyUI's `/system_stats` also lists
+  the server's command line; that is dropped unread.
+- In model folders it opens only `.safetensors` files, and only to read
+  their header. It follows no links out of the folder.
+- For private files it reads only their permissions: the mode, or on
+  Windows the access list, through the Windows API and compared by account
+  ID (SID), so it works in any system language.
+- It sends no telemetry and checks for no updates, and it writes no file
+  unless you ask (`--json FILE`).
+- A pass means these checks found no problem, not that the setup is safe.
+
+Standard library only (Python 3.10+). Tests: `pytest` in this folder, with
+`src` on the path.

local_image_gen_security-0.1.0/README.md

@@ -0,0 +1,56 @@
+# ligsp: the LIGSP checker
+
+Checks the image-generation servers and model folders you name against the
+Local Image Generation Security Profile ([profile.md](https://github.com/33rd-kk/local-image-gen-security/blob/main/profile.md)). It is
+read-only, and it contacts only the places you point it at.
+
+```
+ligsp check http://127.0.0.1:8188                      # a ComfyUI
+ligsp check http://127.0.0.1:7860 --models D:\models   # A1111 / Forge and a model folder
+ligsp check http://127.0.0.1:3000 --redact             # a report you can share
+ligsp check --private C:\latentry                       # who can read Latentry's settings and keys
+```
+
+Common default ports: ComfyUI 8188, Comfy Desktop 8000, A1111 / Forge 7860,
+Latentry 3000, InvokeAI 9090, SwarmUI 7801. It tries no port you did not
+name.
+
+## What it checks
+
+| ID | What |
+|---|---|
+| NET-1 | Whether a server on 127.0.0.1 also answers on this computer's network addresses (IPv4 and IPv6) |
+| NET-2 | Whether it can be used from the network without a login or pairing |
+| BE-1 | A server on another computer reached over plain HTTP |
+| WEB-1 | Whether other websites may read its answers (CORS) |
+| WEB-2 | Whether it answers for any host name (DNS rebinding) |
+| WEB-3 | Protective headers on its page |
+| EXT-1 | An extension installer on the server (ComfyUI-Manager), and how many node packs or A1111 extensions it runs (counts only, never names) |
+| DATA-4 | Who besides you can read a hub's private files (`--private FILE` or a folder; Latentry's settings and keys are found by name). Only permissions are read, never content. |
+| MOD-1 | Weight files in a pickle format (`.ckpt`, `.pt`, `.pth`, `.bin`, `.pkl`), files named `.safetensors` that are really pickles, and safetensors headers that do not read |
+
+Exit code 0 when nothing failed, 1 when something failed, 2 for a usage
+error. `--json FILE` (or `-`) writes the same report as JSON.
+
+## What it does not do
+
+- It sends only GET, HEAD and OPTIONS, only to a fixed list of endpoints
+  known to change nothing, with no query strings, to the URLs you give and
+  to the same port on this computer's own addresses. One function sends
+  every request, and it refuses anything else (`transport.py`). A safe
+  method alone is not enough: some servers act on a GET (ComfyUI-Manager
+  removes or restores snapshots on one). It never queues a job, uploads a
+  file or changes a setting.
+- It reads only the fields it needs. ComfyUI's `/system_stats` also lists
+  the server's command line; that is dropped unread.
+- In model folders it opens only `.safetensors` files, and only to read
+  their header. It follows no links out of the folder.
+- For private files it reads only their permissions: the mode, or on
+  Windows the access list, through the Windows API and compared by account
+  ID (SID), so it works in any system language.
+- It sends no telemetry and checks for no updates, and it writes no file
+  unless you ask (`--json FILE`).
+- A pass means these checks found no problem, not that the setup is safe.
+
+Standard library only (Python 3.10+). Tests: `pytest` in this folder, with
+`src` on the path.

local_image_gen_security-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "local-image-gen-security"
+version = "0.1.0"
+description = "Checks a local image-generation setup (ComfyUI, A1111 / Forge, hubs, model folders) against the Local Image Generation Security Profile: read-only, only where you point it"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+license-files = ["LICENSE", "NOTICE"]
+authors = [{ name = "33rd-kk" }]
+keywords = ["security", "comfyui", "stable-diffusion", "image-generation", "safetensors", "checker"]
+classifiers = [
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Security",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/33rd-kk/local-image-gen-security"
+Issues = "https://github.com/33rd-kk/local-image-gen-security/issues"
+
+[project.scripts]
+ligsp = "ligsp.__main__:main"
+local-image-gen-security = "ligsp.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 140

local_image_gen_security-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

local_image_gen_security-0.1.0/src/ligsp/__init__.py

@@ -0,0 +1,9 @@
+"""Checks a local image-generation setup against the Local Image Generation Security Profile.
+
+Read-only: it sends GET, HEAD and OPTIONS only, to the servers you name and
+to this computer's own addresses, and opens model files only to read
+safetensors headers. See checker/DESIGN.md.
+"""
+
+__version__ = "0.1.0"
+PROFILE_VERSION = "0.1"

local_image_gen_security-0.1.0/src/ligsp/__main__.py

@@ -0,0 +1,106 @@
+"""ligsp check URL ... [--models DIR ...] [--json FILE] [--redact]"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from urllib.parse import urlsplit
+
+from . import __version__
+from .ext import extension_checks
+from .files import file_checks
+from .models import model_checks
+from .net import network_checks, own_lan_addresses
+from .report import Redactor, as_json, as_text, summary
+from .results import FAIL, Target
+from .targets import identify
+from .transport import Transport
+from .web import web_checks
+
+DEFAULT_PORTS = "ComfyUI 8188, Comfy Desktop 8000, A1111 / Forge 7860, Latentry 3000, InvokeAI 9090, SwarmUI 7801"
+
+DESCRIPTION = f"""\
+Checks the image-generation servers and model folders you name against the
+Local Image Generation Security Profile. Read-only: it sends GET, HEAD and OPTIONS
+only, to the URLs you give and to the same port on this computer's own
+network addresses, and it reads only the headers of .safetensors files.
+It tries no other ports. Common defaults: {DEFAULT_PORTS}.
+"""
+
+
+def check_server(transport: Transport, url: str, lan: list[str]) -> Target:
+    transport.allow_url(url)
+    found = identify(transport, url)
+    target = Target(url, found.kind, found.version)
+    results, reachable = network_checks(transport, url, found, lan)
+    target.results.extend(results)
+    if found.answer is not None:
+        web = web_checks(transport, url, found, reachable)
+        target.results.extend(web)
+        any_host = any(r.id == "WEB-2" and r.status in ("warn", "fail") for r in web)
+        target.results.extend(extension_checks(transport, url, found, reachable, any_host))
+    return target
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="ligsp", description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--version", action="version", version=f"ligsp {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+    check = sub.add_parser("check", help="check servers and model folders", description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter)
+    check.add_argument("urls", nargs="*", metavar="URL", help="a server to check, e.g. http://127.0.0.1:8188")
+    check.add_argument("--models", action="append", default=[], metavar="DIR", help="a model folder to check (may be repeated)")
+    check.add_argument("--private", action="append", default=[], metavar="PATH",
+                       help="a private file, or a folder with a hub's private files (Latentry's settings and keys), whose permissions to check")
+    check.add_argument("--json", metavar="FILE", help="also write the report as JSON to FILE ('-' for standard output only)")
+    check.add_argument("--redact", action="store_true", help="hide paths, host names, addresses and ports, to share the report")
+    args = parser.parse_args(argv)
+
+    for url in args.urls:
+        if urlsplit(url).scheme not in ("http", "https") or not urlsplit(url).hostname:
+            parser.error(f"not an http(s) URL: {url}")
+    if not args.urls and not args.models and not args.private:
+        parser.error(f"name at least one server URL, --models folder or --private path (common ports: {DEFAULT_PORTS})")
+
+    redact = Redactor(args.redact)
+    transport = Transport()
+    lan = own_lan_addresses() if args.urls else []
+    for address in lan:
+        redact.add(address, "<this computer>")
+    targets: list[Target] = []
+    for index, url in enumerate(args.urls, 1):
+        parts = urlsplit(url)
+        if parts.hostname and parts.hostname not in ("127.0.0.1", "localhost", "::1"):
+            redact.add(parts.hostname, f"<host{index}>")
+        if parts.port:
+            redact.add(f":{parts.port}", ":<port>")
+        targets.append(check_server(transport, url, lan))
+    for index, folder in enumerate(args.models, 1):
+        path = Path(folder)
+        redact.add(str(path.resolve()), f"<models{index}>")
+        redact.add(folder, f"<models{index}>")
+        target = Target(folder, "models")
+        target.results.extend(model_checks(path))
+        targets.append(target)
+    for index, place in enumerate(args.private, 1):
+        path = Path(place)
+        redact.add(str(path.resolve()), f"<private{index}>")
+        redact.add(place, f"<private{index}>")
+        target = Target(place, "files")
+        target.results.extend(file_checks(path))
+        targets.append(target)
+    redact.add(str(Path.home()), "<home>")
+
+    if args.json != "-":
+        print(as_text(targets, redact))
+    if args.json:
+        data = as_json(targets, redact)
+        if args.json == "-":
+            print(data)
+        else:
+            Path(args.json).write_text(data + "\n", encoding="utf-8")
+    return 1 if summary(targets)[FAIL] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

local_image_gen_security-0.1.0/src/ligsp/ext.py

@@ -0,0 +1,79 @@
+"""Extensions (EXT-1): what runs other people's code on the server, from read-only endpoints.
+
+ComfyUI lists the browser scripts of its custom nodes at /extensions, one
+folder per node pack that has a web part (so the count is a lower bound);
+ComfyUI-Manager answers its version at /v2/manager/version (or the older
+/manager/version). A1111 / Forge list their extensions at
+/sdapi/v1/extensions. Only counts and the Manager's version are kept, never
+the names.
+"""
+
+from __future__ import annotations
+
+import json
+
+from . import fixes
+from .results import FAIL, PASS, WARN, Result
+from .targets import Identified
+from .transport import Transport
+
+MANAGER_PATHS = ("/v2/manager/version", "/manager/version")
+
+
+def _json(answer) -> object:
+    if answer is None or answer.status != 200:
+        return None
+    try:
+        return json.loads(answer.body.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        return None
+
+
+def extension_checks(transport: Transport, base: str, found: Identified, reachable_from_network: bool, any_host: bool) -> list[Result]:
+    """`any_host`: it answers for any host name (WEB-2), so a web page could reach it too."""
+    base = base.rstrip("/")
+    if found.kind == "comfyui":
+        return _comfyui(transport, base, reachable_from_network, any_host)
+    if found.kind == "a1111":
+        return _a1111(transport, base)
+    return []
+
+
+def _comfyui(transport: Transport, base: str, reachable_from_network: bool, any_host: bool) -> list[Result]:
+    results: list[Result] = []
+    listed = _json(transport.request("GET", base + "/extensions"))
+    packs = None
+    if isinstance(listed, list):
+        packs = len({item.split("/")[2] for item in listed if isinstance(item, str) and item.startswith("/extensions/") and item.count("/") >= 3} - {"core"})
+
+    manager = None
+    for path in MANAGER_PATHS:
+        answer = transport.request("GET", base + path)
+        if answer is not None and answer.status == 200 and len(answer.body) < 64:
+            manager = answer.body.decode("utf-8", "replace").strip().strip('"') or "found"
+            break
+
+    evidence = []
+    if packs is not None:
+        evidence.append(f"at least {packs} custom node pack(s) with a web part")
+    if manager:
+        evidence.append(f"ComfyUI-Manager {manager}")
+        if reachable_from_network:
+            status, title = FAIL, "An extension installer (ComfyUI-Manager) can be used from the network"
+        elif any_host:
+            status, title = WARN, "An extension installer (ComfyUI-Manager) is on a server that answers any host name"
+        else:
+            status, title = WARN, "An extension installer (ComfyUI-Manager) is part of this server"
+        results.append(Result("EXT-1", status, title, evidence, fixes.WHY["EXT-1"], fixes.fix("EXT-1", "comfyui")))
+    else:
+        results.append(Result("EXT-1", PASS, "No extension installer answered", evidence))
+    return results
+
+
+def _a1111(transport: Transport, base: str) -> list[Result]:
+    listed = _json(transport.request("GET", base + "/sdapi/v1/extensions"))
+    if not isinstance(listed, list):
+        return []
+    enabled = sum(1 for item in listed if isinstance(item, dict) and item.get("enabled"))
+    return [Result("EXT-1", PASS if enabled == 0 else WARN, f"{enabled} extension(s) enabled", [f"{len(listed)} installed, {enabled} enabled"],
+                   fixes.WHY["EXT-1"], fixes.fix("EXT-1", "a1111"))]

local_image_gen_security-0.1.0/src/ligsp/files.py

@@ -0,0 +1,70 @@
+"""Private files (DATA-4, AUTH-5): settings, keys and tokens that only their owner may read.
+
+A file is named with --private. A folder named there is searched (not
+recursively) for the private files of the hubs the checker knows (Latentry's
+settings file, pairing key, paired-device list and folder-name key). Only
+the files' permissions are read, never their content.
+
+On POSIX that is the mode. On Windows it is the access list, compared by
+SID (see winacl.py), so it works in any system language. Entries for the
+owner, SYSTEM and Administrators are fine; any other account or group
+(Users, Everyone, Authenticated Users, another person) fails.
+"""
+
+from __future__ import annotations
+
+import stat
+import sys
+from pathlib import Path
+
+from . import fixes, winacl
+from .results import FAIL, PASS, UNKNOWN, Result
+
+KNOWN_PRIVATE = ("latentry.settings.json", "latentry.pairing-key", "latentry.pairing-devices.json", "latentry.folder-names-key")
+
+
+def private_files(path: Path) -> list[Path]:
+    if path.is_dir():
+        return [path / name for name in KNOWN_PRIVATE if (path / name).is_file()]
+    return [path] if path.is_file() else []
+
+
+def others_who_can_read(file: Path, platform: str = sys.platform) -> list[str] | None:
+    """Who besides the owner (and Windows itself) can read `file`; None when unknown."""
+    if platform == "win32":
+        found = winacl.readers(str(file))
+        me = winacl.current_user_sid()
+        if found is None or me is None:
+            return None
+        fine = {me, winacl.SYSTEM, winacl.ADMINISTRATORS}
+        return sorted({name for sid, name in found if sid not in fine})
+    mode = file.stat().st_mode
+    others = []
+    if mode & stat.S_IRGRP:
+        others.append("its group")
+    if mode & stat.S_IROTH:
+        others.append("every user")
+    return others
+
+
+def file_checks(path: Path) -> list[Result]:
+    files = private_files(path)
+    if not files:
+        return [Result("DATA-4", UNKNOWN, "No private file found there" + (" (looked for: " + ", ".join(KNOWN_PRIVATE) + ")" if path.is_dir() else ""))]
+    open_files: list[str] = []
+    unknown: list[str] = []
+    for file in files:
+        others = others_who_can_read(file)
+        if others is None:
+            unknown.append(file.name)
+        elif others:
+            open_files.append(f"{file.name}: also readable by {', '.join(others)}")
+    results = []
+    if open_files:
+        results.append(Result("DATA-4", FAIL, f"{len(open_files)} private file(s) can be read by others", open_files, fixes.WHY["DATA-4"], fixes.fix("DATA-4", "files")))
+    readable = len(files) - len(open_files) - len(unknown)
+    if readable:
+        results.append(Result("DATA-4", PASS, f"{readable} private file(s) readable by their owner only", [f.name for f in files if f.name not in unknown and not any(o.startswith(f.name + ":") for o in open_files)]))
+    if unknown:
+        results.append(Result("DATA-4", UNKNOWN, "Could not read the permissions of some files", unknown))
+    return results