![]() |
|---|
| Lokale Desktopanwendung für klassische Kryptografie und standardisierte Post-Quantum-Verfahren |
|---|
| ⬇ Download Post Quantum Security v1.0.0 |
|---|
| ⬇ Download Post Quantum Security v1.0.0 (.exe) | ⬇ Latest Release |
|---|
| Directory | Status | Details |
|---|---|---|
/ |
✅ Ok | Found 4 dependencies |
Note
Deutsch: Post Quantum Security ist eine lokal arbeitende Desktopanwendung mit:
- klassischer Kryptografie
- Post-Quantum-Key-Encapsulation
- digitalen Post-Quantum-Signaturen
- Schlüsselverwaltung
- lokalem Key Vault
- eigenem QSEC-Containerformat
- einem gemeinsamen lokalen Sicherheitsworkflow
Note
English: Post Quantum Security is a local desktop application with:
- classical cryptography
- post-quantum key encapsulation
- digital post-quantum signatures
- key management
- a local key vault
- a project-specific QSEC container format
- one unified local security workflow
- Projektübersicht
- Funktionsumfang
- Kryptografische Architektur
- Mathematische Grundlage
- Eigene Entwicklungsleistung
- Dateiformate
- Lokale Datenbank und Key Vault
- Projektstruktur
- Voraussetzungen
- Installation
- Anwendung starten
- Grundlegende Bedienung
- Sicherheit
- Sicherheitskritische Schwachstellen
- Entwicklungsstatus
- Lizenz
- Autor
- Project Overview
- Feature Set
- Cryptographic Architecture
- Mathematical Foundation
- Original Development Work
- File Formats
- Local Database and Key Vault
- Project Structure
- Requirements
- Installation
- Starting the Application
- Basic Usage
- Security
- Security-Critical Vulnerabilities
- Development Status
- License
- Author
Post Quantum Security ist eine Python-Desktopanwendung mit PySide6-Oberfläche für lokale kryptografische Workflows.
Ziel des Projekts ist die sinnvolle Verbindung etablierter klassischer Kryptografie mit standardisierten Post-Quantum-Verfahren innerhalb einer eigenständig entwickelten Anwendungs- und Sicherheitsarchitektur.
Die Anwendung verarbeitet Texte, Dateien, kryptografische Schlüssel und digitale Signaturen lokal auf dem eigenen System. Für die grundlegenden Sicherheitsfunktionen ist kein externer Verschlüsselungs- oder Cloud-Dienst erforderlich.
| Bereich | Umsetzung |
|---|---|
| Benutzeroberfläche | PySide6 |
| Sprachen | Deutsch / Englisch |
| Datenverschlüsselung | AES-256-GCM |
| Passwortbasierte Schlüsselableitung | Argon2id |
| Schlüsselableitung | HKDF-SHA-256 |
| Post-Quantum KEM | ML-KEM-768 |
| Post-Quantum Signaturen | ML-DSA-65 |
| Lokale Datenbank | SQLite |
| Containerformat | QSEC |
| Verarbeitung | Lokal / Local First |
| Entwicklungsstand | Aktueller Funktionsumfang abgeschlossen |
Important
Die in der Anwendung eingesetzten kryptografischen Algorithmen sind keine von BYLICKILABS neu erfundenen Kryptografie-Verfahren. AES-256-GCM, Argon2id, HKDF-SHA-256, ML-KEM-768 und ML-DSA-65 sind etablierte beziehungsweise standardisierte Verfahren.
Die eigene Entwicklungsleistung liegt in der Architektur, Integration, Benutzeroberfläche, Schlüsselverwaltung, Datenbankanbindung, dem QSEC-Workflow sowie der Verbindung der einzelnen Komponenten zu einer vollständigen Anwendung.
- lokale Verschlüsselung und Entschlüsselung von Text
- Passwortmodus
- Post-Quantum-Modus
- Ausgabe direkt innerhalb der Anwendung
- Kopieren des Ergebnisses in die Zwischenablage
- Verschlüsselung beliebiger Dateien
- Entschlüsselung von QSEC-Dateien
- Passwortmodus
- Post-Quantum-Modus
- Auswahl von öffentlichen und privaten Schlüsseln
- Drag-and-Drop-Unterstützung für Eingabedateien
- Erzeugung von ML-KEM-Schlüsselpaaren
- Erzeugung von ML-DSA-Signaturschlüsselpaaren
- passwortgeschützte Speicherung privater Schlüssel
- Fingerprint-Erzeugung
- Speicherung erzeugter Schlüssel im lokalen Key Vault
- Laden gespeicherter Schlüssel
- Export von Schlüsselpaaren
- Löschen von Datenbankeinträgen
- Signieren von Dateien mit ML-DSA-65
- Verifikation bestehender Signaturen
- getrennte öffentliche und private Signaturschlüssel
- eigenes
.qsig-Signaturformat
- vollständig bilinguale Oberfläche in Deutsch und Englisch
- direkter Sprachwechsel innerhalb der Anwendung
- Statusmeldungen und Dialoge
- integrierte Datenbankübersicht
- integrierter Info-Dialog
- direkter GitHub-Zugriff aus der Anwendung
Die Anwendung verwendet mehrere kryptografische Komponenten mit klar getrennten Aufgaben.
| Verfahren | Aufgabe innerhalb der Anwendung |
|---|---|
| AES-256-GCM | Authentifizierte symmetrische Verschlüsselung der Nutzdaten |
| Argon2id | Passwortbasierte Ableitung kryptografischen Schlüsselmaterials |
| HKDF-SHA-256 | Ableitung von Schlüsseln aus kryptografischen Geheimnissen |
| ML-KEM-768 | Post-Quantum Key Encapsulation für gemeinsame kryptografische Geheimnisse |
| ML-DSA-65 | Digitale Post-Quantum-Signaturen und Signaturprüfung |
Passwort
│
▼
Argon2id
│
▼
AES-256-GCM Key
│
▼
Verschlüsselung / Entschlüsselung
│
▼
QSEC Container
ML-KEM-768 Public Key
│
▼
Key Encapsulation
│
▼
Shared Secret
│
▼
HKDF-SHA-256
│
▼
AES-256-GCM Key
│
▼
Verschlüsselung / Entschlüsselung
│
▼
QSEC Container
Datei
│
▼
ML-DSA-65 Private Key
│
▼
Digitale Signatur
│
▼
.qsig
│
▼
ML-DSA-65 Public Key
│
▼
Verifikation
Die eingesetzten Post-Quantum-Verfahren basieren auf gitterbasierter Kryptografie.
Zu den mathematischen Grundlagen gehören unter anderem:
- modulare Arithmetik
- Polynomringe
- Matrix- und Vektoroperationen
- Module-LWE-bezogene Strukturen
- Module-SIS-bezogene Strukturen
- gitterbasierte kryptografische Problemklassen
ML-KEM-768 und ML-DSA-65 nutzen diese mathematischen Strukturen für unterschiedliche Aufgaben: ML-KEM für die sichere Kapselung gemeinsamer Geheimnisse und ML-DSA für digitale Signaturen.
Note
Die Anwendung implementiert nicht eigene mathematische Post-Quantum-Algorithmen, sondern integriert standardisierte Verfahren in einen eigenständig entwickelten lokalen Sicherheitsworkflow.
Die Entwicklungsarbeit dieses Projekts liegt insbesondere in der technischen Konzeption und vollständigen Umsetzung der Anwendung.
Dazu gehören:
- Entwicklung der Desktopanwendung und PySide6-Benutzeroberfläche
- Konzeption der Anwendungs- und Sicherheitsarchitektur
- Integration klassischer und quantenresistenter Kryptografie
- Verbindung von AES-256-GCM, Argon2id, HKDF-SHA-256, ML-KEM-768 und ML-DSA-65
- Entwicklung des QSEC-Containerworkflows
- Definition der projektspezifischen Schlüssel-, Signatur- und Containerdateien
- Entwicklung der lokalen Schlüsselverwaltung
- Integration eines SQLite-basierten Key Vaults
- Fingerprint-Verwaltung
- Schlüsselimport und Schlüsselexport
- Verschlüsselungs- und Entschlüsselungsworkflows
- Signatur- und Verifikationsworkflows
- bilinguale Benutzeroberfläche
- lokale Status-, Fehler- und Informationslogik
Die Anwendung basiert damit auf etablierten kryptografischen Standards, während deren konkrete Integration, Strukturierung und technische Umsetzung Bestandteil der eigenen Softwareentwicklung ist.
| Endung | Verwendung |
|---|---|
.qpub |
Öffentlicher ML-KEM-Schlüssel |
.qkey |
Passwortgeschützter privater ML-KEM-Schlüssel |
.qsigpub |
Öffentlicher ML-DSA-Signaturschlüssel |
.qsigkey |
Passwortgeschützter privater ML-DSA-Signaturschlüssel |
.qsig |
Digitale Signatur |
.qsec |
Verschlüsselter QSEC-Container |
Das QSEC-Containerformat dient der Speicherung verschlüsselter Dateiinhalte innerhalb des Anwendungsworkflows.
Abhängig vom gewählten Modus kann der zugrunde liegende kryptografische Schlüssel:
- passwortbasiert abgeleitet oder
- über einen ML-KEM-basierten Post-Quantum-Workflow erzeugt werden.
Die Anwendung erzeugt automatisch eine lokale SQLite-Datenbank.
Sie verwaltet unter anderem:
- Schlüssel-ID
- Schlüsselname
- Schlüsseltyp
- verwendeten Algorithmus
- Fingerprint
- Zeitstempel
- Schlüsselreferenzen
- Anwendungseinstellungen
- ausgewählte Sprache
Die Datenbank ist direkt in die Benutzeroberfläche eingebunden. Gespeicherte Schlüssel können angezeigt, geladen, materialisiert, exportiert und aus der Datenbank entfernt werden.
Note
Verwendete Passwörter werden nicht als Klartext in der lokalen Datenbank gespeichert.
Kernstruktur der Anwendung:
Post-Quantum-Security/
│
├── app/
│ ├── constants.py
│ ├── database.py
│ └── i18n.py
│
├── crypto/
│ ├── container.py
│ ├── keys.py
│ ├── pq.py
│ └── signatures.py
│
├── gui/
│ └── main_window.py
│
├── main.py
├── requirements.txt
├── LICENSE
└── README.md
| Bereich | Aufgabe |
|---|---|
app/ |
Anwendungskonstanten, Internationalisierung und Datenbank |
crypto/ |
Container, Schlüssel, Post-Quantum-Verfahren und Signaturen |
gui/ |
PySide6-Benutzeroberfläche |
main.py |
Einstiegspunkt der Anwendung |
Für die Ausführung werden benötigt:
- Python 3
- PySide6
cryptographyargon2-cffi- Open Quantum Safe /
liboqs - Python-Bindings für
oqs - SQLite-Unterstützung der Python-Standardbibliothek
Important
Die Post-Quantum-Funktionen setzen eine funktionsfähige
Open-Quantum-Safe-/liboqs-Umgebung voraus.
Unter Windows können für die lokale Erstellung beziehungsweise
Kompilierung von liboqs zusätzlich die
Microsoft Visual Studio Build Tools erforderlich sein.
Benötigte Komponenten:
- Visual Studio Build Tools (
vs_BuildTools.exe) - Workload Desktop development with C++
- MSVC C++ Toolchain
- Windows SDK
- CMake
Die Build Tools werden insbesondere benötigt, wenn liboqs
auf dem Windows-System selbst kompiliert werden muss.
Repository klonen:
git clone https://github.com/bylickilabs/Post-Quantum-Security.git
cd Post-Quantum-SecurityVirtuelle Umgebung erstellen:
python -m venv .venvUnter Windows aktivieren:
.venv\Scripts\Activate.ps1pip aktualisieren und Abhängigkeiten installieren:
python -m pip install --upgrade pip
pip install -r requirements.txtDie Anwendung wird aus dem Hauptverzeichnis des Projekts gestartet:
python main.pyImportant
gui/main_window.py sollte nicht direkt gestartet werden.
Der vorgesehene Einstiegspunkt ist main.py, damit die Projektmodule app und crypto korrekt über den Projekt-Root aufgelöst werden.
- Registerkarte Text öffnen.
- Passwort- oder Post-Quantum-Modus auswählen.
- Text eingeben beziehungsweise verschlüsselten Text einfügen.
- Passwort oder passenden Schlüssel angeben.
- Verschlüsselung oder Entschlüsselung ausführen.
- Datei auswählen oder per Drag-and-Drop übernehmen.
- Zieldatei festlegen.
- Passwort- oder Post-Quantum-Modus auswählen.
- Passwort beziehungsweise Schlüssel angeben.
- Verschlüsselung oder Entschlüsselung ausführen.
- Registerkarte Schlüssel öffnen.
- Zielordner und Namen festlegen.
- Passwort für den privaten Schlüssel vergeben.
- ML-KEM- oder ML-DSA-Schlüsselpaar erzeugen.
- Datei auswählen.
- privaten ML-DSA-Schlüssel und Passwort angeben.
- Signatur erzeugen.
- Zur Prüfung Originaldatei,
.qsigund öffentlichen ML-DSA-Schlüssel auswählen. - Verifikation starten.
Die Anwendung verfolgt einen Local-First-Ansatz.
- grundlegende kryptografische Verarbeitung erfolgt lokal
- keine externe Verschlüsselungs-API erforderlich
- private Schlüssel werden passwortgeschützt gespeichert
- Passwörter werden nicht als Klartext in der SQLite-Datenbank gespeichert
- AES-256-GCM wird für authentifizierte Datenverschlüsselung eingesetzt
- ML-KEM-768 wird für Post-Quantum-Key-Encapsulation verwendet
- ML-DSA-65 wird für digitale Post-Quantum-Signaturen verwendet
Warning
Kryptografische Software sollte vor einem produktiven oder sicherheitskritischen Einsatz umfassend geprüft und unabhängig auditiert werden. Dieses Projekt stellt keine formale Sicherheitszertifizierung und keinen unabhängigen Security Audit dar.
Caution
Der Verlust von Passwörtern oder privaten Schlüsseln kann dazu führen, dass verschlüsselte Daten nicht mehr wiederhergestellt werden können. Schlüsselmaterial sollte sicher gesichert werden.
Sicherheitskritische Schwachstellen sollten nicht über einen öffentlichen GitHub-Issue veröffentlicht werden.
Bitte sende entsprechende Hinweise direkt an:
E-Mail: bylicki@mail.de
Bitte gib – soweit möglich – folgende Informationen an:
- betroffene Komponente
- reproduzierbare Schritte
- technische Beschreibung
- mögliche Auswirkungen
- verwendete Version beziehungsweise Commit
- relevante Logausgaben ohne vertrauliche Schlüssel oder Passwörter
Important
Private Schlüssel, Passwörter, geheime Schlüssel oder andere vertrauliche Informationen dürfen nicht mit einem Schwachstellenbericht versendet werden.
Der für die aktuelle Projektphase vorgesehene Funktionsumfang ist abgeschlossen.
| Funktion | Status |
|---|---|
| Textverschlüsselung / Entschlüsselung | ✅ Abgeschlossen |
| Dateiverschlüsselung / Entschlüsselung | ✅ Abgeschlossen |
| Passwortmodus | ✅ Abgeschlossen |
| ML-KEM-768 Integration | ✅ Abgeschlossen |
| ML-DSA-65 Integration | ✅ Abgeschlossen |
| Schlüsselgenerierung und -verwaltung | ✅ Abgeschlossen |
| SQLite Key Vault | ✅ Abgeschlossen |
| QSEC-Container | ✅ Abgeschlossen |
| Digitale Signaturen / Verifikation | ✅ Abgeschlossen |
| Deutsch / Englisch | ✅ Abgeschlossen |
Weiterführende Optimierungen, Tests und zukünftige Erweiterungen können auf der bestehenden Architektur aufbauen.
Die Lizenzbedingungen dieses Projekts befinden sich in:
Die Nutzung, Veränderung und Weitergabe des Projekts richtet sich nach den dort festgelegten Bedingungen.
Thorsten Bylicki
BYLICKILABS
Post Quantum Security is a Python desktop application developed by BYLICKILABS with a PySide6 user interface for local cryptographic workflows.
The project combines established classical cryptography with standardized post-quantum mechanisms within an independently developed application and security architecture.
The application processes text, files, cryptographic keys and digital signatures locally on the user's system. No external encryption or cloud service is required for the core security functions.
| Area | Implementation |
|---|---|
| User interface | PySide6 |
| Languages | German / English |
| Data encryption | AES-256-GCM |
| Password-based key derivation | Argon2id |
| Key derivation | HKDF-SHA-256 |
| Post-Quantum KEM | ML-KEM-768 |
| Post-Quantum signatures | ML-DSA-65 |
| Local database | SQLite |
| Container format | QSEC |
| Processing | Local / Local First |
| Development status | Current feature set completed |
Important
The cryptographic algorithms used by the application are not newly invented cryptographic algorithms developed by BYLICKILABS. AES-256-GCM, Argon2id, HKDF-SHA-256, ML-KEM-768 and ML-DSA-65 are established or standardized mechanisms.
The original development work lies in the architecture, integration, user interface, key management, database integration, QSEC workflow and the combination of these components into a complete application.
- local text encryption and decryption
- password mode
- post-quantum mode
- result output directly inside the application
- clipboard copy function
- encryption of arbitrary files
- decryption of QSEC files
- password mode
- post-quantum mode
- public and private key selection
- drag-and-drop support for input files
- generation of ML-KEM key pairs
- generation of ML-DSA signature key pairs
- password-protected storage of private keys
- fingerprint generation
- storage of generated keys in the local key vault
- loading stored keys
- exporting key pairs
- deleting database entries
- signing files with ML-DSA-65
- verification of existing signatures
- separate public and private signature keys
- project-specific
.qsigsignature format
- fully bilingual German and English interface
- direct language switching inside the application
- status messages and dialogs
- integrated database overview
- integrated information dialog
- direct GitHub access from the application
The application uses several cryptographic components with clearly separated responsibilities.
| Mechanism | Purpose within the application |
|---|---|
| AES-256-GCM | Authenticated symmetric encryption of payload data |
| Argon2id | Password-based derivation of cryptographic key material |
| HKDF-SHA-256 | Derivation of keys from cryptographic secrets |
| ML-KEM-768 | Post-quantum key encapsulation for shared cryptographic secrets |
| ML-DSA-65 | Digital post-quantum signatures and signature verification |
Password
│
▼
Argon2id
│
▼
AES-256-GCM Key
│
▼
Encryption / Decryption
│
▼
QSEC Container
ML-KEM-768 Public Key
│
▼
Key Encapsulation
│
▼
Shared Secret
│
▼
HKDF-SHA-256
│
▼
AES-256-GCM Key
│
▼
Encryption / Decryption
│
▼
QSEC Container
File
│
▼
ML-DSA-65 Private Key
│
▼
Digital Signature
│
▼
.qsig
│
▼
ML-DSA-65 Public Key
│
▼
Verification
The post-quantum mechanisms used by the application are based on lattice-based cryptography.
Their mathematical foundations include:
- modular arithmetic
- polynomial rings
- matrix and vector operations
- Module-LWE-related structures
- Module-SIS-related structures
- lattice-based cryptographic problem classes
ML-KEM-768 and ML-DSA-65 use these structures for different purposes: ML-KEM for secure encapsulation of shared secrets and ML-DSA for digital signatures.
Note
The application does not implement newly invented mathematical post-quantum algorithms. It integrates standardized mechanisms into an independently developed local security workflow.
The original development work of this project lies primarily in the technical design and complete implementation of the application.
This includes:
- development of the desktop application and PySide6 user interface
- design of the application and security architecture
- integration of classical and post-quantum cryptography
- combination of AES-256-GCM, Argon2id, HKDF-SHA-256, ML-KEM-768 and ML-DSA-65
- development of the QSEC container workflow
- definition of project-specific key, signature and container files
- development of local key management
- integration of a SQLite-based key vault
- fingerprint management
- key import and export
- encryption and decryption workflows
- signing and verification workflows
- bilingual user interface
- local status, error and information handling
The application therefore relies on established cryptographic standards, while their concrete integration, structure and technical implementation are part of the original software development.
| Extension | Purpose |
|---|---|
.qpub |
Public ML-KEM key |
.qkey |
Password-protected private ML-KEM key |
.qsigpub |
Public ML-DSA signature key |
.qsigkey |
Password-protected private ML-DSA signature key |
.qsig |
Digital signature |
.qsec |
Encrypted QSEC container |
The QSEC container format stores encrypted file content within the application workflow.
Depending on the selected mode, the underlying cryptographic key can be:
- derived from a password, or
- generated through an ML-KEM-based post-quantum workflow.
The application automatically creates a local SQLite database.
It manages information including:
- key ID
- key name
- key type
- algorithm
- fingerprint
- timestamp
- key references
- application settings
- selected language
The database is integrated directly into the user interface. Stored keys can be displayed, loaded, materialized, exported and removed from the database.
Note
Passwords are not stored in plaintext inside the local database.
Core application structure:
Post-Quantum-Security/
│
├── app/
│ ├── constants.py
│ ├── database.py
│ └── i18n.py
│
├── crypto/
│ ├── container.py
│ ├── keys.py
│ ├── pq.py
│ └── signatures.py
│
├── gui/
│ └── main_window.py
│
├── main.py
├── requirements.txt
├── LICENSE
└── README.md
| Area | Responsibility |
|---|---|
app/ |
Application constants, internationalization and database |
crypto/ |
Container, keys, post-quantum mechanisms and signatures |
gui/ |
PySide6 user interface |
main.py |
Application entry point |
The following components are required to run the application:
- Python 3
- PySide6
cryptographyargon2-cffi- Open Quantum Safe /
liboqs - Python bindings for
oqs - SQLite support provided by the Python standard library
Important
The post-quantum functions require a working
Open Quantum Safe / liboqs environment.
On Windows, the
Microsoft Visual Studio Build Tools
may additionally be required to build or compile liboqs locally.
Required components:
- Visual Studio Build Tools (
vs_BuildTools.exe) - Desktop development with C++ workload
- MSVC C++ Toolchain
- Windows SDK
- CMake
The Build Tools are particularly required when liboqs
needs to be compiled locally on the Windows system.
Clone the repository:
git clone https://github.com/bylickilabs/Post-Quantum-Security.git
cd Post-Quantum-SecurityCreate a virtual environment:
python -m venv .venvActivate it on Windows:
.venv\Scripts\Activate.ps1Upgrade pip and install dependencies:
python -m pip install --upgrade pip
pip install -r requirements.txtStart the application from the project root:
python main.pyImportant
Do not start gui/main_window.py directly.
The intended entry point is main.py, ensuring that the app and crypto project modules are resolved correctly from the project root.
- Open the Text tab.
- Select password or post-quantum mode.
- Enter text or paste encrypted text.
- Provide the password or appropriate key.
- Run encryption or decryption.
- Select a file or use drag and drop.
- Define the output file.
- Select password or post-quantum mode.
- Provide the password or key.
- Run encryption or decryption.
- Open the Keys tab.
- Select the destination folder and key name.
- Set a password for the private key.
- Generate an ML-KEM or ML-DSA key pair.
- Select a file.
- Provide the private ML-DSA key and password.
- Generate the signature.
- For verification, select the original file,
.qsigfile and public ML-DSA key. - Start verification.
The application follows a local-first approach.
- core cryptographic processing is performed locally
- no external encryption API is required
- private keys are stored in password-protected form
- passwords are not stored in plaintext inside the SQLite database
- AES-256-GCM is used for authenticated data encryption
- ML-KEM-768 is used for post-quantum key encapsulation
- ML-DSA-65 is used for digital post-quantum signatures
Warning
Cryptographic software should be thoroughly reviewed and independently audited before production or security-critical use. This project does not represent a formal security certification or an independent security audit.
Caution
Losing passwords or private keys may make encrypted data unrecoverable. Cryptographic key material should be backed up securely.
Security-critical vulnerabilities should not be disclosed through a public GitHub issue.
Please report them directly to:
E-mail: bylicki@mail.de
Where possible, include:
- affected component
- reproducible steps
- technical description
- potential impact
- affected version or commit
- relevant log output without confidential keys or passwords
Important
Never send private keys, passwords, secret keys or other confidential data with a vulnerability report.
The feature set planned for the current project phase has been completed.
| Feature | Status |
|---|---|
| Text encryption / decryption | ✅ Completed |
| File encryption / decryption | ✅ Completed |
| Password mode | ✅ Completed |
| ML-KEM-768 integration | ✅ Completed |
| ML-DSA-65 integration | ✅ Completed |
| Key generation and management | ✅ Completed |
| SQLite key vault | ✅ Completed |
| QSEC container | ✅ Completed |
| Digital signatures / verification | ✅ Completed |
| German / English | ✅ Completed |
Further optimization, testing and future extensions can build on the existing architecture.
The license terms for this project are available in:
Use, modification and redistribution of this project are governed by the terms defined there.
Thorsten Bylicki
BYLICKILABS
