Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > de.sci.electronics > #369080
| From | Helmut Schellong <var@schellong.biz> |
|---|---|
| Newsgroups | de.sci.electronics |
| Subject | KI mit mittlerer Aufgabenstellung getestet - Bewertungen, Anmerkungen |
| Date | 2026-08-29 14:49 +0200 |
| Message-ID | <116ukgd$1abav$1@solani.org> (permalink) |
| References | (5 earlier) <slrn118tfb7.meqp.als@frodo.angband.thangorodrim.de> <116nh26$15on4$1@solani.org> <slrn11903hg.2luu.als@mordor.angband.thangorodrim.de> <116pdjm$16mei$1@solani.org> <slrn1190p4k.758o.als@mordor.angband.thangorodrim.de> |
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
Back to de.sci.electronics | Previous | Next — Previous in thread | Next in thread | Find similar | Unroll 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 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
csiph-web