> यदि आपने `--recurse-submodules` का उपयोग किए बिना क्लोन किया है, तो `git submodule update --init` चलाकर स्रोत फ़ोल्डर के अंदर से सबमॉड्यूल को अपडेट किया जा सकता है।

यहां प्रोजेक्ट को संकलित करने के लिए आवश्यक निर्भरताओं की एक सूची दी गई है (कृपया स्थापना के बारे में अधिक जानकारी के लिए नीचे आगे पढ़ें):```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

## पर्यावरण सेटअप

### पर्यावरण चर```bash
./src/Tools/SiteAgentRunner/SiteAgentRunner -p 8001 &
./src/Drivers/DummyQKDDriver/DummyQKDDriver -r localhost:8001 -b

जो डिफ़ॉल्ट रूप से कुछ ऐसा उत्पन्न करना चाहिए, यदि *SiteAgentRunner* और *DummyQKDDriver* को कॉन्फ़िगरेशन JSON स्ट्रिंग फ़ाइल तर्क निर्दिष्ट किए बिना लॉन्च किया गया हो:```json
{
 "url": "<hostname>:8000",
 "devices": [
  {
   "config": {
    "id": "dummyqkd__0__16_alice",
    "kind": "dummyqkd"
   },
   "controlAddress": "<hostname>:34219"
  }
 ]
}

- अब, कनेक्शन को कॉल करके बनाया जा सकता है:```bash
./src/Tools/SiteAgentCtl/SiteAgentCtl -c localhost:8000 -j localhost:8001

लिंक को unjoin कमांड के साथ रोका जा सकता है:```bash
./src/Tools/SiteAgentCtl/SiteAgentCtl -c localhost:8000 -u localhost:8001

- अब VPN के एलिस पक्ष को शुरू करें, बनाए जाने वाले टनल को परिभाषित करते हुए। दो पोर्ट खोले जाएंगे, प्रत्येक पक्ष के लिए एक 9000 और 9001 पर, इन पोर्ट में प्रवेश करने वाली कोई भी चीज़ एन्क्रिप्ट की जाएगी, दूसरी तरफ स्थानांतरित की जाएगी, डिक्रिप्ट की जाएगी और दूसरे पोर्ट पर उत्पादित की जाएगी।```
./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

और एक दूसरे पर:```
nc localhost 9001

### Ubuntu 18.04+

आप [Gitlab](https://gitlab.com/QComms/cqptoolkit/-/jobs/artifacts/master/download?job=package%3Adeb) से बाइनरी पैकेज स्थापित कर सकते हैं। ज़िप फ़ाइल निकालें और `dpkg` के साथ टूल्स स्थापित करें, यह गुम निर्भरताओं के बारे में शिकायत करेगा लेकिन चिंता न करें, दूसरी पंक्ति उन्हें ठीक कर देगी।```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

अन्यथा, स्रोत से निर्माण करने के लिए `setup/setupbuild.sh` में सूचीबद्ध निर्भरताओं को स्थापित करना आवश्यक है, वर्तमान में यह Ubuntu और Arch Linux के लिए काम करता है।

[git](https://gitlab.com/QComms/cqptoolkit.git) से स्रोत को क्लोन करें [git][] के साथ और [CMake][] और [gnu make](https://www.gnu.org/software/make/) के साथ निर्माण करें:
`--recurse-submodules` वैकल्पिक एक्सट्रा जोड़ता है - इनमें से कुछ तक पहुंच UoB और उसके भागीदारों तक सीमित है, निर्माण उनके बिना भी काम करेगा।```bash
git clone --recurse-submodules https://gitlab.com/QComms/cqptoolkit.git

अब, आप अपने स्थानीय रिपॉजिटरी में जा सकते हैं और स्क्रिप्ट के साथ निर्भरताएँ स्थापित कर सकते हैं (फ़ाइल अनुमति बदलने की आवश्यकता हो सकती है):```bash
cd cqptoolkit/setup
./setupbuild.sh

बिल्ड [CMake][] का उपयोग करके विभिन्न प्लेटफार्मों के लिए makefiles/समाधान/आदि तैयार करता है और इसे एक खाली बिल्ड फ़ोल्डर से चलाया जाता है जिसमें सभी आउटपुट फ़ाइलें होंगी। डीबग बिल्ड पैकेज तैयार करेंगे जिनके नाम में "D" प्रत्यय जुड़ा होता है।
बिल्ड को cmake को विकल्प पास करके नियंत्रित किया जा सकता है, जैसे `-DBUILD_TESTING=OFF`। उपलब्ध स्विचों की सूची देखने के लिए cmake को `-LH` विकल्प के साथ चलाएँ।

लाइब्रेरी में परिवर्तन और विकास करने के लिए [QT Creator](http://doc.qt.io/qtcreator/) स्थापित करने और [CMakeLists.txt फ़ाइल का चयन करके](https://codeyarns.com/2016/01/26/how-to-import-cmake-project-in-qt-creator/) प्रोजेक्ट खोलने की अनुशंसा की जाती है। Projects->Build Steps->Details पर जाकर और टूल पैरामीटर में `-j<number>` जोड़कर समानांतर बिल्ड का उपयोग करना उचित है, [देखें](https://stackoverflow.com/questions/8860712/setting-default-make-options-for-qt-creator)।
बिल्ड होने के बाद फ़ाइलें, डिफ़ॉल्ट रूप से, प्रोजेक्ट फ़ोल्डर के समान स्तर पर `build-<project name>-<platform>-<target>` नामक फ़ोल्डर में होती हैं।

> **Ubuntu पर protobuf + QT के बारे में नोट**
> लाइब्रेरी `qt5-gtk-platformtheme` protobuf के पुराने संस्करण से जुड़ी हुई है जो हमारे QT प्रोग्रामों को चलने से रोकेगी।
> इस वैकल्पिक निर्भरता को `apt-get remove qt5-gtk-platformtheme` के साथ हटाया जा सकता है।

## लाइब्रेरी की खोज

    @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

नीचे एक प्रवाह चार्ट है जो आपके लिए प्रासंगिक क्षेत्र खोजने में मदद करता है क्योंकि परियोजना QKD और कुंजी प्रबंधन के कई अलग-अलग पहलुओं को शामिल करती है - योगदानकर्ताओं का इस परियोजना को और अधिक विशिष्ट बनाने के लिए स्वागत है।
QKD के लिए किसी प्रकार के [गैर-क्लोनिंग](https://en.wikipedia.org/wiki/No-cloning_theorem) संचार की आवश्यकता होती है, आमतौर पर फाइबर ऑप्टिक केबल पर एकल फोटॉन का उपयोग करके। वे पॉइंट-टू-पॉइंट या एक-से-अनेक के रूप में काम कर सकते हैं लेकिन उनका स्वाभाविक रूप से एक भौतिक स्थान होता है (जहाँ फाइबर समाप्त होता है) - उन्हें वर्चुअलाइज़ नहीं किया जा सकता! वह बिंदु जहाँ फोटॉन प्रेषित या पता लगाया जाता है, सुरक्षित प्रणाली की सीमा है - लगभग नेटवर्क के [फ़ायरवॉल](https://en.wikipedia.org/wiki/Firewall_(computing)) की तरह। एक बार जब अविभाज्य फोटॉन बिट्स की एक स्ट्रिंग में बदल जाते हैं और एक [सममित कुंजी](https://en.wikipedia.org/wiki/Key_(cryptography)) बनाते हैं, तो कंप्यूटर सुरक्षा के मानक नियम जैसे प्रमाणीकरण, अभिगम नियंत्रण आदि लागू होते हैं। अंतर यह है कि एक बार जब वे कुंजियाँ उत्पन्न हो जाती हैं, तो प्रत्येक QKD उपकरण के पास एक संख्या होती है जो [किसी और को नहीं पता](https://en.wikipedia.org/wiki/Shared_secret) [विज्ञान द्वारा सिद्ध](https://arxiv.org/pdf/quant-ph/0003004.pdf) होती है।

इस "फ़ायरवॉल" प्रभाव की प्रकृति यह है कि QKD उपकरणों को नियंत्रित करने वाली प्रणालियों को सुरक्षित और विश्वसनीय माना जाना चाहिए - जिसे "विश्वसनीय नोड" भी कहा जाता है - जहाँ और कैसे आप रेखा खींचते हैं, यह सशस्त्र गार्ड से लेकर [सर्वर रूम का दरवाज़ा बंद करने](https://www.youtube.com/watch?v=rnmcRTnTNC8) तक हो सकता है।

यदि आप नीचे दिए गए आरेख को नहीं देख पा रहे हैं, तो कृपया [ऑनलाइन दस्तावेज़ीकरण](https://qcomms.gitlab.io/cqptoolkit/) पर जाएँ, इसे `doc` लक्ष्य द्वारा भी बनाया जा सकता है।

    @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 चलाना <a name="RunningDummyQKDDriver" />

यह अनुभाग QKD उपकरण के आउटपुट का अनुकरण करने के लिए DummyQKDDriver की उपयोगी कार्यक्षमता पर एक टिप्पणी मात्र है। कृपया अगले अनुभाग को देखें जहाँ उनके साथ एक सरल लिंक स्थापित करने का एक मार्गदर्शित उदाहरण दिया गया है।
अधिकांश प्रोग्रामों की तरह, इसे `-h` पास करने से उपलब्ध विकल्प प्रदर्शित होंगे। DummyQKDDriver cqp::DummyQKD वर्ग का उपयोग करके अनुकरणित फोटॉन पहचान पर प्रसंस्करण के बाद के मानक चरणों का एक सेट चलाता है। प्रोग्राम के दो उदाहरण चलने चाहिए, एक एलिस के लिए और एक बॉब के लिए।

बॉब को पोर्ट 8000 पर पहले चलाएँ, इस प्रकार कॉल करें:```bash
DummyQKDDriver -b -k 0.0.0.0:8000

यदि यह काम करता है तो आपको इस तरह के त्रुटि संदेशों की बाढ़ आ जाएगी: `ERROR: OnKeyGeneration No listener for generated key`. ऐसा इसलिए है क्योंकि इस तरह से सिस्टम को चलाना यह देखने के लिए अच्छा है कि यह कुछ कर रहा है, लेकिन यह बहुत उपयोगी नहीं है, उत्पन्न कुंजी को रखने के लिए कोई जगह नहीं है। ड्राइवरों को किसी चीज़ द्वारा उपयोग करने के लिए डिज़ाइन किया गया है।
प्रोजेक्ट में कुंजियों के प्रबंधन के लिए [Site Agents](#SiteAgents) नामक एक प्रणाली है, या आप [IDevice interface](#IDeviceInterface) का उपयोग करके सीधे ड्राइवरों से बात कर सकते हैं।

### Site Agents को कॉन्फ़िगर करना <a name="SiteAgents" />

नेटवर्क के प्रत्येक नोड के लिए Site agents, ड्राइवर, और VPN टनल को JSON स्ट्रिंग फ़ाइलों के साथ पैरामीट्रिज़ करने की आवश्यकता होती है क्योंकि बिना तर्कों के डिफ़ॉल्ट कमांड डिफ़ॉल्ट रूप से सभी आवश्यक फ़ील्ड निर्दिष्ट नहीं करता है और केवल उसी स्थानीय मशीन पर परीक्षण के लिए काम करता है।

Site agents को SiteAgentRunner के साथ चलाया जा सकता है, हम दो साइटों को इस प्रकार चला सकते हैं:```bash
SiteAgentRunner -c site-a.json

प्रत्येक JSON फ़ाइल में Alice और Bob के लिए अलग-अलग पोर्ट (जैसे 9000/9001) उपयुक्त रूप से दर्शाए गए हैं। JSON स्ट्रिंग इस प्रकार है:```json
		{
		    "name":"",
		    "id":"",
		    "netManUri":"",
		    "bindAddress":"0.0.0.0",
		    "listenPort":9000,
		    "connectionAddress":"",
		    "credentials": {},
		    "useAutoDiscover":false,
		    "backingStoreUrl":"",
		    "fallbackKey":""
		}

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

> नियंत्रण पता फ़ील्ड 0.0.0.0:0 हो सकता है यदि कोई फ़ायरवॉल न हो। यदि ऐसा है, तो होस्ट का वास्तविक IP इंगित करना होगा और एक उपयुक्त पोर्ट चुनना होगा जिसे फ़ायरवॉल अवरुद्ध न करे।

अभी कुछ नहीं होगा क्योंकि साइट एजेंटों को पता नहीं है कि इन उपकरणों के साथ क्या करना है। हम उन्हें cqp::ISiteAgent::StartNode कमांड भेजकर कुंजी बनाना शुरू करने के लिए निर्देशित कर सकते हैं (-b शुरू करने के लिए):```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"}}]}'

> ध्यान दें कि लिंक को *शुरू* करने के बजाय *समाप्त* करने के लिए `-e` का उपयोग करें, `-b` का नहीं।

अधिक जटिल सेटअप को स्वयं cqp::remote::INetworkManager इंटरफ़ेस को लागू करके प्राप्त किया जा सकता है ताकि कमांड जारी किए जा सकें। उपकरणों से फीडबैक उसी सॉकेट पर cqp::remote::IReporting इंटरफ़ेस के माध्यम से आता है ताकि आप सिस्टम में बदलावों पर प्रतिक्रिया कर सकें। [यहाँ](#Reporting) आप देख सकते हैं कि StatsDump टूल के साथ रिपोर्टिंग इंटरफ़ेस से चीजें कैसे निकालें।

### ड्राइवर बनाना <a name="CreatingDrivers" />

ड्राइवर एप्लिकेशन आंतरिक डिवाइस इंटरफ़ेस (cqp::IQKDDevice) और बाहरी cqp::remote::IDevice इंटरफ़ेस के बीच एक सेतु है। cqp::RemoteQKDDevice क्लास आपके लिए अधिकांश कार्य संभालता है, एप्लिकेशन को डिवाइस के कॉन्फ़िगरेशन और निर्माण को संभालना होता है।

असली काम डिवाइस को सेटअप करने और कुंजी पढ़ने के लिए ड्राइवर बनाने में है। यदि आपका डिवाइस केवल कच्ची डिटेक्शन उत्पन्न करता है तो आपको [प्रोसेसिंग पाइपलाइन](#ProcessingPipelines) जैसे cqp::DummyQKD या cqp::PhotonDetectorMk1 और cqp::LEDAliceMk1 कॉन्फ़िगर करने की आवश्यकता होगी। यदि आपका डिवाइस cqp::Clavis3Device जैसी उपयोग के लिए तैयार कुंजी उत्पन्न करता है तो आपको इसे पढ़ना होगा और cqp::IKeyCallback इंटरफ़ेस (cqp::KeyPublisher का उपयोग करें) पर प्रकाशित करना होगा।

इन दोनों दृष्टिकोणों में सत्र प्रबंधन के एक रूप की आवश्यकता होती है, जो cqp::session::SessionController और cqp::session::AliceSessionController द्वारा प्रदान किया जाता है, ये cqp::ISessionController और cqp::remote::ISession इंटरफ़ेस को लागू करते हैं और cqp::RemoteQKDDevice द्वारा डिवाइस और उसके सहकर्मी को शुरू और रोकने के लिए उपयोग किए जाते हैं। ये आमतौर पर आवश्यक सभी चीजें हैं लेकिन कुछ स्थितियों में डिवाइस की आवश्यकताओं से निपटने के लिए इन्हें विशेषज्ञ बनाने की आवश्यकता होती है।

    @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

### ड्राइवर पंजीकृत करना <a name="Registering" />

इस लेखन के समय, सभी ड्राइवरों को `-r` स्विच का उपयोग करके एक साइट एजेंट के साथ पंजीकृत किया जा सकता है। इससे cqp::RemoteQKDDevice cqp::SiteAgent पर cqp::remote::ISiteAgent::RegisterDevice को कॉल करता है, फिर यह डिवाइस को शुरू/रोकने के लिए cqp::remote::ISession इंटरफ़ेस का उपयोग करेगा।

### IDevice इंटरफ़ेस <a name="IDeviceInterface" />

यह इंटरफ़ेस साइट एजेंटों के माध्यम से जाने की तुलना में डिवाइस तक अधिक सीधी पहुँच की अनुमति देता है। डिवाइस द्वारा उत्पन्न कुंजी तुरंत कॉलर को वापस दी जाती है। पहले cqp::remote::IDevice::WaitForSession को कॉल करें, फिर cqp::remote::IDevice::RunSession को। कुंजी उत्पन्न करना बंद करने के लिए cqp::remote::IDevice::EndSession को कॉल करें।

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

[HSMs](https://en.wikipedia.org/wiki/Hardware_security_module) भंडारण उपकरण हैं जो भौतिक रूप से सुरक्षित डिजिटल तिजोरी हैं। उनके लिए एक मानक इंटरफ़ेस है जिसे [PKCS#11](https://en.wikipedia.org/wiki/PKCS_11) कहा जाता है। प्रत्येक निर्माता के अपने इंटरफ़ेस होते हैं और PKCS#11 के लिए समर्थन अधूरा है, हालांकि एक सॉफ्टवेयर कार्यान्वयन है जिसका हम संदर्भ के रूप में उपयोग करते हैं जिसे [SoftHSM2](https://www.opendnssec.org/softhsm/) कहा जाता है। cqp::keygen::HSMStore वर्ग एक कार्यान्वयन प्रदान करता है जो cqp::SiteAgent को cqp::IBackingStore इंटरफ़ेस से जोड़ता है।

### IKey इंटरफ़ेस <a name="IKeyInterface" />

साइटें कई एंडपॉइंट के लिए कुंजियाँ प्रदान करती हैं (उपलब्ध कुंजी भंडार cqp::remote::IKey::GetKeyStores को कॉल करके प्राप्त किए जा सकते हैं), उन्हें cqp::remote::IKey इंटरफ़ेस का उपयोग करके अनुरोध किया जा सकता है। एक बार नई कुंजी का अनुरोध करने के बाद, दूसरा पक्ष इसे केवल मौजूदा कुंजी के रूप में ही प्राप्त कर सकता है - यह कुंजियों के टकराव और दुरुपयोग को रोकता है।

### एन्क्रिप्शन <a name="Encryption" />

विशिष्ट कार्यान्वयन पर अधिक विवरण यहां पाया जा सकता है:
* [Tunnels](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/Tunnels.md)

### रिपोर्टिंग <a name="Reporting" />

सिस्टम में मानों में बदलाव बाहरी रूप से cqp::remote::IReporting इंटरफ़ेस के माध्यम से और आंतरिक रूप से cqp::stats::Stat वर्ग के साथ प्रकाशित किए जाते हैं। आप cqp::remote::IReporting::GetStatistics को cqp::remote::ReportingFilter::listIsExclude फ़ील्ड को `true` पर सेट करके सभी स्टैट्स के लिए पंजीकृत हो सकते हैं या विशिष्ट फ़िल्टर निर्दिष्ट किए जा सकते हैं।

### प्रोसेसिंग पाइपलाइन <a name="ProcessingPipelines" />

मानक [BB84 QKD प्रोटोकॉल](https://en.wikipedia.org/wiki/BB84) को कच्ची डिटेक्शन को उपयोग योग्य कुंजियों में बदलने के लिए पोस्ट प्रोसेसिंग चरणों की आवश्यकता होती है।

- **संरेखण** वास्तविक ट्रांसमिशन के आरंभ और अंत का पता लगाना।
    + समय अंतर/ड्रिफ्ट आदि के लिए समायोजन।
    + ट्रांसमीटर और रिसीवर के बीच चरण या अन्य अंतरों की भरपाई, आदि
- **सिफ्टिंग** अमान्य डिटेक्शन को हटाना
- **त्रुटि सुधार** गलत डिटेक्शन को सुधारना - मानों को उजागर किए बिना
- **गोपनीयता प्रवर्धन** कुंजी को हैश करना ताकि कोई भी उजागर बिट बेकार हो जाएं

प्रोसेसिंग पाइपलाइन का एक उदाहरण cqp::DummyQKD::ProcessingChain में देखा जा सकता है।

## निर्माण

निर्माण gitlab [सतत एकीकरण प्रणाली](https://about.gitlab.com/product/continuous-integration/) द्वारा प्रबंधित किए जाते हैं जो `.gitlab-ci.yml` फ़ाइल में परिभाषित है।

डॉकर इमेज को `setup/makeDocker.sh` चलाकर मैन्युअल रूप से बनाया जा सकता है।

### विंडोज

यह कार्य प्रगति पर है।
यह सेटअप विंडोज 10 और विंडोज सर्वर 2016 पर विजुअल स्टूडियो 15 (2016) के साथ परीक्षण किया गया है।
निम्नलिखित कॉन्फ़िगरेशन समर्थित हैं

| ओएस        | VS 2017   | QT Creator    | Codeblocks    |
|:----------|-----------|---------------|---------------|
| Linux     |           | gcc           | gcc           |
| Windows   | MSVC      | MSVC / MSYS2  | MSYS2-Mingw   |

#### आईडीई

- [Visual Studio 2016][]
    + C:\vcpkg में vcpkg स्थापित करने के लिए [InstallVcPkg.bat](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/vs2017_x64/InstallVcPkg.bat) स्क्रिप्ट एक बार चलाएं
    + [SetupMSBuild.bat](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/vs2017_x64/SetupMSBuild.bat) स्क्रिप्ट चलाएं
    + [cqp.sln](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/vs2017_x64/cqp.sln) समाधान खोलें
    + बिल्ड->समाधान चुनें
- [QT Creator for windows][]
    + QT Creator या तो मूल Microsoft कंपाइलर या MSYS2 का उपयोग कर सकता है। MSYS2 को अलग से स्थापित करें, आपको QTCreator इंस्टॉलर के साथ आने वाले minGW कंपाइलर को स्थापित करने की आवश्यकता नहीं है। या [Windows 10 SDK][] स्थापित करें
    + घटक मेनू के अंतर्गत, अपने उपयोग किए जा रहे कंपाइलर के लिए घटक चुनें। जैसे msvc2017
    + "Open Project" का उपयोग करके, स्रोत ट्री के आधार पर `CMakeLists.txt` फ़ाइल चुनें।
- [MSYS2][] और [Codeblocks][]
    + [MSYS2][] पैकेज स्थापित करें।
    + [installMSYS2Dependencies.bat](https://gitlab.com/qcomms/cqptoolkit/-/blob/master/build/installMSYS2Dependencies.bat) स्क्रिप्ट चलाएं
    + सेटिंग्स->डीबगर के अंतर्गत -> "MSYS2 GDB" नामक "कॉन्फिग बनाएं"
        - डीबगर को gdb.exe की ओर इंगित करने के लिए बदलें (जैसे C:\\msys64\\mingw64\\bin\\gdb.exe)
    + सेटिंग्स->कंपाइलर के अंतर्गत
        + GCC कंपाइलर सेटिंग्स कॉपी करें, इसे "GCC - Old" नाम दें
        + टूलचेन इंस्टॉलेशन निर्देशिका को MSYS2 के mingw64 स्थापना स्थान पर बदलें (जैसे C:\\msys64\\mingw64)
        + "Program Files" के अंतर्गत प्रत्येक फ़ील्ड में, "make" प्रोग्राम को छोड़कर, `mingw32-` उपसर्ग हटाएं।
        + make फ़ील्ड में, मल्टी-कोर बिल्डिंग की अनुमति देने के लिए -j स्विच जोड़ें: `mingw32-make.exe -j`
        + पहले बनाए गए "MSYS2 GDB" डीबगर का चयन करें
        + यदि आप कंपाइलर से पढ़ने योग्य आउटपुट पसंद करते हैं, तो "अन्य सेटिंग्स"->"कंपाइलर लॉगिंग" को "कार्य विवरण" पर सेट करें
    + CodeBlock बिल्ड निर्देशिका (\\build\\CodeBlocks) में
    + `SetupCodeBlocks-MSYS2.bat` फ़ाइल चलाएं
    + "CQP.cbp" CodeBlocks प्रोजेक्ट फ़ाइल खोलें।

यदि आपकी प्रोजेक्ट फ़ाइल में गहरी फ़ोल्डर संरचना है (यह एक बग है), तो इसे वर्कस्पेस पर राइट-क्लिक करके और निम्नलिखित करके सुधारा जा सकता है:

- "डिस्क पर फ़ोल्डर्स दिखाएं" को अनचेक करें
- "फ़ोल्डर का नाम छुपाएं" को चेक करें

## इस सॉफ्टवेयर का उद्धरण```
@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}
}