> Falls Sie ohne Verwendung von `--recurse-submodules` geklont haben, können die Submodule durch Ausführen von `git submodule update --init` aus dem Quellordner aktualisiert werden.

Hier ist eine Liste der Abhängigkeiten, die Sie zum Kompilieren des Projekts benötigen (bitte lesen Sie weiter unten für weitere Details zur Installation):```bash
sudo apt install pkg-config ca-certificates file build-essential cmake ninja-build libusb-1.0-0-dev libcurl4-openssl-dev \
	libcrypto++-dev libcap-dev uuid-dev libssl-dev libsqlite3-dev libprotobuf-dev libgrpc++-dev \
	libssl-dev protobuf-compiler protobuf-compiler-grpc checkinstall
mkdir build-cqptoolkit
cd build-cqptoolkit
cmake -G Ninja ../cqptoolkit && ninja

EINGABE:```bash
./src/Tools/SiteAgentRunner/SiteAgentRunner -p 8001 &
./src/Drivers/DummyQKDDriver/DummyQKDDriver -r localhost:8001 -b

was standardmäßig etwas Ähnliches erzeugen sollte, wenn *SiteAgentRunner* und *DummyQKDDriver* ohne Angabe eines Konfigurations-JSON-String-Dateiarguments gestartet wurden:```json
{
 "url": "<hostname>:8000",
 "devices": [
  {
   "config": {
    "id": "dummyqkd__0__16_alice",
    "kind": "dummyqkd"
   },
   "controlAddress": "<hostname>:34219"
  }
 ]
}

- Nun, die Verbindung kann nun durch Aufrufen von: hergestellt werden:```bash
./src/Tools/SiteAgentCtl/SiteAgentCtl -c localhost:8000 -j localhost:8001

Der Link kann mit dem unjoin-Befehl gestoppt werden:```bash
./src/Tools/SiteAgentCtl/SiteAgentCtl -c localhost:8000 -u localhost:8001

Starten Sie nun die Alice-Seite des VPN und definieren Sie den zu erstellenden Tunnel. Es werden zwei Ports geöffnet, einer für jede Seite auf 9000 und 9001; alles, was diese Ports erreicht, wird verschlüsselt, auf die andere Seite übertragen, entschlüsselt und auf dem anderen Port ausgegeben.```
./src/Tools/QTunnelServer/QTunnelServer --keystore-url=`hostname`:8000 --remote=localhost:9010 --start-node=tcpsrv://0.0.0.0:9000 --end-node=tcpsrv://0.0.0.0:9001

und eine auf der anderen:```
nc localhost 9001

### Ubuntu 18.04+

Sie können Binärpakete von [Gitlab](https://gitlab.com/QComms/cqptoolkit/-/jobs/artifacts/master/download?job=package%3Adeb) installieren. Entpacken Sie die Zip-Datei und installieren Sie die Tools mit `dpkg`. Es wird sich über fehlende Abhängigkeiten beschweren, aber keine Sorge, die zweite Zeile wird sie beheben.```bash
sudo dpkg -i setup/*.deb build/gcc/CQP-*-Linux-{Algorithms,Networking,CQPToolkit,KeyManagement,QKDInterfaces,CQPUI,Simulate,Tools,UI,Drivers,IDQDevices}.deb
sudo apt install -fy

Ansonsten erfordert das Erstellen aus dem Quellcode, dass Sie die Abhängigkeiten installieren, die in der `setup/setupbuild.sh` aufgelistet sind, derzeit funktioniert es für Ubuntu und Arch Linux.

Klonen Sie die Quelle von [gitlab](https://gitlab.com/QComms/cqptoolkit.git) mit [git][] und erstellen Sie mit [CMake][] und [gnu make](https://www.gnu.org/software/make/):
Die Option `--recurse-submodules` fügt die optionalen Extras hinzu - der Zugriff auf einige davon ist auf die UoB und ihre Partner beschränkt, der Build funktioniert auch ohne sie.```bash
git clone --recurse-submodules https://gitlab.com/QComms/cqptoolkit.git

Nun können Sie in Ihr lokales Repository gehen und die Abhängigkeiten mit dem Skript installieren (möglicherweise müssen Sie die Dateiberechtigungen ändern):```bash
cd cqptoolkit/setup
./setupbuild.sh

Der Build verwendet [CMake][], um Makefiles/Lösungen/etc. für viele verschiedene Plattformen zu erstellen, und wird aus einem leeren Build-Ordner aufgerufen, der alle Ausgabedateien enthält. Debug-Builds erstellen Pakete mit dem Suffix "D".
Der Build kann durch Übergabe von Optionen an cmake gesteuert werden, z.B. `-DBUILD_TESTING=OFF`. Führen Sie cmake mit der Option `-LH` aus, um verfügbare Schalter aufzulisten.

Um Änderungen vorzunehmen und die Bibliothek zu entwickeln, wird empfohlen, [QT Creator](http://doc.qt.io/qtcreator/) zu installieren und das Projekt durch [Auswahl der CMakeLists.txt-Datei](https://codeyarns.com/2016/01/26/how-to-import-cmake-project-in-qt-creator/) zu öffnen. Es ist ratsam, parallele Builds zu verwenden, indem Sie zu Projekte -> Build-Schritte -> Details gehen und `-j<Anzahl>` zu den Werkzeugparametern hinzufügen, siehe [so](https://stackoverflow.com/questions/8860712/setting-default-make-options-for-qt-creator).
Nach dem Build befinden sich die Dateien standardmäßig auf derselben Ebene wie der Projektordner mit dem Namen `build-<Projektname>-<Plattform>-<Ziel>`.

> **Hinweis zu protobuf + QT unter Ubuntu**
> Die Bibliothek `qt5-gtk-platformtheme` ist mit einer alten Version von protobuf verknüpft, was die Ausführung unserer QT-Programme verhindert.
> Diese optionale Abhängigkeit kann mit `apt-get remove qt5-gtk-platformtheme` entfernt werden.

## Die Bibliothek erkunden

    @startuml
        title Applicaiton Overview

        component "QKD Device Drivers" as drv
        interface IDevice as idev
        drv - idev

        component "Device contol and\n Key storage" as sa
        interface IKey as ikey
        sa - ikey
        sa ..> idev

    package "Key consumers" as kc {
        component "Custom VPN" as tun
        component "Custom\nWeb Server" as nginx
        component "HSM bridge" as hsm
    }
    tun ..> ikey
    nginx ..> ikey
    hsm ..> ikey

    package Utilities {
        component "Config/Control GUI" as gui
        component "Simulators/Testing" as sim
        component "Data extraction" as stats

        gui -[hidden]down- sim
        sim -[hidden]down- stats
    }
    @enduml

Nachfolgend ein Flussdiagramm, das Ihnen hilft, den für Sie relevanten Bereich zu finden, da das Projekt viele verschiedene Aspekte von QKD und Schlüsselverwaltung abdeckt – Mitwirkende sind willkommen, dieses Projekt spezialisierter zu gestalten.
QKD erfordert eine Form von [No-Cloning](https://en.wikipedia.org/wiki/No-cloning_theorem)-Kommunikation, meist unter Verwendung einzelner Photonen über eine Glasfaserverbindung. Sie können Punkt-zu-Punkt oder Eins-zu-Viele betrieben werden, haben aber inhärent einen physikalischen Standort (wo die Faser endet) – sie können nicht virtualisiert werden! Der Punkt, an dem das Photon gesendet oder erkannt wird, ist die Grenze des sicheren Systems – fast wie die [Firewall](https://en.wikipedia.org/wiki/Firewall_(computing)) eines Netzwerks. Sobald die unteilbaren Photonen in eine Bitfolge umgewandelt wurden, um einen [symmetrischen Schlüssel](https://en.wikipedia.org/wiki/Key_(cryptography)) zu bilden, gelten die Standardregeln der Computersicherheit wie Authentifizierung, Zugriffskontrolle usw. Der Unterschied besteht darin, dass nach der Erzeugung dieser Schlüssel jedes der QKD-Geräte eine Zahl besitzt, die [niemand sonst kennt](https://en.wikipedia.org/wiki/Shared_secret) und die [wissenschaftlich nachgewiesen ist](https://arxiv.org/pdf/quant-ph/0003004.pdf).

Die Art dieses "Firewall"-Effekts besteht darin, dass die Systeme, die die QKD-Geräte steuern, sicher und als vertrauenswürdig (auch "Trusted Node" genannt) angesehen werden müssen – wo und wie Sie die Grenze ziehen, reicht von bewaffneten Wachen bis hin zum [Abschließen der Serverraumtür](https://www.youtube.com/watch?v=rnmcRTnTNC8).

Wenn Sie das Diagramm unten nicht sehen können, gehen Sie bitte zur [Online-Dokumentation](https://qcomms.gitlab.io/cqptoolkit/), sie kann auch über das `doc`-Ziel erstellt werden.

    @startuml
    title Where to start \n

    skinparam activity {
      StartColor #EF476F
      BarColor #FFD166
      EndColor #EF476F
      BackgroundColor #06D6A0
      BorderColor #118AB2
    }

    start
    if (Do you have a QKD Device?) then (Yes)
        if (Does your QKD device have a driver?) then (No)
            :You will need to [[./index.html#CreatingDrivers create a driver]] which implements the
            <b>IDriver</b> and <b>IReporting</b> interfaces.;
            if (Use the library?) then (Yes)
                :See the [[./index.html#RunningDummyQKDDriver DummyQKDDriver]] for an example.;
            else (No)
            endif
        else (Yes)
        endif
    else (No)
        :Check out how to run the
        [[./index.html#RunningDummyQKDDriver DummyQKDDriver]];
    endif

    if (Do you want keys for multiple
    locations in a network?) then (Yes: Sites)
        :[[./index.html#Registering Register your driver]] with the site agent
        using the <b>ISiteAgent</b> Interface
        Keys can be obtained by using the [[./index.html#IKeyInterface IKey]] interface;

        if(Do you want keys to be stored/persist between restarts?) then (Yes)
            if (Do the keys need to be secured?) then (Yes)
                :Use the [[./index.html#HSMs HSM storage]] options;
                if (Is your HSM supported?) then (No)
                    :Create a driver that implements
                    the <b>IBackingStore</b> interface.
                    Add the driver creation to the
                    <b>BackingStoreFactory</b>;
                else (Yes)
                endif
            else (No)
                : When running SiteAgentRunner,
                use the option ""-b file"" or
                set ""backingStoreUrl"" to
                ""file:///filename.db"";
            endif
        else (No)
        endif
    else (No: Point-to-Point)
        :Use the [[./index.html#IDeviceInterface IDevice interface]] to
        control the driver for your system.
        As keys become available they will
        be sent via the call to <b>WaitForSession</b>.;
    endif

    if (Do you want to use the key for anything?) then (Yes)
        :See the [[./index.html#Encryption encryption section]]
        for an example of using the [[./index.html#IKeyInterface IKey interface]];
    else (No)
    endif
    stop

    @enduml


### DummyQKDDriver ausführen <a name="RunningDummyQKDDriver" />

Dieser Abschnitt ist lediglich ein Kommentar zur nützlichen Funktionalität von DummyQKDDriver zur Simulation der Ausgabe eines QKD-Geräts. Bitte lesen Sie den nächsten Abschnitt für ein geführtes Beispiel zur Einrichtung einer einfachen Verbindung mit ihnen.
Wie bei den meisten Programmen zeigt die Übergabe von `-h` die verfügbaren Optionen an. Der DummyQKDDriver führt eine standardmäßige Reihe von Nachbearbeitungsschritten an simulierten Photonendetektionen unter Verwendung der Klasse cqp::DummyQKD durch. Es müssen zwei Instanzen des Programms ausgeführt werden, eine für Alice und eine für Bob.

Starten Sie Bob zuerst auf Port 8000 durch Aufruf von:```bash
DummyQKDDriver -b -k 0.0.0.0:8000

Wenn es funktioniert hat, erhalten Sie eine Flut von Fehlermeldungen wie diese: `ERROR: OnKeyGeneration No listener for generated key`. Der Grund ist, dass es zwar schön ist zu sehen, dass das System etwas tut, wenn man es so betreibt, aber es ist nicht sehr nützlich, da es keinen Ort gibt, an dem der generierte Schlüssel abgelegt werden kann. Die Treiber sind dafür ausgelegt, von etwas verwendet zu werden.
Das Projekt verfügt über ein System zur Verwaltung der Schlüssel namens [Site Agents](#SiteAgents) oder Sie können direkt mit den Treibern über die [IDevice-Schnittstelle](#IDeviceInterface) kommunizieren.

### Konfigurieren der Site Agents <a name="SiteAgents" />

Site agents, Treiber und VPN-Tunnel müssen für jeden Knoten des Netzwerks mit JSON-String-Dateien parametrisiert werden, da der Standardbefehl ohne Argumente standardmäßig nicht alle erforderlichen Felder angibt und nur für Tests auf demselben lokalen Rechner funktioniert.

Site agents können mit dem SiteAgentRunner ausgeführt werden, wir können zwei Sites mit:```bash
SiteAgentRunner -c site-a.json

wobei jede JSON-Datei entsprechend einen anderen Port für Alice und Bob angibt (z.B. 9000/9001). Die JSON-Zeichenfolge sieht so aus:```json
		{
		    "name":"",
		    "id":"",
		    "netManUri":"",
		    "bindAddress":"0.0.0.0",
		    "listenPort":9000,
		    "connectionAddress":"",
		    "credentials": {},
		    "useAutoDiscover":false,
		    "backingStoreUrl":"",
		    "fallbackKey":""
		}

und:```bash
DummyQKDDriver -c driver_config-b.json # run as Bob, register with site agent

> Das Kontrolladressfeld kann 0.0.0.0:0 sein, wenn keine Firewall vorhanden ist. Falls doch, muss die tatsächliche IP des Hosts angegeben und ein geeigneter Port gewählt werden, den die Firewall nicht blockiert.

Es wird noch nichts passieren, da die Site-Agents nicht wissen, was sie mit diesen Geräten tun sollen. Wir können sie anweisen, mit der Schlüsselerstellung zu beginnen (-b as begin), indem wir den Befehl cqp::ISiteAgent::StartNode senden:```bash
SiteAgentCtl -c localhost:9000 -b '{"hops":[{"first":{"site":"'hostname':9000","deviceId":"dummyqkd__0__16_alice"},"second":{"site":"'hostname':9001","deviceId":"dummyqkd__0__16_bob"}}]}'

> Beachten Sie das `-e` anstelle von `-b`, um den Link zu *beenden* statt zu *beginnen*.

Komplexere Setups können erreicht werden, indem Sie das cqp::remote::INetworkManager-Interface selbst implementieren, um die Befehle zu erteilen. Rückmeldungen von den Geräten kommen über das cqp::remote::IReporting-Interface auf demselben Socket, sodass Sie auf Änderungen im System reagieren können. [Hier](#Reporting) sehen Sie, wie Sie mit dem StatsDump-Tool Dinge aus dem Reporting-Interface extrahieren können.

### Treiber erstellen <a name="CreatingDrivers" />

Die Treiberanwendung ist eine Brücke zwischen den internen Geräteschnittstellen (cqp::IQKDDevice) und der externen cqp::remote::IDevice-Schnittstelle. Die cqp::RemoteQKDDevice-Klasse erledigt den größten Teil der Arbeit für Sie, die Anwendung muss die Konfiguration und Erstellung des Geräts übernehmen.

Die eigentliche Arbeit besteht darin, einen Treiber zu erstellen, um das Gerät einzurichten und den Schlüssel auszulesen. Wenn Ihr Gerät nur Rohdetektionen erzeugt, müssen Sie eine [Verarbeitungspipeline](#ProcessingPipelines) wie cqp::DummyQKD oder cqp::PhotonDetectorMk1 und cqp::LEDAliceMk1 konfigurieren. Wenn Ihr Gerät einen gebrauchsfertigen Schlüssel wie das cqp::Clavis3Device erzeugt, müssen Sie ihn auslesen und über das cqp::IKeyCallback-Interface veröffentlichen (verwenden Sie cqp::KeyPublisher).

Beide Ansätze erfordern eine Form der Sitzungsverwaltung, die von cqp::session::SessionController und cqp::session::AliceSessionController bereitgestellt wird. Diese implementieren die cqp::ISessionController- und cqp::remote::ISession-Schnittstelle und werden von cqp::RemoteQKDDevice verwendet, um das Gerät und seinen Peer zu starten und zu stoppen. Normalerweise reichen diese aus, aber in manchen Situationen müssen sie spezialisiert werden, um den Geräteanforderungen gerecht zu werden.

    @startuml Readme_Drivers
    title Anatomy of a driver
        package Application {
            namespace cqp #DDDDDD {
                class RemoteQKD
                interface IQKDDevice {
                    GetSessionController()
                }
                class "SessionController" as session
                interface "IDetector::Service" as detServ {
                    StartDetecting()
                    StopDetecting()
                }
                class "Provider<IDetectionEventCallback>" as provider {
                    Attach()
                    Dettach()
                    Emit()
                }

                RemoteQKD .r.> IQKDDevice : uses
                IQKDDevice -r[hidden]-> session
            }
            class Main {
                main()
            }
            class MyDriver
            class Detector

            MyDriver .u.|> cqp.IQKDDevice
            MyDriver o-u-> cqp.session
            Detector .u.|> cqp.detServ
            Detector -u-|> cqp.provider

            Main o-> MyDriver
            MyDriver o-> Detector
            Main o-u-> cqp.RemoteQKD

            note bottom of MyDriver
                In this case the driver is a simple detector
                which produces detection. Post processing detail not shown.
                MyDriver pull together all the parts to run the driver.
            end note

            note bottom of Detector
                The detector controls the device
                and outputs the data using the Provider
            end note
        }
    @enduml

### Treiber registrieren <a name="Registering" />

Zum Zeitpunkt der Erstellung dieses Textes können alle Treiber mit einem Site-Agenten über den Schalter `-r` registriert werden. Dies bewirkt, dass cqp::RemoteQKDDevice cqp::remote::ISiteAgent::RegisterDevice auf dem cqp::SiteAgent aufruft, der dann das cqp::remote::ISession-Interface verwendet, um das Gerät zu starten/stoppen.

### IDevice-Schnittstelle <a name="IDeviceInterface" />

Diese Schnittstelle ermöglicht einen direkteren Zugriff auf das Gerät als über die Site-Agenten. Vom Gerät erzeugte Schlüssel werden sofort an den Aufrufer zurückgegeben. Rufen Sie zuerst cqp::remote::IDevice::WaitForSession auf, dann cqp::remote::IDevice::RunSession. Rufen Sie cqp::remote::IDevice::EndSession auf, um die Schlüsselerzeugung zu stoppen.

### HSMs <a name="HSMs" />

[HSMs](https://en.wikipedia.org/wiki/Hardware_security_module) sind Speichergeräte, die physisch sichere digitale Tresore darstellen. Es gibt eine Standardschnittstelle für sie namens [PKCS#11](https://en.wikipedia.org/wiki/PKCS_11). Jeder Hersteller hat seine eigenen Schnittstellen und die Unterstützung für PKCS#11 ist lückenhaft, es gibt jedoch eine Softwareimplementierung, die wir als Referenz verwenden, namens [SoftHSM2](https://www.opendnssec.org/softhsm/). Die Klasse cqp::keygen::HSMStore stellt eine Implementierung bereit, die den cqp::SiteAgent mit dem cqp::IBackingStore-Interface verbindet.

### IKey-Schnittstelle <a name="IKeyInterface" />

Sites stellen Schlüssel für viele Endpunkte bereit (die verfügbaren Schlüsselspeicher können durch Aufruf von cqp::remote::IKey::GetKeyStores abgerufen werden), sie können über das cqp::remote::IKey-Interface angefordert werden. Sobald ein neuer Schlüssel angefordert wurde, kann die andere Seite ihn nur als vorhandenen Schlüssel abrufen - dies verhindert Konflikte und Missbrauch von Schlüsseln.

### Verschlüsselung <a name="Encryption" />

Weitere Einzelheiten zu spezifischen Implementierungen finden Sie unter:
* [Tunnel](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/Tunnels.md)

### Berichterstattung <a name="Reporting" />

Änderungen von Werten im System werden extern über das cqp::remote::IReporting-Interface und intern über die cqp::stats::Stat-Klasse veröffentlicht. Sie können sich für alle Statistiken registrieren, indem Sie cqp::remote::IReporting::GetStatistics mit dem Feld cqp::remote::ReportingFilter::listIsExclude auf `true` setzen, oder es können bestimmte Filter angegeben werden.

### Verarbeitungspipelines <a name="ProcessingPipelines" />

Das standardmäßige [BB84-QKD-Protokoll](https://en.wikipedia.org/wiki/BB84) erfordert Nachbearbeitungsschritte, um die Rohdetektionen in nutzbare Schlüssel umzuwandeln.

- **Ausrichtung** Finden des Anfangs und Endes der eigentlichen Übertragung.
    + Anpassen von Zeitunterschieden/Drift usw.
    + Kompensation von Phasen- oder anderen Unterschieden zwischen Sender und Empfänger usw.
- **Siebungsphase** Verwerfen ungültiger Detektionen
- **Fehlerkorrektur** Korrigieren fehlerhafter Detektionen - ohne Preisgabe der Werte
- **Privatsphärenverstärkung** Hashing des Schlüssels, um preisgegebene Bits unbrauchbar zu machen

Ein Beispiel für eine Verarbeitungspipeline ist in cqp::DummyQKD::ProcessingChain zu sehen.

## Erstellung

Die Builds werden vom gitlab [Continuous-Integration-System](https://about.gitlab.com/product/continuous-integration/) verwaltet, das in der Datei `.gitlab-ci.yml` definiert ist.

Die Docker-Images können manuell durch Ausführen von `setup/makeDocker.sh` erstellt werden.

### Windows

Dies ist eine laufende Arbeit.
Dieses Setup wurde unter Windows 10 und Windows Server 2016 mit Visual Studio 15 (2016) getestet.
Die folgenden Konfigurationen werden unterstützt

| Betriebssystem | VS 2017   | QT Creator    | Codeblocks    |
|:--------------|-----------|---------------|---------------|
| Linux         |           | gcc           | gcc           |
| Windows       | MSVC      | MSVC / MSYS2  | MSYS2-Mingw   |

#### IDE

- [Visual Studio 2016][]
    + Führen Sie das Skript [InstallVcPkg.bat](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/vs2017_x64/InstallVcPkg.bat) einmal aus, um vcpkg in C:\vcpkg zu installieren.
    + Führen Sie das Skript [SetupMSBuild.bat](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/vs2017_x64/SetupMSBuild.bat) aus.
    + Öffnen Sie die Projektmappe [cqp.sln](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/vs2017_x64/cqp.sln).
    + Wählen Sie Erstellen->Projektmappe.
- [QT Creator für Windows][]
    + QT Creator kann entweder den nativen Microsoft-Compiler oder MSYS2 verwenden. Installieren Sie MSYS2 separat, Sie müssen nicht den minGW-Compiler installieren, der mit dem QTCreator-Installer geliefert wird. Oder installieren Sie das [Windows 10 SDK][].
    + Wählen Sie im Komponentenmenü die Komponenten für den von Ihnen verwendeten Compiler aus. Z.B. msvc2017
    + Verwenden Sie "Projekt öffnen" und wählen Sie die Datei `CMakeLists.txt` im Stammverzeichnis des Quellbaums.
- [MSYS2][] und [Codeblocks][]
    + Installieren Sie das Paket [MSYS2][].
    + Führen Sie das Skript [installMSYS2Dependencies.bat](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/installMSYS2Dependencies.bat) aus.
    + Unter Einstellungen->Debugger -> "Konfiguration erstellen" namens "MSYS2 GDB"
        - Ändern Sie den Debugger so, dass er auf gdb.exe zeigt (z.B. C:\\msys64\\mingw64\\bin\\gdb.exe).
    + Unter Einstellungen->Compiler
        + Kopieren Sie die GCC-Compilereinstellungen, nennen Sie sie "GCC - Alt"
        + Ändern Sie das Toolchain-Installationsverzeichnis auf MSYS2s mingw64-Installationsort (z.B. C:\\msys64\\   mingw64).
        + Entfernen Sie in jedem der Felder unter "Programmdateien" außer dem Programm "make" das Präfix `mingw32-`.
        + Fügen Sie im make-Feld den Schalter -j hinzu, um Mehrkern-Builds zu ermöglichen: `mingw32-make.exe -j`
        + Wählen Sie den zuvor erstellten Debugger "MSYS2 GDB"
        + Wenn Sie lesbare Ausgaben des Compilers bevorzugen, ändern Sie "Andere Einstellungen"->"Compiler-Protokollierung" auf "Aufgabenbeschreibung"
    + Im CodeBlock-Build-Verzeichnis (\\build\\CodeBlocks)
    + Führen Sie die Datei `SetupCodeBlocks-MSYS2.bat` aus.
    + Öffnen Sie die CodeBlocks-Projektdatei "CQP.cbp".

Wenn Ihre Projektdatei eine tiefe Ordnerstruktur aufweist (dies ist ein Fehler), kann dies verbessert werden, indem Sie mit der rechten Maustaste auf den Arbeitsbereich klicken und:
- "Ordner wie auf Datenträger anzeigen" deaktivieren
- "Ordnernamen ausblenden" aktivieren

## Zitieren dieser Software```
@Manual{,
title = {CQPToolkit: A QKD toolkit library},
author = {{Richard Collins, University of Bristol, UK}},
organization = {University of Bristol},
address = {Bristol, UK},
year = 2018,
url = {https://gitlab.com/QComms}
}