© Peter Jurik/stock.adobe.com

Quantenkryptographie einfach erklärt: Das BB84 Protokoll

Im dritten Beitrag meiner Reihe "Quantencomputing und Quantenkryptographie einfach erklärt" werde ich ein Hauptthema der Quantenkryptographie näher erläutern: Quantenschlüsselaustauschprotokolle, im Detail das Protokoll BB84. Klingt kompliziert, aber keine Angst - bevor wir uns das Protokoll näher anschauen, werden wir uns vorab erst einmal mit dem Sinn und Zweck von solchen Protokollen im Allgemeinen beschäftigen und dies völlig unabhängig von der Quantenkryptographie. Hierbei werden wir recht schnell erkennen, dass Schlüsselaustauschprotokolle alltäglich im Einsatz sind - auch in den Moment, in dem Du diese Webseite geöffnet hast.

Vorab der übliche Disclaimer: Ich bin weder Mathematiker, noch Physiker. Aus diesem Grund werde ich sicherlich nicht alle Punkte mit mathematisch/ physischer Präzision korrekt formuliert darlegen können. Insofern du Verbesserungsvorschläge für die Beiträge hast, so freue ich mich selbstverständlich über einen Kommentar oder Feedback.

Dieser Artikel ist Teil einer Serie:

- Teil 1: Was ist Spin?
- Teil 2: Die Grundlagen der Quanten-Mathematik
- Teil 3: Das Quantenschlüsselaustauschprotokoll BB84

Kapitel 1: Grundlagen Verschlüsselung

Beginnen werde ich dieses Mal mit einer Problembeschreibung, die völlig unabhängig von der Quantenkryptographie ist: Wie können zwei oder mehr Personen sicher miteinander kommunizieren? In meinen Kursen habe ich zur Darstellung des Problems sehr gerne das folgende Szenario genommen: Wir stellen uns für einen Moment vor, dass wir uns mitten auf einer belebten Kreuzung befinden, beispielsweise hier:

Alice und Bob auf einer Kreuzung

Alice und Bob auf einer Kreuzung [1]

Die Aufgabenstellung: Wie können die beiden rot markierten Person eine Nachricht austauschen, ohne dass diese sich näher kommen dürfen? Natürlich sind wir in einer modernen Welt, Smartphones existieren bereits. Aber wie stellt beispielsweise ein Smartphone sicher, dass eine Nachricht unverändert und vertraulich beim Empfänger ankommt?
Weiterlesen

© Alex - Fotolia.com

Kubernetes auf Ubuntu 20.04 installieren

Anbei ein kleines Skript, welches ich gerne nutze um auf einer frischen Ubuntu 20.04 Installation Google Kubernetes inkl. dem Dashboard und dem Metis Server zu Testzwecken auszurollen. Das Skript hat keinerlei Vorbedingungen sondern kann direkt nach einer Ubuntu 20.04 (Server-)Installation ausgeführt werden. Wie immer gilt jedoch:

Bitte testet das Skript vorab in einer sicheren Umgebung.

#!/bin/bash

# Lösche die folgende Zeile, wenn du das Skript verstanden und an dein System angepasst hast :)
exit

echo "Update System"
apt-get update
apt-get -y dist-upgrade

echo "Install some tools"
apt-get -y install aptitude apt-transport-https curl nftables net-tools zip jq

echo "Add Kubernetes Repository"
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" > /etc/apt/sources.list.d/kubernetes.list
apt-get update

echo "Install Docker"
apt-get -y install docker.io
systemctl enable docker.service

echo "Install Kubernetes"
apt-get -y install kubelet kubeadm kubectl

echo "Enable IP Forwarding"
sysctl -w net.ipv4.ip_forward=1
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf

echo "Disable SWAP"
cp /etc/fstab /tmp/fstab 
echo "" > /etc/fstab
cat /tmp/fstab | grep -v swap >> /etc/fstab
rm /tmp/fstab
swapoff -a 

echo "Setup Kubernetes Cluster"
kubeadm config images pull
kubeadm init --pod-network-cidr=192.168.0.0/16 --apiserver-advertise-address=<HIER DIE IP ADRESSE DES SERVERS>

echo "Distribute .kube Files for root"
mkdir -p /root/.kube
cp -i /etc/kubernetes/admin.conf /root/.kube/config
chown root:root /root/.kube/config

echo "Distribute .kube Files for user"
mkdir $HOME/.kube
sudo cp /etc/kubernetes/admin.conf $HOME/.kube/
sudo chown $(id -u):$(id -g) $HOME/.kube/admin.conf
export KUBECONFIG=$HOME/.kube/admin.conf

echo "Untainted Node"
kubectl taint nodes --all node-role.kubernetes.io/master-

echo "Install calico"
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

echo "Install Kubernetes Dashboard"
kubectl create namespace kubernetes-dashboard
mkdir /tmp/certs
openssl genrsa -out /tmp/certs/tls.key 4096
openssl rsa -in /tmp/certs/tls.key -out /tmp/certs/tls.key
openssl req -sha256 -new -key /tmp/certs/tls.key -out /tmp/certs/tls.csr -subj '/CN=localhost'
openssl x509 -req -sha256 -days 365 -in /tmp/certs/tls.csr -signkey /tmp/certs/tls.key -out /tmp/certs/tls.crt
kubectl -n kube-system create secret generic kubernetes-dashboard-certs --from-file=/tmp/certs -n kubernetes-dashboard
rm -r /tmp/certs/
kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0-rc7/aio/deploy/recommended.yaml
kubectl apply -f ./install/dashboard-adminuser.yaml
kubectl apply -f ./install/dashboard-role.yaml
kubectl create clusterrolebinding kube-dashboard-binding --clusterrole=admin --user=admin-user
openssl genrsa -out /tmp/kbdb.key 4096
openssl req -config ./install/dashboard-csr.cnf -new -key /tmp/kbdb.key -nodes -out /tmp/kbdb.csr
export BASE64_CSR=$(cat /tmp/kbdb.csr | base64 | tr -d '\n')
cat ./install/dashboard-csr.yaml | envsubst | kubectl apply -f -
kubectl certificate approve mycsr

echo "Install Metis-Server"
wget https://get.helm.sh/helm-v2.16.5-linux-amd64.tar.gz
tar -zxvf helm-v2.16.5-linux-amd64.tar.gz 
mv ./linux-amd64/helm /usr/local/bin/helm
rm ./helm-v2.16.5-linux-amd64.tar.gz
rm -r ./linux-amd64
/usr/local/bin/helm init --wait
kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'
kubectl apply -f ./install/metis.yaml
sleep 10
/usr/local/bin/helm install --name metrics-server stable/metrics-server --namespace metrics --set args={"--kubelet-insecure-tls=true,--kubelet-preferred-address-types=InternalIP\,Hostname\,ExternalIP"}

echo "Generating Access Keys"
sleep 60
kubectl get csr mycsr -o jsonpath='{.status.certificate}' | base64 --decode > /tmp/kbdb.crt
openssl pkcs12 -export -in /tmp/kbdb.crt -inkey /tmp/kbdb.key -out /tmp/kbdb.p12 -passout pass:
mv /tmp/kbdb.p12 $HOME/
chown $(id -u):$(id -g) $HOME/kbdb.p12
rm /tmp/kbdb.key
rm /tmp/kbdb.csr
rm /tmp/kbdb.crt
kubectl -n kubernetes-dashboard describe secret $(kubectl -n kubernetes-dashboard get secret | grep admin-user | awk '{print $1}') > /tmp/token.txt
mv /tmp/token.txt $HOME/
chown $(id -u):$(id -g) $HOME/token.txt

Das zu verwendende Clientzertifikat zum Import für euren lokalen Browser liegt anschließend unter $HOME/kbdb.p12. Der Zugriffstoken liegt unter $HOME/token.txt. Folgende Dateien habe ich im Skript im Unterordner "install" verwendet:

dashboard-adminuser.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard

dashboard-csr.cnf

[ req ]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn
[ dn ]
CN = admin-user
[ v3_ext ]
authorityKeyIdentifier=keyid,issuer:always
basicConstraints=CA:FALSE
keyUsage=keyEncipherment,dataEncipherment
extendedKeyUsage=serverAuth,clientAuth

dashboard-csr.yaml

apiVersion: certificates.k8s.io/v1beta1
kind: CertificateSigningRequest
metadata:
  name: mycsr
spec:
  groups:
  - system:authenticated
  request: ${BASE64_CSR}
  usages:
  - digital signature
  - key encipherment
  - server auth
  - client auth

dashboard-role.yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard

metis.yaml

kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: kubelet-api-admin
subjects:
- kind: User
  name: kubelet-api
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: system:kubelet-api-admin
  apiGroup: rbac.authorization.k8s.io

Quellen / Bildnachweis:

  • Beitragsbild: © Alex - Fotolia.com
© nik0.0kin/stock.adobe.com

Google Chrome Verlauf älter als x Tage/Monate löschen

Google Chrome als Browser bietet viele Vorteile, hat jedoch einen großen Nachteil: Die Löschung des Verlaufs bzw. der Daten im Cache ist äußerst unflexibel. In Google Chrome ist es möglich, den Verlauf der letzten Stunden, Tage oder Wochen zu löschen. Was ich vermisse, ist jedoch eine Funktion, die alle Daten löscht, die älter als x Tage bzw. Monate sind.

Google Chrome Verlauf

Google Chrome Verlauf

Zur Lösung des Problems habe ich ein kleines Skript entwickelt, welches ich automatisch beim Anmelden ausführen lasse. Das Skript ist unter Ubuntu Linux getestet, muss also vor dem Betrieb für Windows noch etwas angepasst werden.

Google Chrome Verlauf älter als x Tage löschen

Folgende wichtige Hinweise zum Skript:

  • Bitte testet das Skript vorab in einer sicheren Umgebung. Prüft, ob die Pfade zu eurem System passen. Legt ein Backup eures Google Chrome Profils an!
  • Ich nutzte keine Plugins unter Google Chrome. Nutzt ihr Plugins, so muss das Skript angepasst werden. Andernfalls sind die Plugins nach Ausführung des Skriptes weg.
  • Das Skript löscht alles aus eurem lokalen Google Chrome Profil, außer eure Einstellungen, den Verlauf der letzten x Tage und eure Bookmarks. Dazu gehören auch die in Google Chrome gespeicherten Passwörter.

Weiterlesen

© Peter Jurik/stock.adobe.com

Quantencomputing und Quantenkryptographie einfach erklärt: Grundlagen Mathematik

Nachdem ich im ersten Beitrag die Grundlagen der Quantenphysik erläutert habe, werde ich in diesem Beitrag versuchen, die grundlegende Mathematik möglichst einfach zu erklären. Spätestens wenn wir uns manche Eigenschaften wie die Verschränkung oder Quantenteleportation anschauen, dann wird die Thematik mit etwas Mathematik erheblich leichter verständlich. Vorab der übliche Disclaimer: Ich bin weder Mathematiker, noch Physiker. Aus diesem Grund werde ich sicherlich nicht alle Punkte mit mathematisch/ physischer Präzision korrekt formuliert darlegen können. Insofern du Verbesserungsvorschläge für die Beiträge hast, so freue ich mich selbstverständlich über einen Kommentar oder Feedback.

Dieser Artikel ist Teil einer Serie:

- Teil 1: Was ist Spin?
- Teil 2: Die Grundlagen der Quanten-Mathematik
- Teil 3: Das Quantenschlüsselaustauschprotokoll BB84

Kapitel 1: Zahlenmengen

Beginnen wir mit dem ersten Thema: Zahlenmengen. Zahlenmengen werden die meisten von uns sicherlich schon einmal im Laufe der Schulzeit gehört haben. So gibt beispielsweise die natürlichen Zahlen, ganze Zahlen oder auch die rationalen Zahlen. Da es ein Großteil der Literatur zu Quantentheorien primär auf englisch gibt, werde ich die wichtigsten englischen Übersetzungen im Folgenden ergänzen, um eine Recherche zu Details zu erleichtern.

Zahlenmengen

Verschiedene Zahlenmengen [1]

Eine kurze Wiederholung der bekanntesten Zahlenmengen:

Natürliche Zahlen, mathematisch mit zusammengefasst, sind alle positiven ganzen Zahlen, je nach Definition mit oder oder Null:

Weiterlesen

© Peter Jurik/stock.adobe.com

Quantencomputing und Quantenkryptographie einfach erklärt: Was ist Spin?

Nachdem es relativ wenig Beiträge gibt, die die Grundlagen des Quantencomputings bzw. der Quantenkryptographie einfach verständlich erklären, möchte ich im Folgenden mit einer Beitragsreihe das Themenfeld erklären. Vorab: Ich bin weder Mathematiker, noch Physiker, was vielleicht auch ein Vorteil sein kann, wenn man komplexe Sachverhalte aus den genannten Themengebieten einfach erklären möchte. Sicherlich werde ich nicht alle Punkte mit mathematisch/ physischer Präzision korrekt formuliert darlegen können - was für ein Grundverständnis jedoch auch nicht notwendig ist.

Dieser Artikel ist Teil einer Serie:

- Teil 1: Was ist Spin?
- Teil 2: Die Grundlagen der Quanten-Mathematik
- Teil 3: Das Quantenschlüsselaustauschprotokoll BB84

Insofern du Verbesserungsvorschläge für die Beiträge hast, so freue ich mich selbstverständlich über einen Kommentar oder Feedback. Letztendlich ist es ein Thema, welches mich selbst seit einigen Monaten sehr interessiert - und es gibt keinen Weg, etwas besser zu lernen, als es selbst für andere verständlich aufzubereiten. Natürlich werde ich den Fokus auf die relevanten IT-Security Themen aus dem Bereich nicht aussparen.

Kapitel 1: Der Einstieg

Ich habe in den letzten Monaten relativ viele Bücher zum Thema gelesen, eins hatten fast alle gemeinsam: den Einsteig ins Thema. Als guter Einstieg wird oftmals das Stern-Gerlach Experiment verwendet. Im Februar 1922 wurden von Otto Stern und Walther Gerlach erstmals bestimmte für uns im Folgenden relevante Eigenschaften anhand von Silberatomen experimentell bestätigt.

Stern-Gerlach

Otto Stern/ Walther Gerlach Gedenktafel am Haus des Physikalischen Vereins [1]

Aber der Reihe nach: Bevor ich das Experiment selbst erklären möchte, müssen wir auf eine Besonderheit bei Silberatomen eingehen - denn genau diese wurden im Experiment von Gerlach-Stern verwendet.

Weiterlesen

Martin Witkowski zu Themen aus IT, Datenschutz & Sicherheit.