ChatGPT mit mittlerer Aufgabenstellung getestet

Welche Datenmenge? Ich sprach hingegen von Dateimenge. Dateimenge beschreibt die in /etc befindlichen Dateien, nach Aufgaben. Es gibt unter FreeBSD bestimmte Konfigurations-Dateien nicht, die jedoch unter SystemV vorhanden sind - und umgekehrt.

Ich weiß jetzt nicht mehr, was Du eigentlich willst. Du schreibst semantisch außerordentlich widersprüchlich.

Ich werde kein von einer KI generiertes Skript direkt verwenden - blind schon mal gar nicht! Das sagte ich im Thread bereits. Ich bin doch nicht bescheuert!

Ich würde auch das Gnu-Kommando 'gpg' nicht verwenden, aus mehreren Gründen. Die man-page dazu sagt mir, daß ich dieses Kommando nicht brauche und sogar gar nicht gebrauchen will und die Abhängigkeit davon keinesfalls haben will! Allein der zusätzliche Aufwand ist entbehrlich. Gegen Chiffren aus openssl habe ich prinzipiell nichts.

Wie lautet denn das Subject hier? Da steht was von Test einer KI.

Die Verschleierung _allein_ durch die Wahl von Steuerzeichen ist kostenlos. Deshalb lasse ich mir diesen Nullaufwand gefallen. Immerhin handelt es sich um Backup-Dateien, die beliebig lange im Internet verweilen könnten, mit ihren ohne Verschleierung eventuell verräterischen Dateinamen.

Ich teilte bereits im Thread mit, daß ich seit Monaten ein selbst entwickeltes Skript erfolgreich verwende. Lediglich die Kommandos 'glabel' und 'df' benötige ich von extern. Keines davon muß nach Installation des OS nachträglich besorgt und installiert werden. Alle anderen sind in die verwendete Shell eingebaut - auch mehrere Chiffren.

Ich wäre ja bescheuert, würde ich mein eigenes, erprobtes Skript nicht ausschließlich weiter verwenden. Sämtliche Testausgaben von KIs werde ich garantiert nicht als Werkzeug in Praxis verwenden. Auch nicht nach Anpassungen, die diese Skripte einwandfrei verwendbar machten. Mein Skript und mein eigener Interpreter sind eben insgesamt haushoch überlegen.

Bevor ich den kurzen Satz schrieb, fragte ich mich: was wird daraufhin wohl kommen?

Und bist Du nicht froh, jetzt darauf eine Antwort zu haben?

Siehste, so hilfreich bin ich.

SCNR, Alex.

*seufz* Ok, mein Fehler, falsch gelesen. Immer noch eine .. nicht sehr sinnvolle Metrik.

Siehe unten: FreeBSD ist kein SystemV und ausserhalb historischer Setups wirst Du auch kein aktuelles SystemV finden heutzutage.

Man liest sich, Alex.

Ich bin froh, eine Antwort erhalten zu haben. Allerdings glaube ich deren Aussage nicht.

Ich habe sie noch - habe sie aufgehoben, seit den 1980ern und 1990ern. Vor FreeBSD war ich sehr auf SCO (Santa Cruz Operation) fixiert. Die hatten ihre Systeme für Privatleute Royalty-Free an einen Importeur abgegeben. Von dem erhielt ich die für wenig Geld - immerhin inklusive Development-System.

Die ersten C++ hatten den Code in C umgewandelt (mit sehr vielen Klammerpaaren) und kompilierten mittels C-Compiler. Die Datei-Endung für C++ war 'datei.C'.

Als symbolische Links aufkamen, hatten die das komplette System mittels zehntausender Symlinks in den User-Bereich gelinkt.

Ich hatte von SCO Unixware, Netware, OpenUnix8, mehrere OpenServer, und SCO-Unix386-SysV (1988). Das letztgenannte hatte mein Arbeitgeber für über 3000 DM gekauft. Dateinamen durften dort maximal 14 Zeichen lang sein. Der C-Compiler 32bit war von Microsoft. cc wie auch cl waren damals ziemlich fehlerbehaftet. Ich hatte die etwa 50 Disketten 5¼" nach 3½ umgemodelt, die Images könnte ich noch haben.

?mansearchword=cc&mansection=&lang=de

Fällt unter historisch. ;-)

Mir ist Ende der 1990er mal ein Coherent zugelaufen. Unix ohne Netzwerk, wer Coherent damals mit Netzwerk wollte, musste extra zahlen - das fand ich schon damals sehr seltsam. Zu der Zeit liefen im Studentennetz die Router schon mit Linux ...

Naja, umgewandelt - die ersten C++ "Compiler" waren halt als Präprozessor für den C-Compiler implementiert. Da war C++ aber auch noch ganz massiv einfacher als heute.

Oh ja, kommerzielles Unix, gerade aus der Zeit, war teilweise echt grauslig.

Man liest sich, Alex.

Wie der Betreff es kundtut, wurden die KI getestet, um Bewertungen zu deren Ausgaben abgeben zu können. Insbesondere wurden den KI in der Aufgabenstellung absichtlich viele Freiheiten gelassen, um festzustellen, wie die KI darauf reagieren.

Es war nie beabsichtigt, die Ausgaben der KI als (angepaßtes!) Werkzeug zu verwenden. Wegen der belassenen Freiheiten sind die Skripte logischerweise auch nicht so maßgeschneidert geworden, wie es erforderlich ist. Es existiert seit Monaten ein mehrfach erprobtes Skript, das zudem besser geeignet ist, als es von einer KI je geliefert werden kann.

Die getesteten KI Copilot und ChatGPT haben beide ein brauchbares Skript abgeliefert. Das heißt, die Skripte würden nach einigen Anpassungen, die hpts. wegen der belassenen Freiheiten erforderlich geworden sind, sehr wahrscheinlich funktionieren.

Das Skript von Copilot kommt mir mehr entgegen, als das von ChatGPT. Das kann auch daran liegen, daß ich Copilot bisher wesentlich häufiger besuchte.

Ein Detail ist wissenschaftlich interessant: ChatGPT hatte zwecks Entschlüsselung Arg2 den Inhalt '-qm7' gegeben (-). Copilot hat den Inhalt 'd' gewählt. . "Das zweite Arg soll mit einem geeigneten Zeichen eine Entschlüsselung anzeigen." . "Arg2 soll hier nur das eine Entschlüsselungs-Zeichen enthalten." Mit dem Hinweis des zweiten Satzes wählte auch ChatGPT 'd'. Der erste Satz ist tatsächlich nicht eindeutig genug!

Copilot hat eine Eingabe von einzelnen Zeichen per 'read' vorgesehen, für den Key. Für alle Krypto-Algo ein und denselben Key. ChatGPT handelt gleich wirkend mittels des Kommandos 'gpg' (GnuPG). Ich kann beides nicht akzeptieren, besonders nicht das komplexe Kommando.

----- Ich will mindestens 6 Keys allerhöchster Qualität als Konstanten mit Skript-Eignung im Skript haben: . K1='@T4,?`Nfd:+8j;w*pVI-^JBH[{Y$SaxWAiz]ck!U}s6r7Q)5_v"EXKD0L\2<3yqO' . K2='Ve%UFRYKpSbo9;!~5vMT*&Bdz.\-^_:4CHNr(0)n1/wx8QDElI$WPyis|>ga{j[k' . K3='G3K^J1o6y9!_4;7]|:DThL*x.FYO[gCfzqI5a%$8bu+"m\Re@A,&v/?-XZBwQrnP' . K4='Oq(Z"f#~EIgw_3)zC+?\GHj5rQM2SN,x]s`pXJv{yutc[AkiF7.U^dLe1%TWV6bl' Sicherheitsbedenken gibt es hierzu gar nicht. Jeder Verschlüsselungsvorgang soll seinen eigenen unterschiedlichen Key haben.

Die von den KI ausgewählten Chiffren könnten verwendet werden. Logischerweise verwende ich jedoch diejenigen Algorithmen, die in die verwendete Shell eingebaut oder als Executable stets verfügbar sind. Bevorzugt werden Strom-Chiffren, bei den kryptographischen Algorithmen.

Beide KI generieren Dateinamen wie 'dokument.pdf.qm7.sha3_256' für einen Hash. Das paßt mir gar nicht; es ist u.a. unnötig unbequem. Viel besser ist ein >>Dateiinhalt wie: ubin.tar.ehuu 18537592 0d3e8f87923c78a17f9d4ce65f20617b085f569cf96d4787241395cf91a0ad02 202607112058.38 u.tar.ehu 7470516224 66a5bbcdd84498e500491f8ae575ec18f7858746a716574e1aed8a6adc8f00f4 202607130038.34 home.tar.ehu 5186626220 7f42487e8b5ba6e65e0f14f0004753d7fd8f2bbb4881d750f85ecd45e6ccde83 202607130039.17 tmp.tar.ehu 6264413528 cebbac031dbc627cf3f627a41c6dbd07528392a67937a4a46ad20a17a75f85ef 202607130042.58 Die vorstehenden Daten sind inzwischen veraltet.

Beide KI verwenden nicht das vorteilhafte Shell-Kommando 'shift', wegen des optionalen Arguments.

ChatGPT schreibt: Wenn jemand sowohl dokument.pdf.qm7 als auch dokument.pdf.qm7.sha3_256 manipulieren kann, kann er auch den Hash neu berechnen. Für ein Backup im Internet wäre deshalb eine digitale Signatur bzw. ein MAC zusätzlich sinnvoll. Der reine SHA3-256-Hash schützt insbesondere gegen Übertragungs- und Speicherkorruption, nicht gegen einen Angreifer, der beide Dateien verändern kann.

----- Hier ist die KI unlogisch. Alle Hashes sind ausschließlich auf meinem PC, beim Skript, in der einen hash-Datei. Dort wird das alles auf 2.HDD, MemCard, und ins Internet abgesichert.

Beide KI verwenden fleißig: . for ((i=0; i<${#SEQUENCE}; i++)); do In der Korn-Shell lernte ich (( math )) $(( math )) $( ) kennen. In Verbindung mit 'for' wird jedoch die Mathe nicht von links nach rechts abgearbeitet, sondern immer wieder in den Schleifenkörper gesprungen. Ich finde das doof. Besser finde ich eine solche zusätzliche Schleife: . [ for Name ] [ from a ] [ by i ] [ to b ] repeat . do . Liste . done

----- . df -hT "$od" | { readl; readl Z; } && { nop $Z; [ $, -eq 7 ]; } && { . for 7 - typ - - av - dir in $Z . do break; done . [ "$typ" == tmpfs -a av -ge 25 -a "$dir/" == "$od" ] && ram=1 . } Auch vorstehende for-Struktur-Schleife ist sehr nützlich.

Korn-Shell:

Aufgabenstellung: ================================================================================================================== 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. Arg2 soll hier nur das eine Entschlüsselungs-Zeichen enthalten. 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 wegen relativer Unwichtigkeit 'kostenlos' gehalten werden. ==================================================================================================================

Copilot: ================================================================================================================== #!/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>

<seq> = 1..6 Zeichen aus {X,7,_}, Reihenfolge = Reihenfolge der Algorithmen Ergebnis: <datei>.<seq> und Hash-Datei <datei>.<seq>.sha3

Entschlüsseln: $0 [arbeitsverzeichnis] <datei.muster> d <datei.muster> = Dateiname mit Endung .<seq>

'd' = Entschlüsselungsmodus Vor Entschlüsselung wird Hash aus <datei>.<seq>.sha3 geprüft.

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 ==================================================================================================================

ChatGPT: ================================================================================================================== #!/usr/bin/env bash # # cryptbackup.sh # # Verschlüsseln: # ./cryptbackup.sh DATEI ALGORITHMUSFOLGE # # Entschlüsseln: # ./cryptbackup.sh DATEI.ENDUNG d # # Mit Arbeitsverzeichnis: # ./cryptbackup.sh ARBEITSVERZEICHNIS DATEI ALGORITHMUSFOLGE # # ./cryptbackup.sh ARBEITSVERZEICHNIS DATEI.ENDUNG d # # Beispiel: # ./cryptbackup.sh geheim.txt qm7 # ./cryptbackup.sh geheim.txt.qm7 d # # ./cryptbackup.sh /backup geheim.txt qm7 # ./cryptbackup.sh /backup geheim.txt.qm7 d # # Interne, absichtlich nicht sprechende Zuordnung: # q -> AES256 # m -> CAMELLIA256 # 7 -> TWOFISH # # Die Zuordnung dient ausschließlich der Verschleierung. #

set -euo pipefail

PROGRAM="${0##*/}"

# ============================================================ # ALGORITHMUS-ZUORDNUNG # ============================================================

declare -A ALG

ALG[q]="AES256" ALG[m]="CAMELLIA256" ALG[7]="TWOFISH"

# ============================================================ # HILFSFUNKTIONEN # ============================================================

usage() { cat >&2 <<EOF Verwendung:

Verschlüsseln: $PROGRAM DATEI ALGORITHMUSFOLGE

Entschlüsseln: $PROGRAM DATEI.ENDUNG d

Mit Arbeitsverzeichnis:

$PROGRAM ARBEITSVERZEICHNIS DATEI ALGORITHMUSFOLGE

$PROGRAM ARBEITSVERZEICHNIS DATEI.ENDUNG d

Beispiele:

$PROGRAM geheim.txt qm7 $PROGRAM geheim.txt.qm7 d

$PROGRAM /backup geheim.txt qm7 $PROGRAM /backup geheim.txt.qm7 d

Verschlüsselung: Die Algorithmusfolge besteht aus 1 bis 6 Zeichen.

Entschlüsselung: Arg2 muss genau aus dem einen Zeichen 'd' bestehen. Die Algorithmusfolge wird aus dem Dateinamen gelesen. EOF

exit 2 }

die() { echo "$PROGRAM: $*" >&2 exit 1 }

need_command() { command -v "$1" >/dev/null 2>&1 || die "Benötigtes Programm '$1' wurde nicht gefunden." }

# ============================================================ # SHA3-256 # ============================================================

sha3_256() { local file="$1"

openssl dgst -sha3-256 -r "$file" | awk '{print $1}' }

# ============================================================ # ALGORITHMUSFOLGE PRÜFEN # ============================================================

decode_sequence() { local sequence="$1" local i local char

# Nur 1 bis 6 Zeichen. # Erlaubt sind ausschließlich die definierten # Verschleierungszeichen.

[[ "$sequence" =~ ^[qm7]{1,6}$ ]] || die "Ungültige Algorithmusfolge: '$sequence'"

# Zusätzliche Prüfung der Zuordnung.

for ((i=0; i<${#sequence}; i++)); do

char="${sequence:i:1}"

[[ -n "${ALG[$char]+x}" ]] || die "Unbekanntes Steuerzeichen '$char'"

done }

# ============================================================ # ARGUMENTE AUSWERTEN # ============================================================

case "$#" in

2) # Kein Arbeitsverzeichnis angegeben. # # Arg1 = Datei # Arg2 = Algorithmusfolge oder d

WORKDIR="." FILE="$1" MODE="$2" ;;

3) # Arbeitsverzeichnis angegeben. # # Arg1 = Arbeitsverzeichnis # Arg2 = Datei # Arg3 = Algorithmusfolge oder d

WORKDIR="$1" FILE="$2" MODE="$3" ;;

*) usage ;;

esac

# ============================================================ # ARBEITSVERZEICHNIS # ============================================================

[[ -d "$WORKDIR" ]] || die "Arbeitsverzeichnis existiert nicht: $WORKDIR"

cd -- "$WORKDIR"

# ============================================================ # BENÖTIGTE PROGRAMME # ============================================================

need_command gpg need_command openssl need_command awk need_command mktemp

# ============================================================ # ENTSCHLÜSSELUNG # # Arg2 bzw. Arg3 muss exakt "d" sein. # # Die Algorithmusfolge wird ausschließlich aus dem Dateinamen # ermittelt. # ============================================================

if [[ "$MODE" == "d" ]]; then

# -------------------------------------------------------- # Die verschlüsselte Datei muss vorhanden sein. # --------------------------------------------------------

[[ -f "$FILE" ]] || die "Datei existiert nicht: $FILE"

# -------------------------------------------------------- # Algorithmusfolge aus Dateinamen extrahieren. # # Beispiel: # # geheim.txt.qm7 # # ergibt: # # ORIGINAL = geheim.txt # SEQUENCE = qm7 # # Die Endung darf 1 bis 6 Zeichen enthalten. # --------------------------------------------------------

if [[ "$FILE" =~ ^(.+)\.([qm7]{1,6})$ ]]; then

ORIGINAL="${BASH_REMATCH[1]}" SEQUENCE="${BASH_REMATCH[2]}"

else

die "Dateiname enthält keine gültige verschlüsselte Endung."

fi

# -------------------------------------------------------- # Algorithmusfolge prüfen. # --------------------------------------------------------

decode_sequence "$SEQUENCE"

# -------------------------------------------------------- # Zugehörige Hash-Datei # # geheim.txt.qm7.sha3_256 # --------------------------------------------------------

HASHFILE="${FILE}.sha3_256"

[[ -f "$HASHFILE" ]] || die "Hash-Datei fehlt: $HASHFILE"

# -------------------------------------------------------- # Erwarteten SHA3-256-Hash lesen. # --------------------------------------------------------

EXPECTED_HASH="$( awk 'NR == 1 {print $1}' "$HASHFILE" )"

[[ "$EXPECTED_HASH" =~ ^[0-9a-fA-F]{64}$ ]] || die "Ungültiger SHA3-256-Hash in $HASHFILE"

# -------------------------------------------------------- # Tatsächlichen SHA3-256-Hash der verschlüsselten Datei # berechnen. # --------------------------------------------------------

ACTUAL_HASH="$(sha3_256 "$FILE")"

# -------------------------------------------------------- # Hashvergleich VOR jeder Entschlüsselung. # --------------------------------------------------------

if [[ "$EXPECTED_HASH" != "$ACTUAL_HASH" ]]; then

die "HASH-FEHLER: Die verschlüsselte Datei wurde verändert oder beschädigt."

fi

echo "SHA3-256-Prüfung erfolgreich."

# -------------------------------------------------------- # Temporäres Arbeitsverzeichnis erzeugen. # --------------------------------------------------------

TMPDIR="$(mktemp -d)"

trap 'rm -rf -- "$TMPDIR"' EXIT

CURRENT="$PWD/$FILE"

# -------------------------------------------------------- # Entschlüsselung # # Wenn verschlüsselt wurde: # # AES -> CAMELLIA -> TWOFISH # # dann muss entschlüsselt werden: # # TWOFISH -> CAMELLIA -> AES # # Deshalb wird SEQUENCE rückwärts durchlaufen. # --------------------------------------------------------

for ((i=${#SEQUENCE}-1; i>=0; i--)); do

CHAR="${SEQUENCE:i:1}"

ALGORITHM="${ALG[$CHAR]}"

OUTPUT="$TMPDIR/stage_$i"

echo "Entschlüssele Schicht $(( ${#SEQUENCE} - i )): $CHAR"

gpg \ --batch \ --yes \ --pinentry-mode loopback \ --decrypt \ --output "$OUTPUT" \ "$CURRENT"

CURRENT="$OUTPUT"

done

# -------------------------------------------------------- # Das ursprüngliche Dateiname darf nicht versehentlich # überschrieben werden. # --------------------------------------------------------

if [[ -e "$ORIGINAL" ]]; then

die "Zieldatei existiert bereits: $ORIGINAL"

fi

# -------------------------------------------------------- # Entschlüsseltes Ergebnis an ursprünglichen Dateinamen # kopieren. # --------------------------------------------------------

cp -- "$CURRENT" "$ORIGINAL"

echo echo "Entschlüsselung erfolgreich:" echo " $ORIGINAL"

# ============================================================ # VERSCHLÜSSELUNG # # MODE ist hier NICHT "d". # # MODE muss deshalb eine Algorithmusfolge mit 1 bis 6 Zeichen # sein. # ============================================================

else

# -------------------------------------------------------- # Bei der Verschlüsselung ist Arg2/Arg3 die # Algorithmusfolge. # --------------------------------------------------------

SEQUENCE="$MODE"

# -------------------------------------------------------- # Algorithmusfolge prüfen. # --------------------------------------------------------

decode_sequence "$SEQUENCE"

# -------------------------------------------------------- # Quelldatei prüfen. # --------------------------------------------------------

[[ -f "$FILE" ]] || die "Datei existiert nicht: $FILE"

# -------------------------------------------------------- # Zieldatei erzeugen. # # Beispiel: # # geheim.txt # # wird zu: # # geheim.txt.qm7 # --------------------------------------------------------

OUTPUT="${FILE}.${SEQUENCE}"

# -------------------------------------------------------- # Hash-Datei: # # geheim.txt.qm7.sha3_256 # --------------------------------------------------------

HASHFILE="${OUTPUT}.sha3_256"

# -------------------------------------------------------- # Keine vorhandenen Dateien überschreiben. # --------------------------------------------------------

[[ ! -e "$OUTPUT" ]] || die "Zieldatei existiert bereits: $OUTPUT" [[ ! -e "$HASHFILE" ]] || die "Hash-Datei existiert bereits: $HASHFILE"

# -------------------------------------------------------- # Temporäres Arbeitsverzeichnis # --------------------------------------------------------

TMPDIR="$(mktemp -d)"

trap 'rm -rf -- "$TMPDIR"' EXIT

CURRENT="$PWD/$FILE"

# -------------------------------------------------------- # Verschlüsselung in der angegebenen Reihenfolge. # # Beispiel: # # qm7 # # bedeutet intern: # # AES256 # | # CAMELLIA256 # | # TWOFISH # --------------------------------------------------------

for ((i=0; i<${#SEQUENCE}; i++)); do

CHAR="${SEQUENCE:i:1}"

ALGORITHM="${ALG[$CHAR]}"

NEXT="$TMPDIR/stage_$i"

echo "Verschlüssele Schicht $((i + 1)): $CHAR"

gpg \ --batch \ --yes \ --pinentry-mode loopback \ --symmetric \ --cipher-algo "$ALGORITHM" \ --output "$NEXT" \ "$CURRENT"

CURRENT="$NEXT"

done

# -------------------------------------------------------- # Fertig verschlüsselten Inhalt an den endgültigen # Dateinamen kopieren. # --------------------------------------------------------

cp -- "$CURRENT" "$OUTPUT"

# -------------------------------------------------------- # SHA3-256 über den FERTIG verschlüsselten Inhalt bilden. # --------------------------------------------------------

HASH="$(sha3_256 "$OUTPUT")"

# -------------------------------------------------------- # Hash dauerhaft aufbewahren. # # Format: # # HASH DATEINAME # --------------------------------------------------------

printf '%s %s\n' \ "$HASH" \ "$(basename -- "$OUTPUT")" \ > "$HASHFILE"

# -------------------------------------------------------- # Ergebnis anzeigen. # --------------------------------------------------------

echo echo "Verschlüsselung erfolgreich:" echo " Datei : $OUTPUT" echo " Hash : $HASHFILE" echo " SHA3 : $HASH"

fi

Aufrufschema Damit ist die gewünschte Schnittstelle jetzt eindeutig:

Verschlüsselung: cryptbackup.sh DATEI ALGORITHMUSFOLGE

Entschlüsselung: cryptbackup.sh DATEI.ENDUNG d

bzw. mit Arbeitsverzeichnis:

Verschlüsselung: cryptbackup.sh ARBEITSVERZEICHNIS DATEI ALGORITHMUSFOLGE

Entschlüsselung: cryptbackup.sh ARBEITSVERZEICHNIS DATEI.ENDUNG d

Beispielsweise:

./cryptbackup.sh geheim.pdf qm7

erzeugt:

geheim.pdf.qm7 geheim.pdf.qm7.sha3_256

und:

./cryptbackup.sh geheim.pdf.qm7 d

liest qm7 automatisch aus dem Dateinamen, prüft zuerst den SHA3-256-Hash und entschlüsselt anschließend die drei Schichten in umgekehrter Reihenfolge. ==================================================================================================================