ChatGPT mit mittlerer Aufgabenstellung getestet

Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung formuliert und diese MS-Copilot vorgelegt:

---------------------------------------------------------------------------------------------------- Nachfolgend wird eine Programmieraufgabe beschrieben. Aufgabenstellung: Ein Skript für das Shell-Programm bash soll hergestellt werden. Dieses Skript soll jeweils eine Datei variabel verschlüsseln oder entschlüsseln. Das Skript soll 2 oder optional 3 Argumente entgegen nehmen. Das erste Argument soll die zu bearbeitende Datei angeben. Das zweite Arg soll 1 bis 6 Zeichen angeben, { die die Verschlüsselungs-Algorithmen kennzeichnen und gleichzeitig die Reihenfolge ihrer Verwendung anzeigen. Jeder Algorithmus kann mehr als 1-mal angegeben werden. Diese 1 bis 6 Zeichen sollen als Endung mit Punkt vorne an den Dateinamen (Arg1) des nun verschlüsselten Inhalts der Datei angehängt werden. Von diesem Inhalt soll ein Hash sha3_256 genommen und aufbewahrt werden. Diese Backup-Inhalte sind für die Aufbewahrung im Internet beabsichtigt. } Es sollen 3 Algorithmen zur Auswahl vorhanden sein. Mindestens 2 der 3 Algorithmen sollen kryptographische Qualität besitzen. Die Algorithmen sollen Argumente für eine Input-Datei und eine Output-Datei entgegen nehmen.

Das zweite Arg soll mit einem geeigneten Zeichen eine Entschlüsselung anzeigen. Das erste Arg enthält hierbei den Dateinamen mit der speziellen Endung aus 1 bis 6 Zeichen. Diese 1 bis 6 Zeichen sollen zur internen Steuerung verwendet werden. Vor dem Entschlüsselungsvorgang soll der zugehörige Hash auf Gleichheit geprüft werden.

Optional kann links als erstes Arg ein wählbares Arbeitsverzeichnis angegeben werden. Die bisherigen Arg1 und Arg2 werden dadurch zu Arg2 und Arg3.

Jemand, der den Dateinamen des verschlüsselten Inhalts betrachtet, soll durch die dort angegebenen 1 bis 6 Zeichen der Endung nicht die verwendeten Algorithmen erkennen können. Es soll hier folglich eine Verschleierung wirken. Der Aufwand dieser Verschleierung soll gering gehalten werden, weil bei Verwendung von mehr als einer Verschlüsselung hintereinander zu keinem Zeitpunkt der Erfolg eines Entschlüsselungs-Versuchs eines Angreifers erkennbar ist.

----------------------------------------------------------------------------------------------------

Prinzipiell hat ChatGPT seine Aufgabe korrekt erfüllt. Das war erwartbar, weil meine Anforderung vollständig und logisch stimmig ist. ChatGPT blieb daher nicht anderes übrig, als brauchbar zu antworten. Ich habe ChatGPT allerdings bewußt einige Freiheiten gelassen.

Vor konkreter Inbetriebnahme als Werkzeug in der Praxis muß seine Ausgabe allerdings einer gründlichen Untersuchung unterzogen werden, die wohl von allerlei Änderungen und Erweiterungen gefolgt werden muß, so scheint mir.

ChatGPT: ==================================================================================================== #!/usr/bin/env bash set -euo pipefail

# ------------------------------------------------------------ # konfigurierbare Zuordnung "verschleierter" Zeichen -> Algorithmen # mind. 2 kryptographisch, 1 optional nicht-kryptographisch # # Wir verwenden hier: # X -> AES-256-CBC (OpenSSL, symmetrisch, kryptographisch) # 7 -> CHACHA20 (OpenSSL, symmetrisch, kryptographisch) # _ -> gzip (Kompression, nicht kryptographisch) # # Die Zeichen X,7,_ verraten die Algorithmen nicht direkt. # ------------------------------------------------------------

# Pfad zu openssl und gzip OPENSSL_BIN=openssl GZIP_BIN=gzip

usage() { cat <<EOF Usage: Verschlüsseln: $0 [arbeitsverzeichnis] <datei> <seq>

Beispiele: $0 geheim.txt X7_ $0 geheim.txt.X7_ d $0 /tmp geheim.txt X7_ EOF exit 1 }

# ------------------------------------------------------------ # Algorithmus-Funktionen: jeweils in/out-Datei # ------------------------------------------------------------

algo_X_encrypt() { local in="$1" out="$2" pass="$3" "$OPENSSL_BIN" enc -aes-256-cbc -pbkdf2 -salt \ -in "$in" -out "$out" -pass pass:"$pass" }

algo_X_decrypt() { local in="$1" out="$2" pass="$3" "$OPENSSL_BIN" enc -d -aes-256-cbc -pbkdf2 \ -in "$in" -out "$out" -pass pass:"$pass" }

algo_7_encrypt() { local in="$1" out="$2" pass="$3" "$OPENSSL_BIN" enc -chacha20 -pbkdf2 -salt \ -in "$in" -out "$out" -pass pass:"$pass" }

algo_7_decrypt() { local in="$1" out="$2" pass="$3" "$OPENSSL_BIN" enc -d -chacha20 -pbkdf2 \ -in "$in" -out "$out" -pass pass:"$pass" }

algo__encrypt() { local in="$1" out="$2" "$GZIP_BIN" -c "$in" > "$out" }

algo__decrypt() { local in="$1" out="$2" gunzip -c "$in" > "$out" }

# ------------------------------------------------------------ # Hilfsfunktionen # ------------------------------------------------------------

calc_sha3() { local file="$1" hashfile="$2" "$OPENSSL_BIN" dgst -sha3-256 "$file" > "$hashfile" }

check_sha3() { local file="$1" hashfile="$2" if [ ! -f "$hashfile" ]; then echo "Fehler: Hash-Datei '$hashfile' fehlt." >&2 exit 1 fi local current stored current=$("$OPENSSL_BIN" dgst -sha3-256 "$file") stored=$(cat "$hashfile") if [ "$current" != "$stored" ]; then echo "Fehler: Hash-Prüfung fehlgeschlagen (Integrität verletzt)." >&2 exit 1 fi }

apply_encrypt_sequence() { local infile="$1" seq="$2" outfile="$3" pass="$4"

local tmp_in="$infile" local tmp_out

for ((i=0; i<${#seq}; i++)); do local c="${seq:i:1}" tmp_out="$(mktemp)"

case "$c" in X) algo_X_encrypt "$tmp_in" "$tmp_out" "$pass" ;; 7) algo_7_encrypt "$tmp_in" "$tmp_out" "$pass" ;; _) algo__encrypt "$tmp_in" "$tmp_out" ;; *) echo "Unbekanntes Algorithmus-Zeichen: '$c'" >&2 rm -f "$tmp_out" exit 1 ;; esac

# nächster Schritt: tmp_out wird zum neuen tmp_in if [ "$tmp_in" != "$infile" ]; then rm -f "$tmp_in" fi tmp_in="$tmp_out" done

mv "$tmp_in" "$outfile" }

apply_decrypt_sequence() { local infile="$1" seq="$2" outfile="$3" pass="$4"

local tmp_in="$infile" local tmp_out

# Entschlüsselung in umgekehrter Reihenfolge for ((i=${#seq}-1; i>=0; i--)); do local c="${seq:i:1}" tmp_out="$(mktemp)"

case "$c" in X) algo_X_decrypt "$tmp_in" "$tmp_out" "$pass" ;; 7) algo_7_decrypt "$tmp_in" "$tmp_out" "$pass" ;; _) algo__decrypt "$tmp_in" "$tmp_out" ;; *) echo "Unbekanntes Algorithmus-Zeichen: '$c'" >&2 rm -f "$tmp_out" exit 1 ;; esac

if [ "$tmp_in" != "$infile" ]; then rm -f "$tmp_in" fi tmp_in="$tmp_out" done

mv "$tmp_in" "$outfile" }

# ------------------------------------------------------------ # Argumente auswerten (inkl. optionalem Arbeitsverzeichnis) # ------------------------------------------------------------

if [ "$#" -lt 2 ] || [ "$#" -gt 3 ]; then usage fi

workdir="." file_arg="" seq_or_flag=""

if [ "$#" -eq 3 ]; then workdir="$1" file_arg="$2" seq_or_flag="$3" else file_arg="$1" seq_or_flag="$2" fi

cd "$workdir"

# ------------------------------------------------------------ # Modus bestimmen: Verschlüsseln vs. Entschlüsseln # ------------------------------------------------------------

if [ "$seq_or_flag" = "d" ]; then # Entschlüsselung enc_file="$file_arg"

if [ ! -f "$enc_file" ]; then echo "Fehler: Datei '$enc_file' nicht gefunden." >&2 exit 1 fi

# Dateiname und Sequenz aus Endung extrahieren: # erwartet: name.<seq>

base="${enc_file%.*}" seq="${enc_file##*.}"

if [ -z "$seq" ] || [ "${#seq}" -gt 6 ]; then echo "Fehler: ungültige Sequenz in Dateiendung." >&2 exit 1 fi

hashfile="${enc_file}.sha3" check_sha3 "$enc_file" "$hashfile"

# Passphrase abfragen (für kryptographische Algorithmen) read -r -s -p "Passphrase für Entschlüsselung: " pass echo

out_file="$base" # ursprünglicher Name ohne .<seq>

apply_decrypt_sequence "$enc_file" "$seq" "$out_file" "$pass"

echo "Entschlüsselt: $out_file"

else # Verschlüsselung plain_file="$file_arg" seq="$seq_or_flag"

if [ ! -f "$plain_file" ]; then echo "Fehler: Datei '$plain_file' nicht gefunden." >&2 exit 1 fi

if [ -z "$seq" ] || [ "${#seq}" -gt 6 ]; then echo "Fehler: Sequenz muss 1..6 Zeichen lang sein." >&2 exit 1 fi

# Passphrase abfragen (für kryptographische Algorithmen) read -r -s -p "Passphrase für Verschlüsselung: " pass echo

out_file="${plain_file}.${seq}"

apply_encrypt_sequence "$plain_file" "$seq" "$out_file" "$pass"

# Hash des verschlüsselten Inhalts berechnen und speichern hashfile="${out_file}.sha3" calc_sha3 "$out_file" "$hashfile"

echo "Verschlüsselt: $out_file" echo "Hash gespeichert in: $hashfile" fi ====================================================================================================