ChatGPT mit mittlerer Aufgabenstellung getestet

From	Helmut Schellong <var@schellong.biz>
Newsgroups	de.sci.electronics
Subject	ChatGPT mit mittlerer Aufgabenstellung getestet
Date	2026-08-25 12:57 +0200
Message-ID	<116jsf2$134ai$1@solani.org> (permalink)

Show all headers | View raw

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


-- 
Mit freundlichen Grüßen
Helmut Schellong

Back to de.sci.electronics | Previous | Next — Next in thread | Find similar | Unroll thread

Thread

ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-25 12:57 +0200
  Re: ChatGPT mit mittlerer Aufgabenstellung getestet Manuel Reimer <manuel.nulldevice@nurfuerspam.de> - 2026-08-25 13:38 +0200
    Re: ChatGPT mit mittlerer Aufgabenstellung getestet Axel Berger <Spam@Berger-Odenthal.De> - 2026-08-25 15:06 +0200
      Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-25 15:40 +0200
    Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-25 15:27 +0200
      Re: ChatGPT mit mittlerer Aufgabenstellung getestet Marc Haber <mh+usenetspam2616@zugschl.us> - 2026-08-25 20:48 +0200
        Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-25 23:33 +0200
          Re: ChatGPT mit mittlerer Aufgabenstellung getestet Marc Haber <mh+usenetspam2616@zugschl.us> - 2026-08-26 07:56 +0200
            Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-26 18:27 +0200
              Re: ChatGPT mit mittlerer Aufgabenstellung getestet Marc Haber <mh+usenetspam2616@zugschl.us> - 2026-08-26 19:00 +0200
              Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-26 21:06 +0200
              Re: ChatGPT mit mittlerer Aufgabenstellung getestet Marte Schwarz <marte.schwarz@gmx.de> - 2026-08-26 21:21 +0200
          Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-26 12:18 +0200
  Re: ChatGPT mit mittlerer Aufgabenstellung getestet Leo Baumann <ib@leobaumann.de> - 2026-08-25 15:03 +0200
    Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-25 15:43 +0200
      Re: ChatGPT mit mittlerer Aufgabenstellung getestet Heinz Schmitz <sch@example.invalid> - 2026-08-26 08:25 +0200
    Re: ChatGPT mit mittlerer Aufgabenstellung getestet Andreas Bockelmann <xotzil@gmx.de> - 2026-08-25 15:42 +0200

csiph-web