spector

Projekte, die den nachfolgenden Best Practices folgen, können sich freiwillig selbst zertifizieren und zeigen, dass sie einen Core-Infrastruktur-Initiative-/OpenSSF-Badge erhalten haben.

Es gibt keine Auswahl an Praktiken, die garantieren können, dass Software niemals Fehler oder Schwachstellen hat. Selbst formale Methoden können fehlschlagen, wenn die Spezifikationen oder Annahmen falsch sind. Auch gibt es keine Auswahl an Praktiken, die garantieren können, dass ein Projekt eine gesunde und gut funktionierende Entwicklungsgemeinschaft erhalten wird. Allerdings können Best Practices dabei helfen, die Ergebnisse von Projekten zu verbessern. Zum Beispiel ermöglichen einige Praktiken die Mehrpersonen-Überprüfung vor der Freigabe, die sowohl helfen können ansonsten schwer zu findende technische Schwachstellen zu finden und gleichzeitig dazu beitragen Vertrauen und den Wunsch nach wiederholter Zusammenarbeit zwischen Entwicklern verschiedener Unternehmen zu schaffen. Um ein Badge zu verdienen, müssen alle MÜSSEN und MÜSSEN NICHT Kriterien erfüllt sein, alle SOLLTEN Kriterien müssen erfüllt sein oder eine Rechtfertigung enthalten, und alle EMPFHOLEN Kriterien müssen erfüllt sein oder nicht (wir wollen sie zumindest berücksichtigt wissen). Wenn lediglich ein allgemeiner Kommentar angebeben werden soll, keine direkte Begründung, dann ist das erlaubt, wenn der Text mit "//" und einem Leerzeichen beginnt. Feedback ist willkommen auf derGitHub-Website als Issue oder Pull-Request. Es gibt auch eine E-Mail-Liste für allgemeine Diskussionen.

Wir stellen Ihnen gerne die Informationen in mehreren Sprachen zur Verfügung, allerdings ist die englische Version maßgeblich, insbesondere wenn es Konflikte oder Inkonsistenzen zwischen den Übersetzungen gibt.
Wenn dies Ihr Projekt ist, zeigen Sie bitte Ihren Badge-Status auf Ihrer Projektseite! Der Badge-Status sieht so aus: Badge-Level für Projekt 14829 ist silver So können Sie ihn einbetten:
Sie können Ihren Badge-Status anzeigen, indem Sie Folgendes in Ihre Markdown-Datei einbetten:
[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/14829/badge)](https://www.bestpractices.dev/projects/14829)
oder indem Sie Folgendes in Ihr HTML einbetten:
<a href="https://www.bestpractices.dev/projects/14829"><img src="https://www.bestpractices.dev/projects/14829/badge"></a>


Dies sind die Kriterien das Level Silber. Sie können auch die Kriterien für die Level Passing oder Gold sehen.

Baseline Series: Baseline Niveau 1 Baseline Niveau 2 Baseline Niveau 3

        

 Grundlagen 17/17 ●

  • Allgemein

    Hinweis: Andere Projekte können den selben Namen benutzen.

    Memory backbone for AI agents. Four-tier store — working, episodic, semantic, procedural — with decay, consolidation, and association graphs. Fused semantic + SIMD-accelerated hybrid recall, in-process MCP, REST/gRPC, and language SDKs.

    Bitte verwenden Sie das SPDX-License-Expression-Format; Beispiele sind "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "GPL-2.0+", "LGPL-3.0+", "MIT" und "(BSD-2-Clause OR Ruby)". Geben sie nicht die einfachen oder doppelten Anführungszeichen mit an.
    Wenn es mehr als eine Programmiersprache gibt, listen Sie sie als kommagetrennte Werte (Leerzeichen sind optional) auf und sortieren Sie sie von am häufigsten zum am wenigsten verwendeten. Wenn es eine lange Liste gibt, bitte mindestens die ersten drei häufigsten auflisten. Wenn es keine Programmiersprache gibt (z. B. ist dies nur ein Dokumentations- oder Testprojekt), verwenden Sie das einzelne Zeichen "-". Bitte verwenden Sie eine herkömmliche Großschreibung für jede Sprache, z.B. "JavaScript".
    Das Common Platform Enumeration (CPE) ist ein strukturiertes Namensschema für IT-Systeme, Software und Pakete. Es wird in diversen Systemen und Datenbanken bei der Meldung von Schwachstellen verwendet.

  • Voraussetzungen


    Genug für ein Badge!

    Das Projekt MUSS ein bestimmtes Level erreichen. [achieve_passing]

  • Grundlegende Informationen auf der Projektwebseite


    Genug für ein Badge!

    Die Informationen darüber, wie man mitwirken kann, MÜSSEN die Anforderungen für akzeptable Beiträge (z.B. einen Hinweis auf einen erforderlichen Codierungsstandard) enthalten. (URL erforderlich) [contribution_requirements]

    https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#coding-standards


  • Projektüberwachung


    Genug für ein Badge!

    Das Projekt SOLLTE einen rechtlichen Mechanismus haben, wo alle Entwickler von nicht-trivialen Beiträgen versichern, dass sie rechtlich ermächtigt sind, diese Beiträge zu machen. Der häufigste und leicht umsetzbare Ansatz, ist die Verwendung eines Developer Certificate of Origin (DCO) , wo Benutzer "signed-off-by" in ihren Commits und die Projektlinks zur DCO-Website hinzufügen. Allerdings DARF dies als Contributor License Agreement (CLA) oder als ein anderer rechtlicher Mechanismus implementiert werden. (URL erforderlich) [dco]
    Die DCO ist der empfohlene Mechanismus, weil er einfach zu implementieren ist, im Quellcode verfolgt wird und git direkt eine "signed-off" Funktion mit "commit -s" unterstützt. Um am effektivsten zu sein, ist es am besten, wenn die Projektdokumentation erklärt, was "signed-off" für dieses Projekt bedeutet. Eine CLA ist eine rechtliche Vereinbarung, die die Bedingungen definiert, unter denen intellektuelle Werke an eine Organisation oder ein Projekt lizenziert wurden. Ein Contributor Assignment Agreement (CAA) ist eine gesetzliche Vereinbarung, die die Rechte an einer intellektuellen Arbeit an eine andere Person überträgt; Projekte müssen keine CAAs haben, da CAA das Risiko erhöht, dass potenzielle Mitwirkende nicht dazu beitragen werden, vor allem, wenn der Empfänger eine gewinnorientierte Organisation ist. Die Apache Software Foundation CLAs (die individuelle Contributor-Lizenz und die Corporate CLA) sind Beispiele für CLAs, für Projekte, die bestimmt haben, dass die Risiken dieser CLAs für das Projekt geringen sind als ihre Vorteile.

    The project enforces a mandatory legal contribution mechanism using both the Developer Certificate of Origin (DCO 1.1) and a formal Contributor License Agreement (CLA.md). All commits require a Signed-off-by line (git commit -s) certifying the author is legally authorized to submit the code under Apache 2.0, enforced by automated CI checks. https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#developer-certificate-of-origin-dco-11--licensing


    Genug für ein Badge!

    Das Projekt MUSS eindeutig sein Projekt-Governance-Modell (die Art, wie es Entscheidungen fällt, einschließlich der wichtigsten Rollen) definieren und dokumentieren. (URL erforderlich) [governance]
    Es muss einen gut dokumentierten, etablierten Weg geben, Entscheidungen zu treffen und Streitigkeiten zu lösen. In kleinen Projekten kann dies so einfach sein wie, "der Projektinhaber und -Leiter trifft alle endgültigen Entscheidungen". Es gibt verschiedene Führungs-Modelle, darunter wohlwollender Diktator und formale Meritokratie; Für weitere Details siehe Governance-Modelle . Sowohl zentralisierte (z.B. Single-Maintainer) als auch dezentrale (z.B. Gruppen-Maintainer) Ansätze wurden erfolgreich in Projekten verwendet. Die Governance-Informationen müssen nicht die Möglichkeit einer Projektspaltung dokumentieren, da dies für FLOSS-Projekte immer möglich ist.

    The project documents its open-source governance model, leadership roles, and decision-making mechanics in GOVERNANCE.md:
    https://github.com/spectrayan/spector/blob/main/GOVERNANCE.md

    Key Roles & Structure:

    • Defined meritocratic roles: Project Lead, Technical Lead (TSC Chair), Architecture Working Group (AWG), Technical Steering Committee (TSC), Maintainers, Committers/Reviewers, and Contributors.
    • A 4-tier Contributor Ladder with transparent progression criteria from first-time contributor to TSC member based on sustained technical merit. Corporate titles hold no review or merge authority.

    Decision-Making Process:

    • Lazy Consensus (72 hours without objection) for routine pull requests, bug fixes, and documentation.
    • Simple Majority (>50%) of Maintainers for committer appointments and non-breaking deprecations.
    • Supermajority (2/3 vote) of the Technical Steering Committee for formal Architecture Decision Records (ADRs), breaking API changes, and governance amendments.

    Genug für ein Badge!

    Das Projekt MUSS einen Code of Conduct etablieren und an einem üblichen Ort veröffentlichen. (URL erforderlich) [code_of_conduct]
    Projekte können das Miteinander ihrer Gemeinschaft verbessern und Erwartungen in Bezug auf akzeptables Verhalten setzen, indem sie einen Verhaltenskodex verfassen. Dies kann helfen, Probleme zu vermeiden, bevor sie auftreten, und das Projekt zu einem einladenderen Ort zu machen. Dies sollte sich nur auf das Verhalten innerhalb der Gemeinschaft/ am Arbeitsplatz des Projekts konzentrieren. Beispielhafte Verhaltenskodizes sind der Linux Kernel Code of Conduct, der Contributor Covenant Code of Conduct, der Debian Code of Conduct, der Ubuntu Code of Conduct, der Fedora Code of Conduct, der GNOME Code Of Conduct, der KDE Community Code of Conduct, der Python Community Code of Conduct, die Ruby Community Conduct Guideline und der Rust Code of Conduct.

    The project adopts the Contributor Covenant Code of Conduct (v2.1), posted in the standard root location (CODE_OF_CONDUCT.md), outlining community standards, enforcement guidelines, and reporting channels (support@spectrayan.com). https://github.com/spectrayan/spector/blob/main/CODE_OF_CONDUCT.md


    Genug für ein Badge!

    Das Projekt MUSS klar und deutlich die Rollen- auf Aufgabenverteilung dokumentieren, inklusive einzelnen Tätigkeiten, die von den Rollenträgern ausgeführt werden müssen. Es MUSS eindeutig sein wer welche Rolle hat, auch wenn es in anderer Form dokumentiert ist. (URL erforderlich) [roles_responsibilities]
    Die Dokumentation für Governance und Rollen und Verantwortlichkeiten können an einem Ort sein.

    Spector defines and documents its project roles, responsibilities, and specific tasks in GOVERNANCE.md (https://github.com/spectrayan/spector/blob/main/GOVERNANCE.md#2-governance-structure--roles), covering the Project Lead, Technical Lead, Architecture Working Group, Technical Steering Committee, Maintainers, Committers, and Contributors. Specific role holders and maintainer responsibilities are publicly assigned in .github/CODEOWNERS (https://github.com/spectrayan/spector/blob/main/.github/CODEOWNERS) and GOVERNANCE.md (https://github.com/spectrayan/spector/blob/main/GOVERNANCE.md#immediate-eligibility-for-committer--reviewer-status)


    Genug für ein Badge!

    Das Projekt MUSS in der Lage sein, mit minimaler Unterbrechung fortzufahren, wenn eine beliebige Person nicht in der Lage ist oder stirbt. Insbesondere MUSS das Projekt in der Lage sein, Probleme zu lösen, vorgeschlagene Änderungen zu akzeptieren und Versionen der Software freizugeben, innerhalb einer Woche nach der Bestätigung, dass eine Person nicht mehr in der Lage ist oder gestorben ist. Dies DARF sichergestellt werden, indem man jemandem anderes notwendige Schlüssel, Passwörter und gesetzliche Rechte gibt, um das Projekt fortzusetzen. Einzelpersonen, die ein FLOSS-Projekt ausführen, DÜRFEN dies durch die Bereitstellung von Schlüsseln in einer Lockbox und einer Willenserklärung zur Bereitstellung von erforderlichen gesetzlichen Rechten (z. B. für DNS-Namen). (URL erforderlich) [access_continuity]

    Project continuity and credential redundancy are documented in GOVERNANCE.md under Project Continuity & Redundancy (https://github.com/spectrayan/spector/blob/main/GOVERNANCE.md#32-project-continuity--redundancy). Organization ownership, domain management, and GitHub repository administration are distributed across multiple administrative contacts with backup credentials. Review and merge rights on main are assigned to team aliases in .github/CODEOWNERS (https://github.com/spectrayan/spector/blob/main/.github/CODEOWNERS), and release credentials (GHCR, PyPI, npm, Maven) are managed via organization-level GitHub Actions secrets, ensuring that issue triage, PR merges, and software releases can continue within one week if any individual contributor becomes unavailable.


    Genug für ein Badge!

    Das Projekt SOLLTE einen Bus-Faktor von 2 oder mehr haben. (URL erforderlich) [bus_factor]
    Ein "bus factor" (aka "LKW-Faktor") ist die minimale Anzahl von Projektmitgliedern, die plötzlich aus einem Projekt ("hit by a bus") verschwinden müssen, bevor das Projekt aufgrund fehlender kompetenter Mitarbeiter stockt. Das Truck-Factor-Tool kann dies für Projekte auf GitHub schätzen. Weitere Informationen finden Sie unter Bewertung des Busfaktors von Git-Repositories von Cosentino et al.

    The project maintains a bus factor of 2 or more across its core codebase and governance hierarchy, as documented in ACKNOWLEDGMENTS.md (https://github.com/spectrayan/spector/blob/main/ACKNOWLEDGMENTS.md#open-source-contributors) and GOVERNANCE.md (https://github.com/spectrayan/spector/blob/main/GOVERNANCE.md#3-the-4-tier-contributor-ladder). Technical knowledge, code review authority, and codebase maintenance are shared between Project Lead Bharat Joshi (@sbharatjoshi) and active committer Timothy Kim (@timothytkim), who has authored merged contributions across kernel documentation, provider architecture, index diagnostics, and observability, alongside functional team aliases in .github/CODEOWNERS (https://github.com/spectrayan/spector/blob/main/.github/CODEOWNERS).


  • Dokumentation


    Genug für ein Badge!

    Das Projekt MUSS eine dokumentierte Roadmap, für mindestens das nächste Jahr haben, die beschreibt, was das Projekt beabsichtigt zu tun und nicht zu tun. (URL erforderlich) [documentation_roadmap]
    Das Projekt könnte die Roadmap nicht umsetzen, das ist ok; Der Zweck der Roadmap ist es, potenziellen Nutzern/innen und Entwicklern/innen zu helfen, die beabsichtigte Richtung des Projekts zu verstehen. Sie muss nicht detailliert sein.

    The project maintains a public 12-month architectural roadmap in ROADMAP.md (https://github.com/spectrayan/spector/blob/main/ROADMAP.md) and docs/roadmap.md (https://github.com/spectrayan/spector/blob/main/docs/roadmap.md). It outlines planned milestones from Q4 2026 through Q3 2027 and JDK 29 LTS (including native Goose extensions, streamable HTTP MCP transport, A2A federated memory sharing, Valhalla value classes, and edge SIMD optimizations). It explicitly details project boundaries and non-goals (what the project will NOT do: it will not become an agent orchestrator framework, will not become a general-purpose SQL database, will not introduce external framework dependencies into the core engine kernel, and will not gate features behind proprietary cloud services).


    Genug für ein Badge!

    Das Projekt MUSS in der Dokumentation die Architektur (alias High-Level-Design) der vom Projekt entwickelten Software bereitstellen. Wenn das Projekt keine Software produziert, wählen Sie "nicht anwendbar" (N/A). (URL erforderlich) [documentation_architecture]
    Eine Softwarearchitektur erläutert die grundlegenden Strukturen eines Programms, d.h. die Hauptkomponenten des Programms, die Beziehungen zwischen ihnen und die Schlüsseleigenschaften dieser Komponenten und Beziehungen.

    The project documents its system architecture and high-level design in the Architecture Overview documentation (https://github.com/spectrayan/spector/blob/main/docs/architecture/overview.md) and the public documentation portal (https://spectrayan.github.io/spector/architecture/overview/). The documentation details the complete multi-tier system architecture, including client SDKs, the Synapse transport layer (MCP and Armeria REST/gRPC), the 4-tier cognitive memory engine (Working, Episodic, Semantic, Procedural), Panama FFM off-heap memory-mapped slab layouts, SIMD vector acceleration kernels, and dataflow/threading models. Additional subsystem architecture deep-dives are maintained under docs/architecture/ and in the Architecture Decision Record catalog (https://github.com/spectrayan/spector/blob/main/docs/adr/catalog.md).


    Genug für ein Badge!

    Das Projekt MUSS dokumentieren, was der/die Benutzer/in in Bezug auf die Sicherheit der Projektsoftware (seine "Sicherheitsanforderungen") erwarten kann und nicht erwarten kann. (URL erforderlich) [documentation_security]
    Dies sind Sicherheitsanforderungen, die die Software erfüllen soll.

    The project documents its security requirements and threat model in SECURITY.md under Security Guarantees & Non-Guarantees (https://github.com/spectrayan/spector/blob/main/SECURITY.md#security-guarantees--non-guarantees-security-requirements) and in docs/architecture/encryption-at-rest.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/encryption-at-rest.md). Users can expect physical on-disk tenant isolation with zero cross-tenant leakage, AES-256-GCM at-rest encryption for text payloads and WAL, memory safety via Panama FFM bounded arenas, timing-attack-resistant authentication, and continuous vulnerability scanning. Users cannot expect application-layer vector decryption (vector slabs are zero-copy memory mapped for SIMD search and require operator-managed volume/disk encryption), implicit perimeter protection (operators must configure TLS/mTLS or reverse proxies for public exposure), or defense against a compromised host OS/root user.


    Genug für ein Badge!

    Das Projekt MUSS eine "Quickstart"-Anleitung für neue Benutzer/innen haben, um ihnen zu helfen, schnell mit der Software umgehen zu können. (URL erforderlich) [documentation_quick_start]
    Die Idee ist, den Benutzern/innen zu zeigen, wie man anfängt und was die Software überhaupt macht. Dies ist entscheidend für potenzielle Benutzer/innen, um loszulegen.

    The project provides a dedicated quick start guide titled 'Quick Start — 30 Seconds to First Memory' in docs/getting-started/quickstart.md (https://github.com/spectrayan/spector/blob/main/docs/getting-started/quickstart.md) and on the public documentation portal (https://spectrayan.github.io/spector/getting-started/quickstart/). The guide enables new users to store and recall their first memory within seconds via multiple paths: a zero-install MCP launcher (npx -y @spectrayan/spector mcp), the Python SDK (pip install spector-client), the TypeScript SDK (npm install @spectrayan/spector-client), and a one-command Docker Compose setup. It is also linked directly from the root README (https://github.com/spectrayan/spector/blob/main/README.md#quick-start).


    Genug für ein Badge!

    Das Projekt MUSS sich bemühen, die Dokumentation mit der aktuellen Version der Projektergebnisse (einschließlich der vom Projekt produzierten Software) stehts zu aktualisieren. Jegliche bekannte Dokumentationsfehler, die es inkonsistent machen, MÜSSEN behoben werden. Wenn die Dokumentation in der Regel aktuell ist, aber fälschlicherweise einige ältere Informationen enthält, die nicht mehr wahr sind, behandeln Sie diese als Störung, dann verfolgen und beheben Sie diese wie üblich. [documentation_current]
    Die Dokumentation DARF Informationen über Unterschiede oder Änderungen zwischen Versionen der Software und/oder Links zu älteren Versionen der Dokumentation enthalten. Die Absicht dieses Kriteriums ist nicht, dass die Dokumentation perfekt sein muss, vielmehr soll Arbeit investiert, um die Dokumentation konsistent zu halten

    The project actively maintains documentation consistency with the current codebase through automated CI gates and disciplined documentation review. The automated documentation deployment pipeline in .github/workflows/docs.yml (https://github.com/spectrayan/spector/blob/main/.github/workflows/docs.yml) and CI suite enforce strict validation (mkdocs build --strict), causing the build to fail if broken links, missing references, or documentation warnings are introduced. In addition, the PR checklist in CONTRIBUTING.md (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#pr-checklist) requires doc updates for any altered interfaces, and documentation defects are tracked and resolved in GitHub Issues (demonstrated in major synchronization overhauls like PR #960 aligning docs with runtime kernel implementations).


    Genug für ein Badge!

    Die Projekt-Repository-Titelseite und / oder Website MUSS alle Errungenschaften, die erreicht wurden, einschließlich dieses Best Practices Abzeichens, innerhalb von 48 Stunden nach der öffentlichen Anerkennung ausweisen und verlinken. (URL erforderlich) [documentation_achievements]
    Eine Errungenschaft ist jegliche Form von externen Kriterien, auf die das Projekt speziell hingearbeitet hat, um diese zu erreichen, einschließlich einiger Abzeichen. Diese Informationen müssen nicht auf der ersten Seite der Website des Projekts einzusehen sein. Ein Projekt, das GitHub verwendet, kann Errungenschaften auf der Repository-Vorderseite setzen, indem man sie der README-Datei hinzufügt.

    The project prominently displays and hyperlinks all project achievements and badges on the repository front page in README.md (https://github.com/spectrayan/spector/blob/main/README.md#L14-L23), including the OpenSSF Best Practices badge (hyperlinked to https://www.bestpractices.dev/projects/14829), CI build status, PyPI package releases, npm package releases, Docker GHCR images, documentation status, and contributor recognition. Maintainers update and display recognized badges immediately upon attainment.


  • Zugänglichkeit und Internationalisierung


    Genug für ein Badge!

    Das Projekt (beide Projektwebsite und Projektergebnisse) SOLLTE den bewährten Praktiken der Erreichbarkeit folgen, damit Personen mit Behinderungen noch an dem Projekt teilnehmen und die Projektergebnisse nutzen können, wo es vernünftig ist. [accessibility_best_practices]
    Für Webanwendungen siehe Web Content Accessibility Guidelines (WCAG 2.0) und dessen unterstützendes Dokument Understanding WCAG 2.0; Siehe auch W3C accessibility information. Für GUI-Anwendungen sollten Sie die umweltbezogenen Barrierefreiheitsrichtlinien verwenden (z.B. Gnome, KDE, XFCE, Android, iOS , Mac und Windows). Einige TUI-Anwendungen (z.B. `ncurses`-Programme) können bestimmte Dinge ausführen, um sich selbst zugänglicher zu machen (z.B. `alpine`'s `force-arrow-cursor`-Einstellung). Die meisten Kommandozeilen-Anwendungen sind ziemlich unzugänglich. Dieses Kriterium ist oft N/A, z.B. für Programmbibliotheken. Hier sind einige Beispiele, welche Maßnahmen zu ergreifen oder Fragen zu berücksichtigen sind:
    • Stellen Sie Text Alternativen für alle Nicht-Text-Inhalte zur Verfügung, so dass dieser in andere Formen umgewandelt werden kann, wie z.B. Großdruck, Blindenschrift, Sprache, Symbole oder einfachere Sprache ( WCAG 2.0-guideline 1.1)
    • Farbe ist nicht das einzige Mittel um Informationen zu übermitteln, die eine Aktion anzeigen, zu einer Eingabe auffordern oder visuelle Elemente unterscheiden. (WCAG 2.0 guideline 1.4.1)
    • Die visuelle Darstellung von Text und Textbildern hat einen Kontrast Verhältnis von mindestens 4,5:1, außer für großen Text, nebensächlichen Text, und Logos(WCAG 2.0 guideline 1.4.3)
    • Machen Sie alle Funktionalitäten von einer Tastatur aus erreichbar (WCAG guideline 2.1)
    • Ein GUI oder ein webbasiertes Projekt SOLLTE mit mindestens einen Screen-Reader auf der Zielplattform(en) testen (z.B. NVDA, Jaws oder WindowEyes auf Windows; VoiceOver auf Mac & iOS; Orca auf Linux/BSD; TalkBack auf Android). TUI-Programme DÜRFEN die Übermalung reduzieren, um eine redundante Lesung durch Screenreader zu verhindern.

    The project follows accessibility best practices across its documentation and interfaces. The public documentation portal (https://spectrayan.github.io/spector/) is built using Material for MkDocs, configured in mkdocs.yml (https://github.com/spectrayan/spector/blob/main/mkdocs.yml#L8-L31) to adhere to WCAG 2.1 Level AA accessibility standards. It features semantic HTML5 navigation, accessible keyboard controls, high-contrast dark and light mode color palette toggles, screen-reader-friendly layout hierarchies, and descriptive alt text on all imagery. Furthermore, CLI and server components support plain-text and structured JSON outputs to remain fully accessible to terminal screen readers.


    Genug für ein Badge!

    Die Projektsoftware SOLLTE internationalisiert werden, um eine einfachen Zugang für die Kultur, Region oder Sprache der Zielgruppe zu ermöglichen. Wenn die Internationalisierung (i18n) nicht andzuwenden ist (z. B. die Software keine für Endbenutzer beabsichtigte Texte erzeugt und keinen menschlich lesbaren Text sortiert), wählen Sie "nicht anwendbar" (N/A). [internationalization]
    Lokalisierung "bezieht sich auf die Anpassung eines Produkt-, Applikations- oder Dokumentinhalts, um die Sprache, kulturelle und andere Anforderungen eines bestimmten Zielmarktes zu erfüllen." Internationalisierung ist die "Gestaltung und Entwicklung eines Produkt-, Applikations- oder Dokumentinhaltes, die eine einfache Lokalisierung für Zielgruppen ermöglicht, die in Kultur, Region oder Sprache variieren." (Siehe W3Cs "Lokalisierung vs. Internationalisierung" .) Software erfüllt dieses Kriterium einfach dadurch, dass sie internationalisiert ist. Es ist keine Lokalisierung für eine andere Sprache erforderlich, denn sobald Software internationalisiert wurde, ist es möglich für andere, an der Lokalisierung zu arbeiten.

    Internationalization does not apply to the core software produced by the project. Spector is a backend cognitive memory engine, native off-heap storage kernel, and Model Context Protocol (MCP) server for autonomous AI agents, as described in docs/architecture/overview.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/overview.md). It processes vector embeddings, association graphs, and structured JSON machine-to-machine payloads, and does not generate human-facing user interface text or locale-dependent strings. All text ingestion and payload handling natively support full Unicode/UTF-8 character encodings.


  • Andere


    Genug für ein Badge!

    Wenn die Projektseiten (Website, Repository und Download-URLs) Passwörter für die Authentifizierung von externen Benutzern speichern, müssen die Passwörter als iterierte Hashes mit einem per-User-Salt unter Verwendung eines Key-Stretching (iterierten) Algorithmus (z. B. Argon2id, Bcrypt, Scrypt, or PBKDF2). Wenn die Projektseiten hierfür keine Passwörter speichern, wählen Sie "nicht anwendbar" (N/A) aus. [sites_password_security]
    Beachten Sie, dass die Verwendung von GitHub dieses Kriterium erfüllt. Dieses Kriterium gilt nur für Passwörter, die für die Authentifizierung von externen Benutzern in die Projektseiten verwendet werden (inbound authentication). Wenn sich die Projektseiten auf anderen Seiten anmelden müssen (outbound authentication), müssen sie eventuell Authorization-Tokens für diesen Zweck anders speichern (da das Speichern eines Hashes nutzlos wäre). Dies gilt für das Kriterium crypto_password_storage zu den Projektseiten, ähnlich wie sites_https.

    The project sites do not store passwords for the authentication of external users. The project repository and download artifacts are hosted on GitHub (https://github.com/spectrayan/spector), and the project documentation website is statically hosted via GitHub Pages (https://spectrayan.github.io/spector/). The project sites maintain no independent user authentication database or credential storage, relying entirely on the host platform's infrastructure.


 Verbesserungs-/Nacharbeits-Kontrolle 1/1 ●

  • Vorherige Versionen


    Genug für ein Badge!

    Das Projekt MUSS die am häufigsten verwendeten älteren Versionen des Produkts beibehalten oder einen Upgrade-Pfad zu neueren Versionen bieten. Wenn der Upgrade-Pfad schwierig durchzuführen ist, muss das Projekt dokumentieren, wie das Upgrade durchgeführt werden kann (z. B. die Interfaces, die sich geändert haben, detaillierte Anleitung für die Aktualisierung des Upgrades). [maintenance_or_update]

    The project maintains active versions and provides transparent upgrade and migration paths documented in CHANGELOG.md (https://github.com/spectrayan/spector/blob/main/CHANGELOG.md) adhering to Semantic Versioning (SemVer 2.0.0) and Keep a Changelog standards. Each release notes interface changes, configuration deprecations, and backward-compatible migration chains. Supported active release streams are explicitly defined in SECURITY.md under Supported Versions (https://github.com/spectrayan/spector/blob/main/SECURITY.md#supported-versions). In addition, storage bundle headers enforce binary schema format version validation to guarantee on-disk data integrity across version upgrades.


 Berichterstattung 3/3 ●

  • Bug-Report-Prozess


    Genug für ein Badge!

    Das Projekt MUSS ein Issue-Tracking-System zur Verwaltung einzelner Issues verwenden. [report_tracker]

    The project uses GitHub Issues to track all bug reports, feature requests, and architectural tasks, with dedicated templates for bug reports, feature requests, and performance investigations. https://github.com/spectrayan/spector/issues


  • Anfälligkeits-Prozessbericht


    Genug für ein Badge!

    Das Projekt MUSS die Reporter/in von allen in den letzten 12 Monaten bekanntgegebenen Schwachstellenberichte aufführen, mit Ausnahme der Reporter, die Anonymität erbeten. Wurde in den letzten 12 Monaten keine Schwachstelle festgestellt, wählen Sie "nicht anwendbar" (N/A). (URL erforderlich) [vulnerability_report_credit]

    No vulnerability reports were received or resolved in the last 12 months. The project's documented policy in SECURITY.md under Coordinated Disclosure Process (https://github.com/spectrayan/spector/blob/main/SECURITY.md#coordinated-disclosure-process) explicitly mandates that reporters are publicly credited in published GitHub Security Advisories (GHSAs) and release notes unless they explicitly request anonymity, alongside permanent recognition in ACKNOWLEDGMENTS.md (https://github.com/spectrayan/spector/blob/main/ACKNOWLEDGMENTS.md).


    Genug für ein Badge!

    Das Projekt MUSS den Prozess für die Meldung von Schwachstellen auf der Projektseite veröffentlichen. (URL erforderlich) [vulnerability_response_process]
    Dies steht im Zusammenhang mit vulnerability_report_process, welcher erfordert, dass es eine dokumentierte Möglichkeit gibt, Schwachstellen zu melden. Es bezieht sich auch auf vulnerability_report_response, welcher eine Antwort auf Schwachstellenberichte innerhalb eines bestimmten Zeitrahmens erfordert.

    The project maintains a formal, step-by-step vulnerability response process documented in SECURITY.md under Coordinated Disclosure Process and Response Timeline & Severity SLAs (https://github.com/spectrayan/spector/blob/main/SECURITY.md#coordinated-disclosure-process). The policy outlines the complete workflow: initial receipt acknowledgment within 24 to 48 hours, private reproduction and triage in a secure fork with CVE assignment, collaborative patch preparation, and coordinated release publication alongside a GitHub Security Advisory (GHSA). Target fix windows are codified by CVSS v3.1 severity tiers (7 days for Critical, 14 days for High, 30 days for Medium).


 Qualität 19/19 ●

  • Programmierstil


    Genug für ein Badge!

    Das Projekt MUSS die spezifischen Codierungsstilrichtlinien für die primären Programmierprachen, die es verwendet, einhalten, und erfordern, dass die Beiträge die Bedingungen generell erfüllen. (URL erforderlich) [coding_standards]
    In den meisten Fällen erfolgt dies durch Verweis auf einige vorhandene Stilrichtlinien, möglicherweise Auflistung Unterschiede. Diese Stilrichtlinien können Möglichkeiten zur Verbesserung der Lesbarkeit und zur Verringerung der Wahrscheinlichkeit von Mängeln (einschließlich Schwachstellen) enthalten. Viele Programmiersprachen haben eine oder mehrere weit verbreitete Stilrichtlinien. Beispiele für Style Guides sind Google-Style-Guides und SEI CERT Coding Standards .

    The project defines and enforces language-specific coding standards in CONTRIBUTING.md under Coding Standards (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#coding-standards). For Java (the primary engine language), it mandates Java 25 modern idioms (records, sealed classes, pattern matching), Project Panama FFM bounded arena lifecycles, Vector API conventions (FloatVector.SPECIES_PREFERRED), zero-allocation hot paths, and comprehensive Javadoc on all public interfaces. For TypeScript and Python client SDKs, it requires strict typing, sanitization standards, and standard package layouts. Compliance is required for all contributions and enforced via the PR checklist in .github/pull_request_template.md (https://github.com/spectrayan/spector/blob/main/.github/pull_request_template.md) and automated CI build gates.


    Genug für ein Badge!

    Das Projekt MUSS automatisch dafür sorgen, dass die ausgewählten Stilrichtlinien eingehalten werden, wenn mindestens ein FLOSS-Tool vorhanden ist, welches das in der gewählten Programmiersprache tun kann. [coding_standards_enforced]
    Dies kann mit Hilfe von statischen Analysewerkzeugen und/oder durch das Durchlaufen des Codes durch Code-Umformatierer erreicht werden. In vielen Fällen ist die Werkzeugkonfiguration im Projekt-Repository enthalten (da verschiedene Projekte unterschiedliche Konfigurationen wählen können). Projekte DÜRFEN Stil Ausnahmen erlauben (und werden es in der Regel); Wo Ausnahmen getroffen werden, MÜSSEN sie selten sein und MÜSSEN dokumentiert werden an der Stelle im Code, wo sie auftreten, so dass diese Ausnahmen überprüft werden können und so dass Werkzeuge sie automatisch in der Zukunft bearbeiten können. Beispiele für solche Werkzeuge sind ESLint (JavaScript), Rubocop (Ruby) und devtools check (R).

    The project automatically enforces coding style and source standards in its CI pipeline and build lifecycle using automated FLOSS tooling. License headers and file formatting are automatically verified during the build via the license-maven-plugin, failing compilation and CI runs if any source file violates the style template, as documented in CONTRIBUTING.md (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#license-headers). Architectural and structural code styles are automatically enforced via ArchUnit (com.tngtech.archunit) during test runs, and static code quality/idiom rules are enforced across Java, TypeScript, and Python via automated GitHub CodeQL analysis on every pull request (.github/workflows/codeql.yml: https://github.com/spectrayan/spector/blob/main/.github/workflows/codeql.yml).


  • Produktivsystem


    Genug für ein Badge!

    Build-Systeme für native Binärdateien MÜSSEN die relevanten Compiler- und Linker- (Umgebungs-) Variablen, die an sie übergeben werden (z.B. CC, CFLAGS, CXX, CXXFLAGS und LDFLAGS), respektieren und an Compiler- und Linker-Aufrufe weiterleiten. Ein Build-System DARF sie mit zusätzlichen Flags erweitern; Es DARF NICHT einfach die mitgelieferten Werte ersetzen. Wenn keine nativen Binärdateien erzeugt werden, wählen Sie "nicht anwendbar" (N/A). [build_standard_variables]
    Es sollte einfach sein, spezielle Build-Features wie Address Sanitizer (ASAN) zu aktivieren, oder verteilte und bewährte Best Practices einzuhalten (z.B. durch einfaches Einschalten von Compiler-Flags).

    The project does not build or compile native binaries (such as C/C++ ELF executables or shared libraries). The build system is Apache Maven (pom.xml: https://github.com/spectrayan/spector/blob/main/pom.xml), producing pure JVM bytecode and JAR artifacts for OpenJDK 25, alongside npm and pip packages for TypeScript and Python SDKs. Native memory and SIMD hardware acceleration are accessed directly within the JVM using Java 25 Project Panama Foreign Function & Memory (FFM) and the Vector API without invoking native C/C++ compilers or linkers.


    Genug für ein Badge!

    Das Build- und Installationssystem SOLLTE Debugging-Informationen beibehalten, wenn sie in den entsprechenden Flags angefordert werden (z. B. "install -s" wird nicht verwendet). Wenn kein Build- oder Installationssystem vorhanden ist (z. B. typische JavaScript-Bibliotheken), wählen Sie "nicht anwendbar" (N / A). [build_preserve_debug]
    Z. B., die Festlegung von CFLAGS (C) oder CXXFLAGS (C ++) sollte die relevanten Debugging-Informationen erstellen, wenn diese Sprachen verwendet werden, und sie sollten während der Installation nicht ignoriert werden. Debugging-Informationen werden für Unterstützung und Analyse benötigt und sind auch nützlich, um das Vorhandensein von Härtungsmerkmalen in den kompilierten Binärdateien zu messen.

    The build and packaging system preserves full debugging information across all compiled artifacts. The Apache Maven compiler configuration in pom.xml (https://github.com/spectrayan/spector/blob/main/pom.xml#L731-L746) preserves all javac debugging symbols (line number tables, source file attributes, and local variable tables) in generated class files and shaded JARs. No symbol-stripping tools or unstripped binary flags are applied during compilation or installation, allowing complete stack traces, line-number mapping, and interactive debugging in production and developer environments.


    Genug für ein Badge!

    Das Build-System für die Software, die durch das Projekt erzeugt wird, DARF NICHT rekursive Unterverzeichnisse aufbauen, wenn es Querverweise in den Unterverzeichnissen gibt. Wenn kein Build- oder Installationssystem vorhanden ist (z.B. typische JavaScript-Bibliotheken), wählen Sie "nicht anwendbar" (N / A). [build_non_recursive]
    Die interne Abhängigkeitsinformationen des Build-Systems des Projektes müssen präzise sein, andernfalls können Änderungen an dem Projekt nicht korrekt erfolgen. Falsche Builds können zu Defekten (einschließlich Schwachstellen) führen. Ein häufiger Fehler bei großen Build-Systemen ist die Verwendung eines "rekursiven Builds" oder "rekursiven Make", d.h. einer Hierarchie von Unterverzeichnissen, die Quelldateien enthalten, wobei jedes Unterverzeichnis unabhängig aufgebaut ist. Es sei denn, jedes Unterverzeichnis ist völlig unabhängig, was ist ein Fehler ist, da die Abhängigkeitsinformationen nicht korrekt sind.

    The project uses Apache Maven's multi-module reactor architecture defined in the root pom.xml (https://github.com/spectrayan/spector/blob/main/pom.xml#L54-L100) rather than recursive make or isolated subdirectory build scripts. Maven analyzes all inter-module dependencies globally to construct a single topological Directed Acyclic Graph (DAG) before compilation starts. Modules are compiled in strict dependency order, circular dependencies are automatically detected and forbidden, and cross-module artifacts are resolved deterministically across the reactor.


    Genug für ein Badge!

    Das Projekt MUSS in der Lage sein, den Prozess der Generierung von Informationen aus Quelldateien zu wiederholen und genau das gleiche Bit-für-Bit-Ergebnis zu erhalten. Wenn kein Build auftritt (z. B. Skriptsprachen, in denen der Quellcode direkt verwendet wird, anstatt kompiliert zu werden), wählen Sie "nicht anwendbar" (N / A). [build_repeatable]
    GCC- und Clang-Benutzer finden die Option -frandom-seed womöglich nützlich; In manchen Fällen kann dies dadurch gelöst werden, dass man eine Sortierreihenfolge erzwingt. Weitere Vorschläge finden Sie auf der reproducible Build Seite.

    The project achieves bit-for-bit reproducible builds using Apache Maven's standardized Reproducible Builds mechanism configured in pom.xml (https://github.com/spectrayan/spector/blob/main/pom.xml#L190). By defining a fixed <project.build.outputTimestamp> (2024-01-01T00:00:00Z), Maven plugins (maven-jar-plugin, maven-shade-plugin, flatten-maven-plugin) normalize zip entry timestamps, file ordering, and manifest metadata, ensuring identical cryptographic byte output from repeated builds on OpenJDK 25.


  • Installationssystem


    Genug für ein Badge!

    Das Projekt MUSS eine Möglichkeit zur einfachen Installation und Deinstallation der Software haben, unter Benutzung einer häufig verwendeten Methode. [installation_common]
    Beispiele hierfür sind die Verwendung eines Paketmanagers (auf dem System- oder Sprachniveaus), "make install/uninstall" (unterstützt DESTDIR), einem Container im Standardformat oder ein virtuelles Maschinenbild im Standardformat. Der Installations- und Deinstallationsvorgang (z.B. seine Verpackung) DARF von einem/einer Dritten implementiert werden, solange es FLOSS ist.

    The project provides standard, conventional installation and uninstallation methods across platforms, documented in docs/getting-started/installation.md (https://github.com/spectrayan/spector/blob/main/docs/getting-started/installation.md) and the root README (https://github.com/spectrayan/spector/blob/main/README.md#quick-start). Package managers support standard life-cycle commands: Python SDK via pip install / pip uninstall spector-client, TypeScript SDK via npm install / npm uninstall @spectrayan/spector-client, Homebrew via brew install / brew uninstall spector, Scoop for Windows via scoop install / scoop uninstall spector, Docker Compose via docker compose up -d / docker compose down -v, and standalone binary removal via rm -rf ~/.spector.


    Genug für ein Badge!

    Das Installationssystem für den/die Endbenutzer/in MUSS Standardkonventionen zur Auswahl des Zielortes, in dem gebildete Artefakte zur Installationszeit geschrieben werden, folgen. Zum Beispiel, wenn es Dateien auf einem POSIX-System installiert, muss es die DESTDIR-Umgebungsvariable verwenden. Wenn es kein Installationssystem oder keine Standardkonvention gibt, wählen Sie "nicht anwendbar" (N/A). [installation_standard_variables]

    The installation system for end-users honors standard directory selection conventions across platforms, documented in scripts/install.sh (https://github.com/spectrayan/spector/blob/main/scripts/install.sh#L16-L45) and docs/getting-started/installation.md (https://github.com/spectrayan/spector/blob/main/docs/getting-started/installation.md). On POSIX systems, the standalone installer honors the standard DESTDIR and SPECTOR_HOME environment variables as well as the --install-dir <path> CLI flag to redirect all binary and JAR writes. Similarly, client package installations honor standard package-manager destination conventions: pip honors --target and --prefix, and npm honors --prefix.


    Genug für ein Badge!

    Das Projekt MUSS einen Weg für potenzielle Entwickler bereithalten, um schnell alle erforderlich Projektergebnisse und Support-Umgebungen zu installieren, um Änderungen vornehmen zu können, einschließlich der Tests und Test-Umgebung. Dies MUSS mit einer gängigen Methode durchgeführt werden können. [installation_development_quick]
    Dies DARF mit einem generierten Container- und/oder Installationsskript(en) implementiert werden. Externe Abhängigkeiten würden typischerweise durch das Aufrufen von System- und/oder Sprachpaketmanager(n), als external_dependencies, installiert.

    The project provides standard, rapid developer environment setup instructions in CONTRIBUTING.md under Development Setup (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#development-setup) and AGENTS.md (https://github.com/spectrayan/spector/blob/main/AGENTS.md#prerequisites). Potential developers can clone the repository and automatically download all reactor dependencies, build artifacts, test libraries (JUnit 5, AssertJ, jqwik), and execution environments using standard Apache Maven conventions via mvn clean compile and mvn test. No non-standard tooling, proprietary compilers, or external database services are required to develop or run tests locally.


  • Externe gepflegte Komponenten


    Genug für ein Badge!

    Das Projekt MUSS externe Abhängigkeiten in computerlesbarer Form auflisten. (URL erforderlich) [external_dependencies]
    Dies geschieht in der Regel mit den Konventionen des Paketmanagers und / oder des Buildsystems. Dies hilft auch installation_development_quick zu erfüllen.

    The project declares all external dependencies in standardized, computer-processable formats across all modules. Java dependencies are centrally managed via Apache Maven's machine-readable XML format in root pom.xml under dependencyManagement (https://github.com/spectrayan/spector/blob/main/pom.xml#L200-L725) and spectrayan-bom, complemented by the cyclonedx-maven-plugin (https://github.com/spectrayan/spector/blob/main/pom.xml#L1016-L1032) which generates standardized machine-readable CycloneDX 1.6 Software Bill of Materials (SBOMs) in XML and JSON. Client packages declare dependencies in standard package manifests (package.json for TypeScript and pyproject.toml for Python), and dependencies are automatically parsed and monitored by GitHub Dependabot (.github/dependabot.yml).


    Genug für ein Badge!

    Projekte MÜSSEN ihre externen Abhängigkeiten (einschließlich Bequemlichkeitskopien) überwachen oder regelmäßig überprüfen, um bekannte Schwachstellen zu erkennen und ausnutzbare Schwachstellen zu beheben oder sie als unausweichlich zu verifizieren. [dependency_monitoring]
    Dies kann mit einem Ursprungsanalysator / Abhängigkeitsüberprüfungswerkzeug / Softwarezusammensetzungsanalysator wie OWASPs Dependency-Check, Sonatypes Nexus Auditor, Synopsys' Black Duck Software Composition Analysis, und Bundler-Audit (für Ruby) erreicht werden. Einige Paketmanager beinhalten Mechanismen, um dies zu tun. Es ist akzeptabel, wenn die Anfälligkeit der Komponenten nicht ausgenutzt werden kann, aber diese Analyse ist schwierig und es ist manchmal einfacher, den Part einfach zu aktualisieren oder zu reparieren.

    The project continuously monitors and updates external dependencies for known security vulnerabilities using automated tooling configured in .github/dependabot.yml (https://github.com/spectrayan/spector/blob/main/.github/dependabot.yml) and container vulnerability scanning in .github/workflows/container-security.yml (https://github.com/spectrayan/spector/blob/main/.github/workflows/container-security.yml). Automated scans run weekly across all package ecosystems (Maven, npm, Docker base images, and GitHub Actions). Flagged vulnerabilities are actively remediated (demonstrated in issue #880 resolving all open dependency alerts and recent container base image digest pinning), resulting in 0 open Dependabot alerts across the repository.


    Genug für ein Badge!

    Das Projekt MUSS entweder:
    1. Es einfach machen, wiederverwendbare extern gepflegte Komponenten zu identifizieren und zu aktualisieren;oder
    2. Die Standardkomponenten des Systems oder der Programmiersprache verwenden.
    Dann, wenn eine Schwachstelle in einer wiederverwendeten Komponente gefunden wird, wird es einfach sein diese Komponente zu aktualisieren. [updateable_reused_components]
    Ein typischer Weg, um dieses Kriterium zu erfüllen, ist die Verwendung von System- und Programmiersprachen-Paketverwaltungssystemen. Viele FLOSS-Programme werden mit "Convenience-Bibliotheken" ausgestattet, die lokale Kopien der Standardbibliotheken (ggf. geforkt) enthalten. Prinzipiell ist das gut. Wenn jedoch das Programm diese lokalen (geforkten) Kopien verwenden *muss*, dann wird die Aktualisierung der "Standard"-Bibliotheken, als Sicherheitsupdate, diese zusätzlichen Kopien immer noch verwundbar lassen. Dies ist vor allem ein Problem für Cloud-basierte Systeme; Wenn der Cloud-Provider seine "Standard"-Bibliotheken aktualisiert, aber das Programm sie nicht verwendt, dann helfen die Updates nicht wirklich. Siehe z.B. "Chromium: Why it isn't in Fedora yet as a proper package" von Tom Callaway .

    The project satisfies both criteria. First, as documented in AGENTS.md under Architecture Conventions (https://github.com/spectrayan/spector/blob/main/AGENTS.md#architecture-conventions-for-ai-agents), the core engine kernel (spector-core, spector-cpu, spector-kernel, spector-memory, and spector-index) has an invariant of zero third-party dependencies, relying purely on standard OpenJDK 25 platform APIs (java.lang.foreign, jdk.incubator.vector, java.lang.ScopedValue). Second, all external dependencies used in gateway and transport layers are centrally managed in root pom.xml under properties and dependencyManagement (https://github.com/spectrayan/spector/blob/main/pom.xml#L110-L185), enabling single-variable version bumps across the entire multi-module reactor, and automated via GitHub Dependabot (.github/dependabot.yml).


    Genug für ein Badge!

    Das Projekt SOLLTE vermeiden veraltete oder obsolete Funktionen und APIs zu verwenden, für die FLOSS-Alternativen in der eingesetzten Technologie verfügbar sind (ihr "Technologie-Stack") und eine Supermajorität der Benutzer, die das Projekt unterstützt (so dass die Benutzer den Zugriff auf die Alternative haben ). [interfaces_current]

    The project actively avoids deprecated and obsolete APIs by targeting modern toolchains (Java 25, Angular 22, Python 3.11+). As documented in CONTRIBUTING.md under Coding Standards (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#coding-standards), the Java codebase strictly utilizes modern replacement standards: Project Panama FFM (java.lang.foreign) replacing obsolete sun.misc.Unsafe and JNI, Virtual Threads and ScopedValues replacing legacy ThreadLocal concurrency patterns, and modern records/sealed classes replacing verbose legacy POJOs. Compiler warnings and CodeQL static analysis workflows in .github/workflows/codeql.yml (https://github.com/spectrayan/spector/blob/main/.github/workflows/codeql.yml) continuously monitor for and eliminate deprecated API invocations.


  • Automatisierte Test-Suite


    Genug für ein Badge!

    Eine automatisierte Test-Suite MUSS bei jedem Check-In auf ein gemeinsames Repository für mindestens einen Zweig angewendet werden. Diese Test-Suite muss einen Bericht über Erfolg oder Misserfolg des Testes produzieren. [automated_integration_testing]
    Diese Anforderung kann als Teilmenge von test_continuous_integration angesehen werden, konzentriert sich aber nur auf das Testen, ohne eine kontinuierliche Integration zu fordern.

    Automated test suites are executed on every check-in and pull request targeting the main branch via GitHub Actions in .github/workflows/ci.yml (https://github.com/spectrayan/spector/blob/main/.github/workflows/ci.yml#L110-L135). The workflow runs unit, property, and benchmark test suites across multiple hardware architectures (x86_64 and aarch64), generates Surefire XML test reports archived as build artifacts (actions/upload-artifact under **/target/surefire-reports/*.xml), aggregates JaCoCo code coverage reports, and outputs clear pass/fail check statuses visible directly on GitHub Actions (https://github.com/spectrayan/spector/actions).


    Genug für ein Badge!

    Das Projekt MUSS Regressionstests zu einer automatisierten Test-Suite hinzufügen für mindestens 50% der, in den letzten sechs Monaten, gefixten Bugs. [regression_tests_added50]

    The project strictly requires and adds automated regression tests for bug fixes, far exceeding the 50% threshold. The project policy documented in CONTRIBUTING.md under Testing Expectations (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#testing-expectations) mandates unit tests for all bug fixes. Recent bug fixes demonstrate 100% regression test coverage: PR #984 (https://github.com/spectrayan/spector/pull/984) fixing silent Hebbian edge drops added dedicated regression tests (ForgetAndVacuumHonestyTest.java, HebbianGraphMaxDegreeMismatchTest.java), PR #982 (https://github.com/spectrayan/spector/pull/982) fixing batch bundle fabrication added SpectorBatchUnimplementedStepsTest.java, and PR #991 added distance precision regression suites. All regression tests run automatically in CI on every push.


    Genug für ein Badge!

    Das Projekt MUSS automatisierte FLOSS-Test-Suite(s) haben, die mindestens 80% Aussage Berichterstattung haben, wenn es mindestens ein FLOSS-Tool gibt, das dieses Kriterium in der ausgewählten Sprache erfüllen kann. [test_statement_coverage80]
    Viele FLOSS-Tools stehen zur Verfügung, um die Test-Coverage zu beurteilen, einschließlich gcov/lcov, Blanket.js, Istanbul, JCov, und covr (R). Beachten Sie, dass das Erfüllen dieses Kriteriums keine Garantie dafür ist, dass die Test-Suite gründlich ist, hingegen ist das Verfehlen dieses Kriteriums ein starker Indikator für eine schlechte Test-Suite.

    The project measures and enforces statement and branch coverage using the open-source JaCoCo tool (jacoco-maven-plugin), configured in the root pom.xml (https://github.com/spectrayan/spector/blob/main/pom.xml#L1046-L1048) with an 80% coverage target baseline. The automated CI pipeline in .github/workflows/ci.yml (https://github.com/spectrayan/spector/blob/main/.github/workflows/ci.yml#L134-L142) runs jacoco:report-aggregate on every check-in to measure statement execution across unit, property, and integration tests, ensuring that core memory layouts, decay algorithms, and scoring kernels maintain 80%+ statement coverage.


  • Neue Funktionalitätsüberprüfung


    Genug für ein Badge!

    Das Projekt MUSS eine formale schriftliche Richtlinie dazu haben, wie wichtige neue Funktionalität hinzugefügt werden. Tests für die neue Funktionalität MÜSSEN zu einer automatisierten Test-Suite hinzugefügt werden. [test_policy_mandated]

    The project maintains a formal written testing policy documented in CONTRIBUTING.md under Testing Expectations (https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#testing-expectations). The policy explicitly mandates automated tests for all new functionality across defined categories: unit tests are required for all new classes and bug fixes, jqwik property tests are required for new indexing algorithms and binary codecs, and integration tests are required for all end-to-end pathways and gateways. This formal requirement is enforced on every change proposal via mandatory checklist items in the pull request template (https://github.com/spectrayan/spector/blob/main/.github/pull_request_template.md).


    Genug für ein Badge!

    Das Projekt MUSS in seinen dokumentierten Anweisungen für Änderungsvorschläge die Richtlinien enthalten, die Tests für große neue Funktionalität hinzugefügt werden sollen. [tests_documented_added]
    Allerdings ist auch eine informelle Regel akzeptabel, solange die Tests in der Praxis hinzugefügt werden.

    The policy on adding tests is explicitly documented in the instructions for change proposals in CONTRIBUTING.md under 'Pull Request Process' and 'PR Checklist', requiring contributors to verify that 'Tests added/updated covering changed behavior and edge cases (mvn test)'. This is also enforced in the GitHub Pull Request submission template (.github/pull_request_template.md). https://github.com/spectrayan/spector/blob/main/CONTRIBUTING.md#pr-checklist


  • Warnhinweise


    Genug für ein Badge!

    Projekte MÜSSEN praktischerweise sehr streng mit Warnungen in der Projektsoftware sein. [warnings_strict]
    Bei manchen Projekten können einige Warnungen effektiv nicht aktiviert werden. Was benötigt wird, ist ein Beleg dafür, dass das Projekt danach strebt, Warnungen zu aktivieren, wo es möglich ist, so dass Fehler frühzeitig erkannt werden.

    The project applies strict quality gates: CodeQL runs with the 'security-extended' query suite, documentation builds enforce 'mkdocs build --strict' (failing CI on any warning or broken link), and Maven license checks strictly fail the build on any compliance warning. https://github.com/spectrayan/spector/blob/main/.github/workflows/codeql.yml


 Sicherheit 13/13 ●

  • Wissen über sichere Entwicklungspraktiken


    Genug für ein Badge!

    Das Projekt MUSS sichere Designprinzipien (von "know_secure_design"), soweit anwendbar, umsetzen. Wenn das Projekt keine Software produziert, wählen Sie "nicht anwendbar" (N/A). [implement_secure_design]
    Beispielsweise sollten die Projektergebnisse fehlersichere Vorgaben haben (Zugriffsentscheidungen sollten standardmäßig verweigert werden und die Installation von Projekten sollte standardmäßig sicher sein). Die Projektergebnisse sollten auch eine vollständige Vermittlung haben (jeder Zugang, der begrenzt werden kann, muss auf Autorität überprüft werden und nicht umgangen werden können). Beachten Sie, dass in einigen Fällen Prinzipien in Konflikt geraten, in welchen eine Entscheidung getroffen werden muss (z.B. viele Mechanismen können die Dinge komplexer machen, gegen die "Wirtschaftlichkeit des Mechanismus" verstoßen / halten Sie es einfach).

    The project systematically implements core secure design principles across its architecture, documented in SECURITY.md under Security Guarantees & Non-Guarantees (https://github.com/spectrayan/spector/blob/main/SECURITY.md#security-guarantees--non-guarantees-security-requirements) and in docs/architecture/encryption-at-rest.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/encryption-at-rest.md). Principles implemented include: (1) Defense in Depth: combining physical on-disk filesystem isolation, AES-256-GCM at-rest encryption, 128-bit Bloom tag gating, and recall visit budgets; (2) Least Privilege: scoped API keys and tenant namespaces that restrict agent access strictly to authorized engrams; (3) Fail-Closed Defaults: implemented in SecurityConfig.java via FailClosedAuthenticationEntryPoint and strict binary bundle magic/CRC32C validation that halts corrupt reads; (4) Complete Mediation: all REST and MCP memory access passes through authentication and authorization filters; and (5) Memory Safety by Design: using Java 25 Panama FFM bounded arenas to eliminate buffer overflows and use-after-free corruption.


  • Verwende grundlegend gute kryptographische Praktiken

    Beachten Sie, dass einige Software keine kryptographischen Mechanismen verwenden muss. Wenn Ihr Project Software erstellt das (1) kryptographische funktionen einbindet, aktiviert, oder ermöglicht und (2) aus den USA heraus an nicht US-Bürger verteilt wird, dann könnten sie rechtlich zu weiterne Schritten gezwungen sein. Meistens beinhaltet dies lediglich das Senden einer E-Mail. Für mehr Informationen, siehe den Abschnitt zu Encryption in Understanding Open Source Technology & US Export Controls.

    Genug für ein Badge!

    Die Standard-Sicherheitsmechanismen innerhalb der Projektsoftware DÜRFEN NICHT von kryptographischen Algorithmen oder Modi mit bekannten schweren Mängeln abhängen (z.B. der SHA-1-Kryptographie-Hash-Algorithmus oder der CBC-Modus in SSH). [crypto_weaknesses]
    Sorgen über den CBC-Modus in SSH werden in CERT: SSH CBC vulnerability erläutert.

    The default security mechanisms avoid algorithms or modes with known weaknesses. Hashing exclusively uses SHA-256 (HMAC-SHA256) rather than SHA-1, and symmetric encryption strictly uses AES-256 in GCM (AEAD) mode rather than CBC or unauthenticated modes.


    Genug für ein Badge!

    Das Projekt SOLLTE mehrere kryptographische Algorithmen unterstützen, so dass Benutzer schnell wechseln können, wenn eines defekt ist. Verbreitete symmetrische Schlüsselalgorithmen umfassen AES, Twofish und Serpent. Verbreitete kryptographische Hash-Algorithmus-Alternativen umfassen SHA-2 (einschließlich SHA-224, SHA-256, SHA-384 UND SHA-512) und SHA-3. [crypto_algorithm_agility]

    The project achieves cryptographic agility by delegating cryptographic operations to the standard OpenJDK Java Cryptography Architecture (JCA) and TLS provider abstractions, as documented in docs/architecture/encryption-at-rest.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/encryption-at-rest.md). By leveraging JCA SPIs (javax.crypto.Cipher, javax.crypto.Mac, and java.security.MessageDigest), the system supports multiple standardized cryptographic algorithms: for hashing and blind indexing, it accommodates alternatives across the SHA-2 family (SHA-256, SHA-384, SHA-512) and SHA-3; for transport security, it negotiates multiple modern AEAD ciphers (AES-256-GCM, AES-128-GCM, and ChaCha20-Poly1305); and symmetric encryption can be configured to alternative approved ciphers without rewriting storage engine code.


    Genug für ein Badge!

    Das Projekt MUSS die Speicherung von Anmeldeinformationen (z.B. Passwörter und dynamische Token) und private kryptografische Schlüssel in Dateien, die von anderen Informationen getrennt sind (z.B. Konfigurationsdateien, Datenbanken und Protokolle), unterstützen und den Benutzern erlauben, sie ohne Code-Neukompilierung zu aktualisieren und zu ersetzen . Wenn das Projekt keine Anmeldeinformationen und private kryptographische Schlüssel verarbeitet, wählen Sie "nicht anwendbar" (N/A). [crypto_credential_agility]

    The project supports storing authentication credentials, tokens, and cryptographic keys in isolated external secret files separate from application code, database stores, and configuration files, documented in deploy/docker/entrypoint.sh (https://github.com/spectrayan/spector/blob/main/deploy/docker/entrypoint.sh#L12-L36) and docs/architecture/encryption-at-rest.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/encryption-at-rest.md). In Docker and Kubernetes environments, API keys, JWT secrets, and TLS private key certificates are mounted from external secret files (e.g., /run/secrets/ or Kubernetes Secret volumes) or injected via environment variables at runtime. Operators can rotate, update, or replace credentials and keys dynamically without recompiling any code or modifying application images.


    Genug für ein Badge!

    Die vom Projekt produzierte Software SOLLTE sichere Protokolle für alle Netzwerkkommunikationen unterstützen , wie SSHv2 oder höher, TLS1.2 oder höher (HTTPS), IPsec, SFTP und SNMPv3. Unsichere Protokolle wie FTP, HTTP, Telnet, SSLv3 oder früher, und SSHv1 SOLLTEN standardmäßig deaktiviert werden und nur aktiviert werden, wenn der/die Benutzer/in es speziell konfiguriert. Wenn die vom Projekt produzierte Software keine Netzwerkkommunikation verwendet, wählen Sie "nicht anwendbar" (N/A). [crypto_used_network]

    The software supports secure network communication protocols across all network endpoints, using TLS 1.2 and TLS 1.3 for HTTPS REST APIs, gRPC services, and inter-node cluster replication, documented in docs/architecture/encryption-at-rest.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/encryption-at-rest.md) and synapse/spector-synapse/src/main/java/com/spectrayan/spector/synapse/replication/ReplicationTlsFactory.java (https://github.com/spectrayan/spector/blob/main/synapse/spector-synapse/src/main/java/com/spectrayan/spector/synapse/replication/ReplicationTlsFactory.java). Insecure and legacy protocols (such as FTP, Telnet, SSLv2, SSLv3, and TLS 1.0/1.1) are unsupported and disabled by default by the OpenJDK 25 security provider and Netty transport layer. For remote cluster and gateway deployments, mutual TLS (mTLS) and HTTPS are enforced, while local agent communications default to secure, memory-isolated stdio process pipes.


    Genug für ein Badge!

    Wenn die Software, die durch das Projekt produziert wird, TLS unterstützt oder verwendet, SOLLTE sie mindestens TLS Version 1.2 verwenden. Beachten Sie, dass der Vorgänger von TLS SSL genannt wurde. Wenn die Software TLS nicht verwendet, wählen Sie "nicht anwendbar" (N/A). [crypto_tls12]

    The software natively supports TLS 1.2 and modern TLS 1.3 for all encrypted network communications, documented in ReplicationTlsFactory.java (https://github.com/spectrayan/spector/blob/main/synapse/spector-synapse/src/main/java/com/spectrayan/spector/synapse/replication/ReplicationTlsFactory.java#L46-L50) and docs/architecture/encryption-at-rest.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/encryption-at-rest.md). Cluster node replication explicitly enforces TLS 1.3 contexts (public static final String TLS_V1_3 = "TLSv1.3"), and gateway REST/gRPC endpoints support both TLS 1.2 and TLS 1.3 through the OpenJDK 25 and Netty SSL engines. All legacy protocols prior to TLS 1.2 (SSLv2, SSLv3, TLS 1.0, TLS 1.1) are permanently disabled at the runtime platform level.


    Genug für ein Badge!

    Die Software, die vom Projekt produziert wird, muss, wenn es TLS unterstützt, die TLS-Zertifikatsüberprüfung standardmäßig bei der Verwendung von TLS, einschließlich auf Subresources, durchführen. Wenn die Software TLS nicht verwendet, wählen Sie "nicht anwendbar" (N/A). [crypto_certificate_verification]
    Beachten Sie, dass eine falsche TLS-Zertifikatsüberprüfung ein häufiger Fehler ist. Weitere Informationen finden Sie unter "The Most Dangerous Code in the World: Validating SSL Certificates in Non-Browser Software" von Martin Georgiev et al. und "Do you trust this application?" von Michael Catanzaro.

    The software performs strict X.509 TLS certificate verification by default on all TLS connections. For inter-node cluster replication, ReplicationTlsFactory.java (https://github.com/spectrayan/spector/blob/main/synapse/spector-synapse/src/main/java/com/spectrayan/spector/synapse/replication/ReplicationTlsFactory.java#L101-L125) configures TrustManagerFactory instances backed by verified truststores and mandates mutual certificate authentication (setNeedClientAuth(true)). For outbound HTTP/REST connections (such as provider APIs, remote gateways, and SDK clients), the underlying OpenJDK and Netty network clients enforce standard CA certificate chain validation, expiration checks, and SNI hostname verification by default, rejecting untrusted or invalid certificates unless explicitly overridden in development environments.


    Genug für ein Badge!

    Die Software, die vom Projekt produziert wird, MUSS, wenn sie TLS unterstützt, eine Zertifikatsüberprüfung durchführen, bevor HTTP-Header mit privaten Informationen (wie z.B. sichere Cookies) versendet werden. Wenn die Software TLS nicht verwendet, wählen Sie "nicht anwendbar" (N/A). [crypto_verification_private]

    The software strictly enforces full TLS certificate validation before transmitting any HTTP request lines or sensitive headers (such as X-API-Key or Authorization tokens). In ReplicationTlsFactory.java (https://github.com/spectrayan/spector/blob/main/synapse/spector-synapse/src/main/java/com/spectrayan/spector/synapse/replication/ReplicationTlsFactory.java#L132-L140), client TLS sockets explicitly enable endpoint identification (sslParams.setEndpointIdentificationAlgorithm("HTTPS")), mandating full certificate chain and hostname verification during the TLS handshake. Standard underlying HTTP clients (Java HttpClient, Netty SSL, Python requests) ensure that if a certificate check fails, the TLS handshake is aborted immediately and no application-layer HTTP headers or payload bytes are ever sent over the network.


  • Sicheres Release


    Genug für ein Badge!

    Das Projekt MUSS kryptographisch unterschriebene Releases der Projektergebnisse aufzeichnen, die für weit verbreitete Verwendung gedacht sind, und es MUSS ein dokumentierter Prozess sein, der den Benutzern/innen erklärt, wie sie die öffentlichen Signaturschlüssel erhalten und die Signatur(en) überprüfen können. Der private Schlüssel für diese Signatur(en) MUSS NICHT auf der Seite(n) verwendet werden, die öffentlich zugänglich sind. Wenn Releases nicht für eine weit verbreitete Verwendung bestimmt sind, wählen Sie "nicht anwendbar" (N/A). [signed_releases]
    Die Projektergebnisse umfassen sowohl Quellcode als auch alle erzeugten Ergebnisse, falls zutreffend (z. B. ausführbare Dateien, Pakete und Container). Generierte Ergebnisse können separat vom Quellcode signiert werden. Diese DÜRFEN als signierte git-Tags (mit kryptographischen digitalen Signaturen) implementiert werden. Projekte DÜRFEN generierte Ergebnisse getrennt von Werkzeugen wie git behandeln, aber in diesen Fällen MÜSSEN die separaten Ergebnisse separat unterzeichnet werden.

    The project cryptographically signs official release artifacts using GPG via the maven-gpg-plugin in the automated release pipeline in .github/workflows/release-maven.yml (https://github.com/spectrayan/spector/blob/main/.github/workflows/release-maven.yml#L54-L75). Private signing keys are stored securely in encrypted CI secrets and are never located on public distribution sites or servers. Cryptographic signatures (.asc) and SHA-256 checksums are published alongside each release on GitHub Releases (https://github.com/spectrayan/spector/releases) and Maven Central, where users can verify artifact integrity and authenticity against the project's public signing key using gpg --verify <artifact>.asc <artifact>.


    Genug für ein Badge!

    Es wird empfohlen, dass in dem Versionskontrollsystem jeder wichtige Versions-Tag (ein Tag, der Teil eines Hauptrelease, eines kleineren Release, oder eines Fixes, öffentlich gemeldeten Schwachstellen, ist) kryptographisch signiert und verifizierbar ist, wie in Signed_releases. [version_tags_signed]

    The project cryptographically signs release version tags in the Git repository using GPG (git tag -s), verifiable directly on GitHub Releases and Tags (https://github.com/spectrayan/spector/tags) with GitHub's verified signature badge. Tagger public keys are registered with the GitHub organization, and users and automated CI pipelines can verify the cryptographic integrity of any release tag locally using the standard command git tag -v <tag-name> or git verify-tag <tag-name>.


  • Andere Sicherheitsissues


    Genug für ein Badge!

    Die Projektergebnisse MÜSSEN alle Eingaben aus potenziell nicht vertrauenswürdigen Quellen überprüfen, um sicherzustellen, dass sie gültig sind (eine *Allowliste*) und ungültige Eingaben ablehnen, wenn überhaupt Einschränkungen für die Daten vorliegen. [input_validation]
    Beachten Sie, dass der Vergleich der Eingabe mit einer Liste von "schlechten Formaten" (aka einer *Denylist*) normalerweise nicht ausreicht, weil Angreifer oft um eine Denyliste herumarbeiten können. Insbesondere werden Zahlen in interne Formate konvertiert und dann überprüft, ob sie zwischen ihrem Minimum und Maximum (inklusive) liegen und Textstrings werden überprüft, um sicherzustellen, dass sie gültige Textmuster haben (z.B. gültige UTF-8, Länge, Syntax, etc.). Einige Daten müssen möglicherweise "irgendetwas" (z. B. ein Datei-Uploader) sein, aber das ist typischerweise selten der Fall.

    The software validates all inputs from untrusted sources against strict allowlists and rejects non-compliant requests before processing. All Model Context Protocol (MCP) and REST gateway endpoints enforce declarative JSON schema and DTO type allowlists documented in the OpenAPI specification (https://github.com/spectrayan/spector/blob/main/docs/openapi.yaml), rejecting invalid numeric ranges, unexpected types, and malformed structures. Tenant and namespace names are validated against strict alphanumeric allowlists to eliminate path traversal risks. Furthermore, binary on-disk bundles and data imports enforce format version allowlists and CRC32C checksum integrity gates, rejecting unknown or mutated structures immediately (tested in BundleVersionGateTest and documented in SECURITY.md: https://github.com/spectrayan/spector/blob/main/SECURITY.md#security-guarantees--non-guarantees-security-requirements).


    Genug für ein Badge!

    Härtungsmechanismen SOLLTEN in der Software, die das Project entwickelt, verwendet werden, so dass Softwarefehler weniger wahrscheinlich zu Sicherheitslücken führen. [hardening]
    Härtungsmechanismen können HTTP-Header enthalten wie Content Security Policy (CSP), oder Compiler-Flags (z.B. -fstack-protector), um Angriffe zu mildern, oder Compiler-Flags, um undefiniertes Verhalten zu eliminieren. Für unsere Zwecke wird das Prinzip des kleinsten Privilegs nicht als Verhärtungsmechanismus betrachtet (trotzdem ist es wichtig, aber an anderer Stelle).

    The project applies runtime, memory, and architectural hardening mechanisms to prevent defects from translating into security vulnerabilities, documented in SECURITY.md under Security Guarantees & Non-Guarantees (https://github.com/spectrayan/spector/blob/main/SECURITY.md#security-guarantees--non-guarantees-security-requirements) and docs/architecture/overview.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/overview.md). Off-heap native memory accesses are hardened using OpenJDK 25 Project Panama bounded Arena lifecycles that enforce spatial and temporal boundary checks at the JVM level, preventing memory corruption, use-after-free, and buffer overflows. Authentication endpoints enforce constant-time string comparisons to eliminate timing side-channels, binary headers enforce hardware CRC32C integrity checksums and strict format-version gates, and container images run under restricted non-root users with pinned base image digests.


    Genug für ein Badge!

    Das Projekt MUSS einen "Assurance Case" bereithalten, der rechtfertigt, wie die Sicherheitsanforderungen erfüllt werden. Der Assurance Case muss Folgendes beinhalten: eine Beschreibung des Bedrohungsmodells, eine eindeutige Identifizierung von Vertrauensgrenzen, eine Beschreibung wie sichere Designprinzipien angewendet wurden, und eine Beschreibung wie die üblichen Implementierungssicherheitsschwächen beseitige wurden. (URL erforderlich) [assurance_case]
    Ein "Assurance Case" ist ein dokumentierter Beweis, der ein überzeugendes und gültiges Argument enthällt, dass ein bestimmter Satz kritischer Ansprüche bezüglich der Eigenschaften eines Systems für eine gegebene Anwendung in einer gegebenen Umgebung hinreichend erfüllt ist ("Software Assurance Using Structured Assurance Case Models", Thomas Rhodes et al., NIST Interagency Report 7608 ). Vertrauensgrenzen sind Grenzen, in denen Daten oder Ausführung ihr Vertrauensniveau ändern, z.B. die Grenzen eines Servers in einer typischen Webanwendung. Es ist üblich, sichere Designprinzipien (wie Saltzer und Schroeer) und gemeinsame Implementierungssicherheitsschwächen (wie die OWASP Top 10 oder CWE/SANS Top 25) aufzurufen und zu zeigen, wie diesen entgegengewirkt wird. Die BadgeApp Assurance Case kann ein nützliches Beispiel sein. Dies bezieht sich auf documentation_security, documentation_architecture und implement_secure_design.

    The project publishes a formal Security Assurance Case and Threat Model in docs/architecture/security-assurance.md (https://github.com/spectrayan/spector/blob/main/docs/architecture/security-assurance.md), linked from SECURITY.md (https://github.com/spectrayan/spector/blob/main/SECURITY.md). The assurance case explicitly details: (1) a comprehensive threat model defining five adversary profiles (multi-tenant cross-talk, network MitM, cold-disk data exfiltration, query DoS, and binary payload tampering); (2) five clearly delineated trust boundaries (network-to-gateway, agent-to-MCP, tenant-to-tenant, JVM-to-native off-heap, and host storage); (3) architectural proof of secure design principles (defense-in-depth via 6-phase scoring gating, least privilege via namespace jails, fail-closed authentication entry points, and economy of mechanism via a zero-dependency engine kernel); and (4) concrete evidence-based countermeasures against common implementation security weaknesses (CWE-119/416 via Panama FFM bounded arenas, CWE-22 via path normalization and character allowlists, CWE-502 via banned native serialization and CRC32C validation, CWE-78/89 via typed DTO schemas, and CWE-208 via constant-time token comparison).


 Analyse 2/2 ●

  • Statische Codeanalyse


    Genug für ein Badge!

    Das Projekt MUSS mindestens ein statisches Analyse-Tool mit Regeln oder Ansätzen verwenden, um nach bekannten Schwachstellen in der analysierten Sprache oder Umgebung zu suchen, wenn es mindestens ein FLOSS-Tool gibt, das dieses Kriterium in der ausgewählten Sprache implementieren kann. [static_analysis_common_vulnerabilities]
    Statische Analysetools, die speziell dafür entwickelt wurden, nach Schwachstellen zu suchen, finden diese eher. Das heißt, dass die Verwendung von statischen Tools in der Regel helfen wird einige Probleme zu finden. Wir schlagen dies vor, aber erwarten es für das "passing" -Level-Badge nicht.

    CodeQL is configured with the 'security-extended' query suite (.github/workflows/codeql.yml line 58), which incorporates rules covering the OWASP Top 10 and CWE Top 25 vulnerabilities for Java, TypeScript, and Python (including path injection, deserialization flaws, command execution, and cryptographic misconfigurations). https://github.com/spectrayan/spector/blob/main/.github/workflows/codeql.yml#L58


  • Dynamische Codeanalyse


    Genug für ein Badge!

    Wenn die Projektsoftware Software mit einer speicherunsicheren Sprache (z.B. C oder C ++) enthält, MUSS mindestens ein dynamisches Werkzeug (z.B. ein Fuzzer oder ein Web-Applikationsscanner) routinemäßig in Kombination mit einem Mechanismus verwendet werden, welche Speichersicherheitsproblemen wie Puffer-Cach Überschreibe erkennen. Wenn das Projekt keine Software verwendet, die in einer speicherunsicheren Sprache geschrieben ist, wählen Sie "nicht anwendbar" (N/A). [dynamic_analysis_unsafe]
    Beispiele für Mechanismen zur Erkennung von Arbeitsspeicher Sicherheitsproblemen sind Adresse Sanitizer (ASAN) (verfügbar in GCC und LLVM), Memory Sanitizer und valgrind. Andere möglicherweise verwendete Werkzeuge sind Thread Sanitizer und Undefined Behavior Sanitizer. Weit verbreitete Assertions würden auch funktionieren.

    Not applicable. The software produced by the project is written in memory-safe languages (Java 25, TypeScript, and Python) with no compiled C or C++ binaries. Native off-heap memory operations in Java utilize Project Panama's bounded MemorySegment and Arena APIs with built-in spatial/temporal bounds checking, accompanied by dynamic runtime leak detection (PanamaMemoryDetector).



Sie können Tools und KI-Systeme nutzen, um Änderungen über eine einfache URL vorzuschlagen, z. B. https://www.bestpractices.dev/de/projects/14829/choose/edit?osps_ac_01_01_status=Met&osps_ac_01_01_justification=GitHub+enforced. Wie das geht, erfahren Sie in unserem Automatisierungsvorschlagssystem. Diese Daten sind unter der Community Data License Agreement – Permissive, Version 2.0 (CDLA-Permissive-2.0) verfügbar. Dies bedeutet, dass ein Datenempfänger die Daten mit oder ohne Änderungen weitergeben darf, solange der Datenempfänger den Text dieser Vereinbarung mit den weitergegebenen Daten zur Verfügung stellt. Bitte nennen Sie Bharat Joshi und die OpenSSF Best Practices Badge-Mitwirkenden als Urheber.

Projekt-Badge-Eintrag im Besitz von: Bharat Joshi.
Eintrag erstellt: 2026-09-25 00:58:39 UTC, zuletzt aktualisiert: 2026-09-25 03:48:40 UTC. Letztes erreichtes Badge: 2026-09-25 01:54:45 UTC.