Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > de.sci.electronics > #369013 > unrolled thread

ChatGPT mit mittlerer Aufgabenstellung getestet

Started byHelmut Schellong <var@schellong.biz>
First post2026-08-25 12:57 +0200
Last post2026-08-25 15:42 +0200
Articles 11 on this page of 31 — 9 participants

Back to article view | Back to de.sci.electronics

Contents

  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 Helmut Schellong <var@schellong.biz> - 2026-08-26 22:30 +0200
                    Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-27 12:17 +0200
                      Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-27 15:29 +0200
                        Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-27 18:19 +0200
                          Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-27 20:24 +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 Helmut Schellong <var@schellong.biz> - 2026-08-26 23:11 +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 Helmut Schellong <var@schellong.biz> - 2026-08-26 23:30 +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 Helmut Schellong <var@schellong.biz> - 2026-08-26 22:07 +0200
                Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-27 12:15 +0200
                  Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-27 15:20 +0200
                    Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-27 18:23 +0200
                      Re: ChatGPT mit mittlerer Aufgabenstellung getestet Helmut Schellong <var@schellong.biz> - 2026-08-27 21:38 +0200
                        Re: ChatGPT mit mittlerer Aufgabenstellung getestet Alexander Schreiber <als@usenet.thangorodrim.de> - 2026-08-28 21:57 +0200
                      KI mit mittlerer Aufgabenstellung getestet - Bewertungen, Anmerkungen Helmut Schellong <var@schellong.biz> - 2026-08-29 14:49 +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

Page 2 of 2 — ← Prev page 1 [2]

#369034

FromHelmut Schellong <var@schellong.biz>
Date2026-08-26 22:07 +0200
Message-ID<116nh26$15on4$1@solani.org>
In reply to#369025
Alexander Schreiber wrote on 26.08.2026 12:18:
> Helmut Schellong <var@schellong.biz> wrote:
>> Marc Haber wrote on 25.08.2026 20:48:
>>> Helmut Schellong <var@schellong.biz> wrote:
>>>> Manuel Reimer wrote on 25.08.2026 13:38:
>>>>> On 25.08.26 12:57, Helmut Schellong wrote:
>>>>>> Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung formuliert
>>>>>> und diese MS-Copilot vorgelegt:
>>>>>> [...]
>>>>>> Prinzipiell hat ChatGPT seine Aufgabe korrekt erfüllt.
>>>>>> [...]
>>>>>
>>>>> Was nun? Copilot oder ChatGPT? Das sind zwei verschiedene Paar Schuhe.
>>>>
>>>> Wikipedia:  "Copilot nutzt das Large Language Model GPT-5 von OpenAI"
>>>> Darauf kommt es mir an.
>>>
>>> Du bist doch immer vollständig logisch und korrekt. Warum schreibst Du
>>> dann ChatGPT; wenn Du doch ein ganz anderes Frontend benutzt hast, das
>>> GPT-5 als Backend benutzt?
>>
>> Hätte ChatGPT eine semantisch _andere_ Aufgaben-Lösung präsentiert, bei Nutzung
>> desselben Modells und desselben Herstellers?
>> Ich halte das (bei meiner Vorgabe) für ausgeschlossen.
> 
> Da spricht der Meister Aller Technologie! OpenAI sollte Dich dringend als CTO
> einstellen, bei Deinen tiefen Detailkenntnissen von LLMs.
> 
> Währenddessen in der Realität: Erfahrungsgemäss produzieren unterschiedliche
> Systeme auch unterschiedliche Resultate. Denn man hantiert nicht mit dem
> nackten Modell direkt, sondern mit der Infrastruktur drumherum (generell
> als harness ("Zaumzeug") bezeichnet) und diese macht u.a. Umschreiben und
> Filtern von Anfragen und Ergebnissen.

Ich merke, ich sollte mal 'Gleichheit der Resultate' definieren!

Das bedeutet nämlich, daß die beiden Skripte gleiche Arbeit verrichten.
Nicht, daß gleiche Byte-Anzahl und Byte-Gleichheit von Byte 0 bis Byte sz-1 vorliegen.
Da ich u.a. die Cipher nicht festlegte, können diese unterschiedlich gewählt werden.
Es kann auch unterschiedliche viele Fehlermeldungen geben - gar nicht festgelegt!
Unterschiede können allein durch unterschiedliche Generier-Zeitpunkte entstehen.
Etc.

Ich habe meinen Anforderungstext auf  chatgpt.com  eingegeben
und unten die Antwort einkopiert.
Sieht für mich im Überblick aus, als würde das Skript - gleiche Arbeit verrichten.

[...]
> Langer Rede kurzer Sinn: FreeBSD (und auch NetBSD, OpenBSD) und Linux sind
> de facto Unices. Es halt halt nur niemand Sinn darin gesehen, das Geld
> für eine offizielle Zertifizierung aus dem Fenster zu werfen.

Ich habe seit 1987 mit annähernd 10 verschiedenen Unix-Systemen gearbeitet.
Seit FreeBSD 3.1 eben fast nur mit FreeBSD.
Ich habe unter FreeBSD eine erkennbar unterschiedliche Dateimenge in /etc bemerkt.
Besonders gegenüber SystemV-Systemen.

Ich schätze, da wird was verwässert.


chatgpt.com
================================================================================================================================

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


-- 
Mit freundlichen Grüßen
Helmut Schellong

[toc] | [prev] | [next] | [standalone]

#369051

FromAlexander Schreiber <als@usenet.thangorodrim.de>
Date2026-08-27 12:15 +0200
Message-ID<slrn11903hg.2luu.als@mordor.angband.thangorodrim.de>
In reply to#369034
Helmut Schellong <var@schellong.biz> wrote:
> Alexander Schreiber wrote on 26.08.2026 12:18:
>> Helmut Schellong <var@schellong.biz> wrote:
>>> Marc Haber wrote on 25.08.2026 20:48:
>>>> Helmut Schellong <var@schellong.biz> wrote:
>>>>> Manuel Reimer wrote on 25.08.2026 13:38:
>>>>>> On 25.08.26 12:57, Helmut Schellong wrote:
>>>>>>> Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung formuliert
>>>>>>> und diese MS-Copilot vorgelegt:
>>>>>>> [...]
>>>>>>> Prinzipiell hat ChatGPT seine Aufgabe korrekt erfüllt.
>>>>>>> [...]
>>>>>>
>>>>>> Was nun? Copilot oder ChatGPT? Das sind zwei verschiedene Paar Schuhe.
>>>>>
>>>>> Wikipedia:  "Copilot nutzt das Large Language Model GPT-5 von OpenAI"
>>>>> Darauf kommt es mir an.
>>>>
>>>> Du bist doch immer vollständig logisch und korrekt. Warum schreibst Du
>>>> dann ChatGPT; wenn Du doch ein ganz anderes Frontend benutzt hast, das
>>>> GPT-5 als Backend benutzt?
>>>
>>> Hätte ChatGPT eine semantisch _andere_ Aufgaben-Lösung präsentiert, bei Nutzung
>>> desselben Modells und desselben Herstellers?
>>> Ich halte das (bei meiner Vorgabe) für ausgeschlossen.
>> 
>> Da spricht der Meister Aller Technologie! OpenAI sollte Dich dringend als CTO
>> einstellen, bei Deinen tiefen Detailkenntnissen von LLMs.
>> 
>> Währenddessen in der Realität: Erfahrungsgemäss produzieren unterschiedliche
>> Systeme auch unterschiedliche Resultate. Denn man hantiert nicht mit dem
>> nackten Modell direkt, sondern mit der Infrastruktur drumherum (generell
>> als harness ("Zaumzeug") bezeichnet) und diese macht u.a. Umschreiben und
>> Filtern von Anfragen und Ergebnissen.
>
> Ich merke, ich sollte mal 'Gleichheit der Resultate' definieren!
>
> Das bedeutet nämlich, daß die beiden Skripte gleiche Arbeit verrichten.
> Nicht, daß gleiche Byte-Anzahl und Byte-Gleichheit von Byte 0 bis Byte sz-1 vorliegen.
> Da ich u.a. die Cipher nicht festlegte, können diese unterschiedlich gewählt werden.
> Es kann auch unterschiedliche viele Fehlermeldungen geben - gar nicht festgelegt!
> Unterschiede können allein durch unterschiedliche Generier-Zeitpunkte entstehen.
> Etc.
>
> Ich habe meinen Anforderungstext auf  chatgpt.com  eingegeben
> und unten die Antwort einkopiert.
> Sieht für mich im Überblick aus, als würde das Skript - gleiche Arbeit verrichten.
>
> [...]
>> Langer Rede kurzer Sinn: FreeBSD (und auch NetBSD, OpenBSD) und Linux sind
>> de facto Unices. Es halt halt nur niemand Sinn darin gesehen, das Geld
>> für eine offizielle Zertifizierung aus dem Fenster zu werfen.
>
> Ich habe seit 1987 mit annähernd 10 verschiedenen Unix-Systemen gearbeitet.
> Seit FreeBSD 3.1 eben fast nur mit FreeBSD.
> Ich habe unter FreeBSD eine erkennbar unterschiedliche Dateimenge in /etc bemerkt.
> Besonders gegenüber SystemV-Systemen.
>
> Ich schätze, da wird was verwässert.

Bitte was? Du kommst auf ... sehr seltsame Metriken die beeindruckend
nichtssagend sind. Datenmenge in /etc hier bei verschiedenen Systemen:
8.4MB, 5.4MB, 17MB, 15MB, 45MB, 5.8MB, 11MB, 9MB, 4.7MB. Fünf verschiedene
Hardware-Plattformen, 2 verschiedene Unix-Systeme. Was sagen diese Zahlen?
Nichts brauchbares.

Und zu "verwässert": Unix SVR3 und FreeBSD sind ... sehr verschiedene
Systeme, schon weil da Jahrzehnte Entwicklung dazwischen liegen.

> chatgpt.com

Oh, oh ...

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

Was bitte soll dieser Unfug? Kryptographie verschlafen? Und wenn das
"der Verschleierung" dienen soll: Dir ist klar, das der verwendete
Algorithmus in der Ausgabedatei von gpg steht? Ansonsten: je nach
Angriffsszenario gilt https://xkcd.com/538/

Man liest sich,
             Alex.
-- 
"Opportunity is missed by most people because it is dressed in overalls and
 looks like work."                                      -- Thomas A. Edison

[toc] | [prev] | [next] | [standalone]

#369055

FromHelmut Schellong <var@schellong.biz>
Date2026-08-27 15:20 +0200
Message-ID<116pdjm$16mei$1@solani.org>
In reply to#369051
Alexander Schreiber wrote on 27.08.2026 12:15:
> Helmut Schellong <var@schellong.biz> wrote:
>> Alexander Schreiber wrote on 26.08.2026 12:18:
>>> Helmut Schellong <var@schellong.biz> wrote:
>>>> Marc Haber wrote on 25.08.2026 20:48:
>>>>> Helmut Schellong <var@schellong.biz> wrote:
>>>>>> Manuel Reimer wrote on 25.08.2026 13:38:
>>>>>>> On 25.08.26 12:57, Helmut Schellong wrote:
>>>>>>>> Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung formuliert
>>>>>>>> und diese MS-Copilot vorgelegt:
>>>>>>>> [...]
>>>>>>>> Prinzipiell hat ChatGPT seine Aufgabe korrekt erfüllt.
>>>>>>>> [...]
>>>>>>>
>>>>>>> Was nun? Copilot oder ChatGPT? Das sind zwei verschiedene Paar Schuhe.
>>>>>>
>>>>>> Wikipedia:  "Copilot nutzt das Large Language Model GPT-5 von OpenAI"
>>>>>> Darauf kommt es mir an.
>>>>>
>>>>> Du bist doch immer vollständig logisch und korrekt. Warum schreibst Du
>>>>> dann ChatGPT; wenn Du doch ein ganz anderes Frontend benutzt hast, das
>>>>> GPT-5 als Backend benutzt?
>>>>
>>>> Hätte ChatGPT eine semantisch _andere_ Aufgaben-Lösung präsentiert, bei Nutzung
>>>> desselben Modells und desselben Herstellers?
>>>> Ich halte das (bei meiner Vorgabe) für ausgeschlossen.
>>>
>>> Da spricht der Meister Aller Technologie! OpenAI sollte Dich dringend als CTO
>>> einstellen, bei Deinen tiefen Detailkenntnissen von LLMs.
>>>
>>> Währenddessen in der Realität: Erfahrungsgemäss produzieren unterschiedliche
>>> Systeme auch unterschiedliche Resultate. Denn man hantiert nicht mit dem
>>> nackten Modell direkt, sondern mit der Infrastruktur drumherum (generell
>>> als harness ("Zaumzeug") bezeichnet) und diese macht u.a. Umschreiben und
>>> Filtern von Anfragen und Ergebnissen.
>>
>> Ich merke, ich sollte mal 'Gleichheit der Resultate' definieren!
>>
>> Das bedeutet nämlich, daß die beiden Skripte gleiche Arbeit verrichten.
>> Nicht, daß gleiche Byte-Anzahl und Byte-Gleichheit von Byte 0 bis Byte sz-1 vorliegen.
>> Da ich u.a. die Cipher nicht festlegte, können diese unterschiedlich gewählt werden.
>> Es kann auch unterschiedliche viele Fehlermeldungen geben - gar nicht festgelegt!
>> Unterschiede können allein durch unterschiedliche Generier-Zeitpunkte entstehen.
>> Etc.
>>
>> Ich habe meinen Anforderungstext auf  chatgpt.com  eingegeben
>> und unten die Antwort einkopiert.
>> Sieht für mich im Überblick aus, als würde das Skript - gleiche Arbeit verrichten.
>>
>> [...]
>>> Langer Rede kurzer Sinn: FreeBSD (und auch NetBSD, OpenBSD) und Linux sind
>>> de facto Unices. Es halt halt nur niemand Sinn darin gesehen, das Geld
>>> für eine offizielle Zertifizierung aus dem Fenster zu werfen.
>>
>> Ich habe seit 1987 mit annähernd 10 verschiedenen Unix-Systemen gearbeitet.
>> Seit FreeBSD 3.1 eben fast nur mit FreeBSD.
>> Ich habe unter FreeBSD eine erkennbar unterschiedliche Dateimenge in /etc bemerkt.
>> Besonders gegenüber SystemV-Systemen.
>>
>> Ich schätze, da wird was verwässert.
> 
> Bitte was? Du kommst auf ... sehr seltsame Metriken die beeindruckend
> nichtssagend sind. Datenmenge in /etc hier bei verschiedenen Systemen:
> 8.4MB, 5.4MB, 17MB, 15MB, 45MB, 5.8MB, 11MB, 9MB, 4.7MB. Fünf verschiedene
> Hardware-Plattformen, 2 verschiedene Unix-Systeme. Was sagen diese Zahlen?
> Nichts brauchbares.

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.

> Und zu "verwässert": Unix SVR3 und FreeBSD sind ... sehr verschiedene
> Systeme, schon weil da Jahrzehnte Entwicklung dazwischen liegen.
> 
>> chatgpt.com
> 
> Oh, oh ...
> 
>> ================================================================================================================================
>>
>> #!/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.
> 
> Was bitte soll dieser Unfug? Kryptographie verschlafen? Und wenn das
> "der Verschleierung" dienen soll: Dir ist klar, das der verwendete
> Algorithmus in der Ausgabedatei von gpg steht? Ansonsten: je nach
> Angriffsszenario gilt https://xkcd.com/538/

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.


-- 
Mit freundlichen Grüßen
Helmut Schellong

[toc] | [prev] | [next] | [standalone]

#369062

FromAlexander Schreiber <als@usenet.thangorodrim.de>
Date2026-08-27 18:23 +0200
Message-ID<slrn1190p4k.758o.als@mordor.angband.thangorodrim.de>
In reply to#369055
Helmut Schellong <var@schellong.biz> wrote:
> Alexander Schreiber wrote on 27.08.2026 12:15:
>> Helmut Schellong <var@schellong.biz> wrote:
>>>
>>> Ich habe seit 1987 mit annähernd 10 verschiedenen Unix-Systemen gearbeitet.
>>> Seit FreeBSD 3.1 eben fast nur mit FreeBSD.
>>> Ich habe unter FreeBSD eine erkennbar unterschiedliche Dateimenge in /etc bemerkt.
>>> Besonders gegenüber SystemV-Systemen.
>>>
>>> Ich schätze, da wird was verwässert.
>> 
>> Bitte was? Du kommst auf ... sehr seltsame Metriken die beeindruckend
>> nichtssagend sind. Datenmenge in /etc hier bei verschiedenen Systemen:
>> 8.4MB, 5.4MB, 17MB, 15MB, 45MB, 5.8MB, 11MB, 9MB, 4.7MB. Fünf verschiedene
>> Hardware-Plattformen, 2 verschiedene Unix-Systeme. Was sagen diese Zahlen?
>> Nichts brauchbares.
>
> Welche Datenmenge?
> Ich sprach hingegen von Dateimenge.

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

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

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

>> Und zu "verwässert": Unix SVR3 und FreeBSD sind ... sehr verschiedene
>> Systeme, schon weil da Jahrzehnte Entwicklung dazwischen liegen.

Man liest sich,
             Alex.
-- 
"Opportunity is missed by most people because it is dressed in overalls and
 looks like work."                                      -- Thomas A. Edison

[toc] | [prev] | [next] | [standalone]

#369067

FromHelmut Schellong <var@schellong.biz>
Date2026-08-27 21:38 +0200
Message-ID<116q3nf$17hil$1@solani.org>
In reply to#369062
Alexander Schreiber wrote on 27.08.2026 18:23:
> Helmut Schellong <var@schellong.biz> wrote:
>> Alexander Schreiber wrote on 27.08.2026 12:15:
>>> Helmut Schellong <var@schellong.biz> wrote:
>>>>
>>>> Ich habe seit 1987 mit annähernd 10 verschiedenen Unix-Systemen gearbeitet.
>>>> Seit FreeBSD 3.1 eben fast nur mit FreeBSD.
>>>> Ich habe unter FreeBSD eine erkennbar unterschiedliche Dateimenge in /etc bemerkt.
>>>> Besonders gegenüber SystemV-Systemen.
>>>>
>>>> Ich schätze, da wird was verwässert.
>>>
>>> Bitte was? Du kommst auf ... sehr seltsame Metriken die beeindruckend
>>> nichtssagend sind. Datenmenge in /etc hier bei verschiedenen Systemen:
>>> 8.4MB, 5.4MB, 17MB, 15MB, 45MB, 5.8MB, 11MB, 9MB, 4.7MB. Fünf verschiedene
>>> Hardware-Plattformen, 2 verschiedene Unix-Systeme. Was sagen diese Zahlen?
>>> Nichts brauchbares.
>>
>> Welche Datenmenge?
>> Ich sprach hingegen von Dateimenge.
> 
> *seufz* Ok, mein Fehler, falsch gelesen. Immer noch eine .. nicht sehr
> sinnvolle Metrik.
> 
>> 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.
> 
> Siehe unten: FreeBSD ist kein SystemV und ausserhalb historischer Setups
> wirst Du auch kein aktuelles SystemV finden heutzutage.

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.

http://docsrv.sco.com/en/Navpages/index.html
http://docsrv.sco.com/cgi-bin/man?mansearchword=/usr/man2/html.ADM/mount.ADM.html&mansection=
http://docsrv.sco.com/cgi-bin/man?mansearchword=cc&mansection=&lang=de


-- 
Mit freundlichen Grüßen
Helmut Schellong

[toc] | [prev] | [next] | [standalone]

#369075

FromAlexander Schreiber <als@usenet.thangorodrim.de>
Date2026-08-28 21:57 +0200
Message-ID<slrn1193q1m.cs5b.als@frodo.angband.thangorodrim.de>
In reply to#369067
Helmut Schellong <var@schellong.biz> wrote:
> Alexander Schreiber wrote on 27.08.2026 18:23:
>> 
>> Siehe unten: FreeBSD ist kein SystemV und ausserhalb historischer Setups
>> wirst Du auch kein aktuelles SystemV finden heutzutage.
>
> Ich habe sie noch - habe sie aufgehoben, seit den 1980ern und 1990ern.

Fällt unter historisch. ;-)

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

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

> Die ersten C++ hatten den Code in C umgewandelt (mit sehr vielen Klammerpaaren) und
> kompilierten mittels C-Compiler.

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.

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

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

Man liest sich,
             Alex.
-- 
"Opportunity is missed by most people because it is dressed in overalls and
 looks like work."                                      -- Thomas A. Edison

[toc] | [prev] | [next] | [standalone]

#369080 — KI mit mittlerer Aufgabenstellung getestet - Bewertungen, Anmerkungen

FromHelmut Schellong <var@schellong.biz>
Date2026-08-29 14:49 +0200
SubjectKI mit mittlerer Aufgabenstellung getestet - Bewertungen, Anmerkungen
Message-ID<116ukgd$1abav$1@solani.org>
In reply to#369062
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:
http://osr507doc.xinuos.com/cgi-bin/man?mansearchword=ksh&mansection=C&lang=de





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


-- 
Mit freundlichen Grüßen
Helmut Schellong

[toc] | [prev] | [next] | [standalone]

#369015

FromLeo Baumann <ib@leobaumann.de>
Date2026-08-25 15:03 +0200
Message-ID<116k3qi$13agk$1@solani.org>
In reply to#369013
Am 25.08.2026 um 12:57 schrieb Helmut Schellong:
> Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung 
> formuliert
> und diese MS-Copilot vorgelegt:

Ich habe mal zum Test die Aufgabe ein Mathematica-Script zu erzeugen, 
dass aus dem Line-In der Soundkarte das DCF77-Signal zu dekodioeren.

Die Aufgabe wurde von ChatGPT gelöst, aber nur nach 10 Maligen 
zurücksetzen eins Lösungsvorschlage und Neuanforderung.

Fürchterlich!

www.leobaumann.de/DCF77-Dekodierung.pdf

:)

-- 
Public Webspace von Ingenieurbüro Baumann:
https://hidrive.ionos.com/share/sc0px3oy7x

[toc] | [prev] | [next] | [standalone]

#369019

FromHelmut Schellong <var@schellong.biz>
Date2026-08-25 15:43 +0200
Message-ID<116k65s$13cc9$1@solani.org>
In reply to#369015
Leo Baumann wrote on 25.08.2026 15:03:
> Am 25.08.2026 um 12:57 schrieb Helmut Schellong:
>> Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung formuliert
>> und diese MS-Copilot vorgelegt:
> 
> Ich habe mal zum Test die Aufgabe ein Mathematica-Script zu erzeugen, dass aus dem Line-In der Soundkarte das DCF77-Signal zu 
> dekodioeren.
> 
> Die Aufgabe wurde von ChatGPT gelöst, aber nur nach 10 Maligen zurücksetzen eins Lösungsvorschlage und Neuanforderung.
> 
> Fürchterlich!

Wir haben dann beide typische Nachteile einer KI kennengelernt.
Ich bemerke auch immer wieder, daß die KI nicht wirklich kreativ sein kann.


-- 
Mit freundlichen Grüßen
Helmut Schellong

[toc] | [prev] | [next] | [standalone]

#369024

FromHeinz Schmitz <sch@example.invalid>
Date2026-08-26 08:25 +0200
Message-ID<uj1t8lp4scqic0rb8tl4ssh173baajl8ek@4ax.com>
In reply to#369019
Helmut Schellong     wrote:

>> Fürchterlich!

>Wir haben dann beide typische Nachteile einer KI kennengelernt.
>Ich bemerke auch immer wieder, daß die KI nicht wirklich kreativ sein kann.

Das kommt vielleicht erst mit der bezahlten Profi-Version :-).
Oder auch nicht.

Grüße,
H.

[toc] | [prev] | [next] | [standalone]

#369020

FromAndreas Bockelmann <xotzil@gmx.de>
Date2026-08-25 15:42 +0200
Message-ID<748d1a7a6be17422b8612eff6f1a8966@wxp-nb-01.mouse.local>
In reply to#369015
Leo Baumann schrieb:
> Am 25.08.2026 um 12:57 schrieb Helmut Schellong:
>> Ich habe mal zum Test eine genaue und vollständige Aufgabenstellung 
>> formuliert
>> und diese MS-Copilot vorgelegt:
> 
> Ich habe mal zum Test die Aufgabe ein Mathematica-Script zu erzeugen, dass 
> aus dem Line-In der Soundkarte das DCF77-Signal zu dekodioeren.
> 
> Die Aufgabe wurde von ChatGPT gelöst, aber nur nach 10 Maligen zurücksetzen 
> eins Lösungsvorschlage und Neuanforderung.
> 
> Fürchterlich!
> 
> www.leobaumann.de/DCF77-Dekodierung.pdf
> 
> :)
> 

Ich kann ähnliches berichten: Im Carport habe ich einen in der Zeitfolge 
einstellbaren Eltako Treppenlichtautomaten gehabt, der auf Bewegungsmelder 3 
Minuten Licht m,achen sollte, auf Taster ebenfalls, aber auch 2 stundne 
Dauerlicht, wenn der Taster länger als 2 Sekunden festgehalten wird. Inkl. 
Bestätigungsflackern zum ein-und Ausschalten.

Der Eltako wich nun einem Shelly Pro2, weil ich vom Haus aus den 
Bewegungsmelder abschaltbar haben wollt, weil wegen Wind und Carportdach und 
Blechwand und dauernd Wiedereinschalten des Lichts. (mal flapsig ausgetdrückt)

Da ich keinerlei Ahnung von Jacascript habe und mich auhc gar nicht in 
Javascript und Shellyprogrammierung einarbeiten wollte, habe ich detailliert 
beschrieben was ich wollte. Das habe ich Gemini und ChatGPT zu fressen 
gegeben. Nach dem 10. Versuch bei Gemini habe ich aufgegeben, nach 10 
Versuchen hatte ChatGPT ein brauchbares Skript produziert, das nun seit 
einem knappen Jahr zufriedenstellend das macht was es soll.



-- 
  Mit freundlichen Grüßen
    Andreas Bockelmann

[toc] | [prev] | [standalone]

Page 2 of 2 — ← Prev page 1 [2]

Back to top | Article view | de.sci.electronics

csiph-web