ubuntuusers.de

Du betrachtest eine alte Revision dieser Wikiseite.

Gnupg

Dieser Artikel wurde für die folgenden Ubuntu-Versionen getestet:


Du möchtest den Artikel für eine weitere Ubuntu-Version testen? Mitarbeit im Wiki ist immer willkommen! Dazu sind die Hinweise zum Testen von Artikeln zu beachten.

Zum Verständnis dieses Artikels sind folgende Seiten hilfreich:

Nautilus/nautilus_logo.png Nachfolgend fünf GnuPG-Aktions-Skripe:

1. Symmetrisch verschlüsseln

2. Asymmetrisch verschlüsseln

3. Entschlüsseln

4. Signieren

5. Signatur verifizieren

6. Schlüsselpaar erzeugen

Installation

Die Voraussetzungen sollten bei einer Standardinstallation bereits erfüllt sein. Auf älteren Ubuntu-Versionen muss evtl. Zenity nachinstalliert werden. Die Skripte werden auf jeweils eigene Seiten kopiert und für einen Benutzer im Verzeichnis ~/.local/share/nautilus/scripts/ gespeichert. Sie müssen noch im Kontext-Eigenschaften-Menü oder im Terminal [1] ausführbar gemacht werden. Die Installation von Skripten für Nautilus ist auch im Artikel Nautilus/Skripte beschrieben.

Bedienung

Die per Rechtsklick im Dateimanager ausgewählte Datei wird über den Kontext-Menü-Eintrag „Skripte“ zu einer der GnuPG-Aktionen geführt. Man kann diese dort auch in einen Ordner, bspw. GPG genannt, legen, was übersichtlicher ist, aber einen Mausklick mehr bedeutet.

Symmetrisch verschlüsseln

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#!/bin/bash
#
# symmetrisch verschlüsseln - mit pgp Version 2.4.4 getestet
#
# Autor: harald - (UbuntuUsers.de), als Prompter eines GPAI (General Purpose AI)
# Lizenz: Public Domain
# Version vom 14.07.2025
#########################################################################

# Überprüfung ob mindestens eine Datei ausgewählt wurde
if [ $# -eq 0 ]; then
    zenity --error --text="Keine Datei ausgewählt."
    exit 1
fi

#Sicherstellen, dass zenity und gpg installiert sind
command -v gpg >/dev/null 2>&1 || { zenity --error --text="Gpg nicht gefunden"; exit 1; }
command -v zenity >/dev/null 2>&1 || { echo "Zenity nicht gefunden"; exit 1; }

for FILE in "$@"; do

    # Mit Zenity nach dem Passwort fragen und ein zweites Mal zur Bestätigung
    PASSPHRASE=$(zenity --password --title="Passwort für die symmetrische Verschlüsselung")
    [ $? -ne 0 ] && exit 1

    CONFIRM_PASSPHRASE=$(zenity --password --title="Passwort bestätigen")
    [ $? -ne 0 ] && exit 1

    if [ "$PASSPHRASE" != "$CONFIRM_PASSPHRASE" ]; then
        zenity --error --text="Die Passwörter stimmen nicht überein!"
        exit 1
    fi

    OUTPUT="${FILE}.gpg"

    # Symmetrisch verschlüsseln
    gpg --batch --yes --passphrase "$PASSPHRASE" --symmetric --cipher-algo AES256 -o "$OUTPUT" "$FILE"
    #rm -- "$FILE" (falls das Original gleich gelöscht werden soll)
    if [ $? -eq 0 ]; then
        notify-send "GPG Verschlüsselung" "Erfolgreich verschlüsselt: $FILE"
        zenity --info --text="Erfolgreich verschlüsselt:\n$OUTPUT"
    else
        notify-send "GPG Verschlüsselung" "Die Verschlüsselung für: $FILE hat nicht funktioniert!"
        zenity --error --text="Die Verschlüsselung für:\n$FILE hat nicht geklappt"
    fi

done

= Asymmetrisch verschlüsseln =

{{{#!code bash
#!/bin/bash
#
# asymmetrisch verschlüsseln - mit pgp Version 2.4.4 getestet
#
# Autor: harald - (UbuntuUsers.de), als Prompter eines GPAI (General Purpose AI)
# Lizenz: Public Domain
# Version vom 14.07.2025
#
# Check if at least one file is selected
if [ $# -eq 0 ]; then
    zenity --error --text="Keine Datei ausgewählt"
    exit 1
fi

#Sicherstellen, dass zenity und gpg installiert sind
command -v gpg >/dev/null 2>&1 || { zenity --error --text="Gpg nicht gefunden"; exit 1; }
command -v zenity >/dev/null 2>&1 || { echo "Zenity nicht gefunden"; exit 1; }

# Get the list of keys for selection
RECIPIENT=$(gpg --list-keys --with-colons | awk -F: '/^uid:/ {print $10}' | zenity --list --title="Empfänger auswählen" --column="Empfänger" --height=400)

if [ -z "$RECIPIENT" ]; then
    zenity --error --text="Kein Empfänger ausgewählt."
    exit 1
fi

for FILE in "$@"; do

    OUTPUT="${FILE}.asc"

    # Encrypt the file to the recipient
    #gpg --batch --yes --armor --encrypt --recipient "$RECIPIENT" -o "$OUTPUT" "$FILE" (Version für ASCII Ausgabe)
     gpg --batch --yes --encrypt --recipient "$RECIPIENT" -o "$OUTPUT" "$FILE" # (Binäre Ausgabe)
    #rm -- "$FILE" (falls das Original gleich gelöscht werden soll)
    if [ $? -eq 0 ]; then
        notify-send "GPG Verschlüsselung" "Erfolgreich verschlüsselt:\n$FILE"
        zenity --info --text="Erfolgreich verschlüsselt:\n$OUTPUT"
    else
        notify-send "GPG Verschlüsselung" "Die Verschlüsselung hat nicht funktioniert:\n$FILE"
        zenity --error --text="Die Verschlüsselung hat nicht funktioniert:\n$FILE"
    fi

done

Entschlüsseln

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#!/bin/bash
#
# entschlüsseln - mit pgp Version 2.4.4 getestet
#
# Autor: harald - (UbuntuUsers.de), als Prompter eines GPAI (General Purpose AI)
# Lizenz: Public Domain
# Version vom 14.07.2025

# Überprüfen ob eine Datei ausgewählt wurde
if [ $# -eq 0 ]; then
    zenity --error --text="Keine Datei ausgewählt."
    exit 1
fi

#Sicherstellen, dass zenity und gpg installiert sind
command -v gpg >/dev/null 2>&1 || { zenity --error --text="Gpg nicht gefunden"; exit 1; }
command -v zenity >/dev/null 2>&1 || { echo "Zenity nicht gefunden"; exit 1; }

for FILE in "$@"; do

    # Schlägt einen Dateinamen für die Ausgabe vor
    if [[ "$FILE" == *.gpg ]]; then
        OUTPUT="${FILE%.gpg}"
    elif [[ "$FILE" == *.asc ]]; then
        OUTPUT="${FILE%.asc}"
    else
        # Default Dateiendung
        OUTPUT="${FILE}.decrypted"
    fi

    # Benutzer auffordern, den Ausgabedateinamen zu bestätigen oder zu ändern
    OUTPUT=$(zenity --entry \
        --title="GPG Entschlüsseln" \
        --text="Name der Ausgabedatei eingeben:" \
        --entry-text="$OUTPUT")

    # Wenn der Benutzer abbricht, überspringe diese Datei
    if [ -z "$OUTPUT" ]; then
        zenity --warning --text="Entschlüsselung für $FILE abgebrochen"
        continue
    fi

    # Entschlüssle die Datei
    gpg --batch --yes -o "$OUTPUT" -d "$FILE"
    if [ $? -eq 0 ]; then
        notify-send "GPG Entschlüsselung" "Erfolgreich entschlüsselt:\n$FILE"
        zenity --info --text="Erfolgreich entschlüsselt:\n$OUTPUT"
    else
        notify-send "GPG Entschlüsselung" "Entschlüsselung fehlgeschlagen für:\n$FILE"
        zenity --error --text="Entschlüsselung fehlgeschlagen für:\n$FILE"
    fi

done

Signieren

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/bin/bash
#
# Signieren - mit pgp Version 2.4.4 getestet
#
# Autor: harald - (UbuntuUsers.de), als Prompter eines GPAI (General Purpose AI)
# Lizenz: Public Domain
# Version vom 8.07.2025

#Sicherstellen, dass zenity und gpg installiert sind
command -v gpg >/dev/null 2>&1 || { zenity --error --text="Gpg nicht gefunden"; exit 1; }
command -v zenity >/dev/null 2>&1 || { echo "Zenity nicht gefunden"; exit 1; }

# Schleife durch alle ausgewählten Dateien
for FILE in "$@"; do
  if [[ ! -f "$FILE" ]]; then
    zenity --error --text="Invalid file: $FILE"
    continue
  fi

# Den Benutzer bitten, die Unterzeichnung zu bestätigen
  SIGNER=$(gpg --list-secret-keys --with-colons | awk -F: '/^uid:/ {print $10}' | zenity --list --title="Schlüssel zum Unterschreiben auswählen" --column="GPG Key ID / UID" --height=300)
  if [[ -z "$SIGNER" ]]; then
    zenity --error --text="Nichts ausgewählt. Abbruch."
    exit 1
  fi

 # Dateiname der Ausgabesignatur festlegen
  SIG_FILE="${FILE}.asc"

  # Unterzeichnung durchführen
  OUTPUT=$(gpg --armor --local-user "$SIGNER" --output "$SIG_FILE" --detach-sign "$FILE" 2>&1)
  STATUS=$?

  if [[ $STATUS -eq 0 ]]; then
    zenity --info --title="GPG-Signatur erstellt" \
      --text="Signatur erfolgreich erstellt:\n\n$SIG_FILE"
  else
    zenity --error --title="GPG-Signierung fehlgeschlagen" \
      --width=400 --text="Beim Signieren ist ein Fehler aufgetreten:\n\n$OUTPUT"
  fi
done

Signatur verifizieren

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#!/bin/bash
#
# Signatur verifizieren - mit pgp Version 2.4.4 getestet
#
# Autor: harald - (UbuntuUsers.de), als Prompter eines GPAI (General Purpose AI)
# Lizenz: Public Domain
# Version vom 14.07.2025
#
# Holt die ausgewählte Datei aus Nautilus
FILE="$1"

# Prüfen, ob eine Datei ausgewählt wurde
if [[ -z "$FILE" ]]; then
  zenity --error --text="Keine Datei ausgewählt."
  exit 1
fi

#Sicherstellen, dass zenity und gpg installiert sind
command -v gpg >/dev/null 2>&1 || { zenity --error --text="Gpg nicht gefunden"; exit 1; }
command -v zenity >/dev/null 2>&1 || { echo "Zenity nicht gefunden"; exit 1; }

# Dateierweiterung prüfen
if [[ "$FILE" =~ \.asc$ || "$FILE" =~ \.sig$ ]]; then
  SIGNATURE_FILE="$FILE"
 # Versuche, die signierte Datei zu erraten, indem du .asc oder .sig entfernst
  SIGNED_FILE="${FILE%.asc}"
  SIGNED_FILE="${SIGNED_FILE%.sig}"

  # Nach der signierten Datei fragen, wenn sie nicht existiert
  if [[ ! -f "$SIGNED_FILE" ]]; then
    SIGNED_FILE=$(zenity --file-selection --title="Wähle die signierte Datei aus")
    if [[ -z "$SIGNED_FILE" || ! -f "$SIGNED_FILE" ]]; then
      zenity --error --text="Signierte Datei nicht ausgewählt oder nicht vorhanden."
      exit 1
    fi
  fi
else
  zenity --error --text="Bitte wähle eine .asc oder .sig Signaturdatei aus."
  exit 1
fi

# GPG-Prüfung durchführen und die gesamte Ausgabe aufzeichnen (stdout + stderr)

OUTPUT=$(gpg --verify "$SIGNATURE_FILE" "$SIGNED_FILE" 2>&1)

# Ausgabe im scrollbaren Zenity-Textinfodialog anzeigen
zenity --text-info \
  --title="Ergebnis der GPG-Prüfung" \
  --width=600 --height=400 \
  --filename=<(echo "$OUTPUT")

# Gibt den gleichen Exit-Code zurück wie gpg
exit $?

Schlüsselpaar erzeugen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#!/bin/bash
#
# Schlüsselpaar erzeugen - mit pgp Version 2.4.4 getestet
#
# Autor: harald - (UbuntuUsers.de), als Prompter eines GPAI (General Purpose AI)
# Lizenz: Public Domain
# Version vom 14.07.2025

# Name
NAME=$(zenity --entry --title="Neues GPG-Schlüsselpaar" --text="Vollständiger Name:")
[ $? -ne 0 ] && exit 0

# E-Mail
EMAIL=$(zenity --entry --title="Neues GPG-Schlüsselpaar" --text="E-Mail-Adresse:")
[ $? -ne 0 ] && exit 0

# Kommentar
COMMENT=$(zenity --entry --title="Neues GPG-Schlüsselpaar" --text="Kommentar (optional):")
[ $? -ne 0 ] && exit 0

# Schlüssellänge
KEYSIZE=$(zenity --list --radiolist \
    --title="Schlüssellänge wählen" \
    --text="Bitte die Schlüssellänge auswählen:" \
    --column="Ausgewählt" --column="Bits" \
    TRUE 2048 FALSE 3072 FALSE 4096)
[ $? -ne 0 ] && exit 0

# Gültigkeit
EXPIRE=$(zenity --entry --title="Neues GPG-Schlüsselpaar" --text="Gültigkeit (z. B. 0 = niemals, 1y = 1 Jahr):" --entry-text="0")
[ $? -ne 0 ] && exit 0

# Passphrase
PASSPHRASE=$(zenity --password --title="Neues GPG-Schlüsselpaar" --text="Passphrase für den privaten Schlüssel eingeben:")
[ $? -ne 0 ] && exit 0

# Prüfen auf leere Felder
if [[ -z "$NAME" || -z "$EMAIL" || -z "$KEYSIZE" || -z "$EXPIRE" || -z "$PASSPHRASE" ]]; then
    zenity --error --text="Alle Felder (außer Kommentar) müssen ausgefüllt sein."
    exit 1
fi

# User-ID zusammensetzen
USERID="$NAME"
if [ -n "$COMMENT" ]; then
    USERID="$USERID ($COMMENT)"
fi
USERID="$USERID <$EMAIL>"

# RSA-Schlüssel erzeugen
gpg --batch --pinentry-mode loopback --passphrase "$PASSPHRASE" \
    --quick-gen-key "$USERID" "rsa$KEYSIZE" sign,encrypt $EXPIRE

if [ $? -eq 0 ]; then
    zenity --info --text="Das GPG-RSA-Schlüsselpaar wurde erfolgreich erstellt."

    # Öffentlichen Schlüssel exportieren
    PUBFILE=$(zenity --file-selection --save --confirm-overwrite --title="Öffentlichen Schlüssel speichern als" --filename="${EMAIL}_pubkey.asc")
    if [ $? -eq 0 ]; then
        gpg --armor --export "$EMAIL" > "$PUBFILE"
        if [ $? -eq 0 ]; then
            zenity --info --text="Öffentlicher Schlüssel gespeichert:\n$PUBFILE"
        else
            zenity --error --text="Fehler beim Export des öffentlichen Schlüssels."
        fi
    fi
else
    zenity --error --text="Fehler beim Erzeugen des GPG-Schlüssels."
fi

Problembehebung

Prüfen, ob die Skripte ausführbar gemacht wurden. Die Skripte können noch verbessert bzw. angepasst werden. Bspw. gibt es noch eine Fehlermeldung, wenn schon eine .asc‑Datei vorhanden ist und man noch eine Signatur hinzufügen möchte.

Diese Revision wurde am 31. Juli 2025 10:36 von ubot erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Sicherheit, Kommunikation, Netzwerk, Ubuntu, Büro, Internet