GnuPG (Polski) - ArchWiki

Jump to content

# GnuPG (Polski)

From ArchWiki

This article or section needs to be translated.

Notes: No updates since 2019-01-24. (Discuss in Talk:GnuPG (Polski))

Według strony oficjalnej:

  GnuPG to pełna i darmowa implementacja OpenPGP standard zdefiniowany przez RFC4880 (znany również jako PGP). GnuPG pozwala na szyfrowanie i podpisywanie danych i komunikacji. Posiada wszechstronny system zarządzania kluczami, a także moduły dostępu do wszystkich rodzajów katalogów kluczy publicznych. GnuPG, znany również jako GPG, to narzędzie linii poleceń z funkcjami ułatwiającymi integrację z innymi aplikacjami. Dostępnych jest wiele aplikacji i bibliotek frontendowych. Wersja 2 GnuPG zapewnia także obsługę S/MIME i Secure Shell (ssh).

## Instalacja

Zainstaluj paczkę gnupg.

To również zainstaluje pinentry, kolekcję prostych okienek do wpisywania PINów oraz haseł które GnuPG używa do wprowadzania. Które z okienek dialogowych od pinentry zostanie użyte, jest determinowane przez symboliczny link `/usr/bin/pinentry`, który domyślnie wskazuje `/usr/bin/pinentry-gtk-2`.

Jeśli chcesz używać graficznego interfejsu, lub programu który integruje się z GnuPG, zobacz List of applications/Security#Encryption, signing, steganography.

## Konfiguracja

### Lokalizacja katalogu

`$GNUPGHOME` jest używany przez GnuPG do wskazywania katalogu, w którym przechowywane są jego pliki konfiguracyjne. Domyślnie `$GNUPGHOME`nie jest ustawione i twoje `$HOME` jest używany zamiast; w ten sposób znajdziesz `~/.gnupg` katalog zaraz po instalacji.

Aby zmienić domyślną lokalizację, uruchom gpg w ten sposób `$ gpg --homedir path/to/file` lub ustaw `GNUPGHOME` environment variable.

### Pliki konfiguracyjne

Domyślne pliki konfiguracyjne to `~/.gnupg/gpg.conf` i `~/.gnupg/dirmngr.conf`.

Domyślnie katalog gnupg ma ustawione uprawnienia do `700` , a pliki, które zawiera, mają ustawione uprawnienia do `600`. Tylko właściciel katalogu ma uprawnienia do odczytu, zapisu i uzyskiwania dostępu do plików. Jest to ze względów bezpieczeństwa i nie należy go zmieniać. W przypadku, gdy ten katalog lub jakikolwiek inny plik wewnątrz niego nie jest zgodny z tą miarą bezpieczeństwa, otrzymasz ostrzeżenia o niebezpiecznych uprawnieniach do plików i katalogu domowego.

Dołącz do tych plików dowolne długie opcje, które chcesz. Nie zapisuj dwóch kresek, ale po prostu nazwę opcji i wymagane argumenty. Znajdziesz pliki szkieletów w `/usr/share/gnupg`. Pliki te są kopiowane do `~/.gnupg` przy pierwszym uruchomieniu gpg, jeśli tam nie istnieją. Inne przykłady można znaleźć w #Zobacz też.

Dodatkowo pacman używa innego zestawu plików konfiguracyjnych do weryfikacji podpisów paczek. Zobacz Pacman/Package signing dla szczegółów.

### Domyślne opcje dla nowych użytkowników

Jeśli chcesz ustawić domyślne opcje dla nowych użytkowników, umieść pliki konfiguracyjne w `/etc/skel/.gnupg/`. Po dodaniu nowego użytkownika w systemie pliki z tego katalogu zostaną skopiowane do katalogu domowego GnuPG. Istnieje również prosty skrypt o nazwie "addgnupghome", który można wykorzystać do stworzenia nowych katalogów domowych GnuPG dla istniejących użytkowników:

    # addgnupghome user1 user2

To doda odpowiednie `/home/user1/.gnupg` i `/home/user2/.gnupg` i skopiuj do niego pliki z katalogu szkieletu. Użytkownicy z istniejącym katalogiem macierzystym GnuPG są po prostu pomijani.

## Używanie

Note Kiedy `user-id` jest wymagany w poleceniu, można go określić za pomocą identyfikatora klucza, odcisku palca, części imienia i nazwiska lub adresu e-mail itp. GnuPG jest elastyczny w tym zakresie..

### Utwórz parę kluczy

Wygeneruj parę kluczy, wpisując w terminalu:

    $ gpg --full-gen-key

Tip Użyj `--expert` możliwość uzyskania alternatywnych szyfrów ECC.

Polecenie spowoduje wyświetlenie odpowiedzi na kilka pytań. Do ogólnego użytku większość ludzi będzie chciała:

- klucz RSA (tylko podpis) i klucz RSA (tylko szyfrowanie).
- klucz do domyślnej wartości (2048). Większy klucz 4096 "daje nam prawie nic, a kosztuje nas sporo"[1].
- data wygaśnięcia. Okres roku jest wystarczająco dobry dla przeciętnego użytkownika. W ten sposób, nawet jeśli dojdzie do utraty dostępu do kluczy, pozwoli to innym dowiedzieć się, że nie jest już ważny. Później, jeśli to konieczne, data wygaśnięcia może zostać przedłużona bez konieczności ponownego wydania nowego klucza.
- twoje imię i adres e-mail. Możesz dodać wiele tożsamości do tego samego klucza później (" ', jeśli masz wiele adresów e-mail, które chcesz powiązać z tym kluczem).
- 'komentarz "nie". Ponieważ semantyka pola komentarza to not well-defined, ma ograniczoną wartość do identyfikacji.
- a secure passphrase.

Note Nazwa i adres e-mail, który tu wpiszesz, będą widoczne dla każdego, kto importuje twój klucz.

### Lista kluczy

Aby wyświetlić listę kluczy w swoim publicznym key ring:

    $ gpg --list-keys

Aby wyświetlić sekretną listę kluczy key ring:

    $ gpg --list-secret-keys

### Wyeksportuj swój klucz publiczny

Głównym zastosowaniem gpg jest zapewnienie poufności wymienianych wiadomości za pośrednictwem kryptografii z kluczem publicznym. Dzięki niemu każdy użytkownik dystrybuuje klucz publiczny swojego klucza, który może być używany przez innych do szyfrowania wiadomości do użytkownika. Klucz prywatny musi być zawsze "prywatny", w przeciwnym razie dochodzi do złamania poufności. Zobacz w w:Public-key cryptography przykłady wymiany wiadomości.

Tak więc, aby inni mogli wysyłać zaszyfrowane wiadomości, potrzebują Twojego publicznego klucza.

By wygenerować wersję ASCII klucza publicznego do pliku `public.key` (np. do dystrybucji poprzez e-mail):

    $ gpg --output public.key --armor --export user-id

Alternatywnie lub dodatkowo możesz zobaczyć sekcję #Użyj serwera kluczy by podzielić się swoim kluczem.

Tip Dodaj `--no-emit-version` aby uniknąć drukowania numeru wersji lub dodać odpowiednie ustawienie do pliku konfiguracyjnego.

### Zaimportuj klucz publiczny

Aby szyfrować wiadomości innym osobom, a także weryfikować ich podpisy, potrzebujesz ich klucza publicznego. Aby zaimportować klucz publiczny z nazwą pliku `public.key` do twojego publicznego breloczka

    $ gpg --import public.key

Alternatywnie, #Użyj serwera kluczy aby znaleźć klucz publiczny.

### Użyj serwera kluczy

Możesz zarejestrować swój klucz za pomocą publicznego serwera kluczy PGP, aby inni mogli odzyskać klucz bez konieczności bezpośredniego kontaktu z Tobą:

    $ gpg --send-keys user-id

Warning Po przesłaniu klucza do serwera kluczy nie można go usunąć z serwera.[2]

Aby poznać szczegóły klucza na serwerze kluczy, bez importowania go, wykonaj następujące czynności:

    $ gpg --search-keys user-id

Aby zaimportować klucz z serwera kluczy:

    $ gpg --recv-keys key-id

Warning

- Powinieneś zweryfikować autentyczność pobranego klucza publicznego, porównując jego odcisk palca z tym, który właściciel opublikował w niezależnym źródle (np. Kontaktując się bezpośrednio z osobą). Zobacz Wikipedia:Public key fingerprint po więcej informacji.
- Używanie krótkiego ID może napotkać na kolizje. Wszystkie klucze zostaną zaimportowane z krótkim identyfikatorem. Aby tego uniknąć, należy użyć pełnego identyfikatora odcisku palca lub długiego identyfikatora klucza podczas odbierania klucza. [3]

Tip

- Dodanie `keyserver-options auto-key-retrieve` do `gpg.conf` automatycznie pobierze klucze z serwera kluczy w razie potrzeby.
- Alternatywny serwer kluczy to `pool.sks-keyservers.net` i można go określić za pomocą `keyserver` w `dirmngr.conf`; Zobacz też wikipedia:Key server (cryptographic)#Keyserver examples.
- Jeśli twoja sieć blokuje porty używane dla hkp / hkps, być może musisz podać port 80, tzn. `pool.sks-keyservers.net:80`
- Możesz połączyć się z serwerem kluczy przez Tor używając `--use-tor`. Zobacz GnuPG blog post po więcej informacji.
- Możesz połączyć się z serwerem kluczy za pomocą serwera proxy, ustawiając opcję `http_proxy` Zmienna i ustawienie środowiska `honor-http-proxy` w `dirmngr.conf`. Ewentualnie ustaw `http-proxy host[:port]` w `dirmngr.conf`, przesłonięte `http_proxy`Zmienna środowiskowa.
- Jeśli chcesz zaimportować identyfikator klucza, aby zainstalować konkretny pakiet Arch Linux, Zobacz pacman/Package signing#Managing the keyring i Makepkg#Signature checking.

### Szyfrowanie i odszyfrowanie

#### Asymetryczne

Musisz zaimportować klucz publiczny użytkownika przed szyfrowaniem (opcje `--encrypt` or `-e`) pliku lub wiadomości do danego odbiorcy (opcje `--recipient` or `-r`). Dodatkowo musisz Utworzyć parę kluczy jeśli jeszcze tego nie zrobiłeś.

Aby zaszyfrować plik o nazwie "doc", użyj:

    $ gpg --recipient user-id --encrypt doc

Aby odszyfrować (opcja `--decrypt` lub `-d`) zaszyfrowany kluczem publicznym plik o nazwie doc .gpg za pomocą klucza prywatnego, użyj:

    $ gpg --output doc --decrypt doc.gpg

gpg poprosi cię o podanie hasła, a następnie odszyfruje i zapisze dane z doc . gpg do doc . Jeśli pominiesz `-o` (`--output`) opcje, gpg zapisze odszyfrowane dane na standardowe wyjście.

Tip

- Dodaj `--armor` zaszyfrować plik przy użyciu zbroi ASCII (nadaje się do kopiowania i wklejania wiadomości w formacie tekstowym)
- Używająć `-R user-id` lub `--hidden-recipient user-id` zamiast `-r` nie umieszczać identyfikatorów kluczy odbiorców w zaszyfrowanej wiadomości. Pomaga to ukryć odbiorców wiadomości i stanowi ograniczony środek zaradczy przeciwko analizie ruchu.
- Dodaj `--no-emit-version` aby uniknąć drukowania numeru wersji lub dodać odpowiednie ustawienie do pliku konfiguracyjnego.
- Możesz użyć gnupg do zaszyfrowania poufnych dokumentów za pomocą własnego identyfikatora użytkownika jako odbiorcy lub używając `--default-recipient-self` zamiast tego flaga; można jednak wykonać tylko ten jeden plik naraz, chociaż zawsze można zarchiwizować różne pliki, a następnie zaszyfrować plik tar. Zobacz też Disk encryption#Available methods jeśli chcesz zaszyfrować katalogi lub cały system plików.

#### Symetryczne

Szyfrowanie symetryczne nie wymaga generowania pary kluczy i może być używane do prostego szyfrowania danych za pomocą hasła. Po prostu użyj `--symmetric` lub `-c` aby wykonać szyfrowanie symetryczne:

    $ gpg -c doc

Poniższy przykład:

- Szyfruje `doc` z symetrycznym szyfrem za pomocą hasła
- Używa algorytmu szyfrowania AES-256 do szyfrowania hasła
- Korzysta z algorytmu skrótu SHA-512, aby pomieszać hasło
- Miesza hasło 65536 razy

    $ gpg -c --s2k-cipher-algo AES256 --s2k-digest-algo SHA512 --s2k-count 65536 doc

Aby odszyfrować symetrycznie zaszyfrowany `doc.gpg` za pomocą hasła i wypakować odszyfrowane treści do tego samego katalogu, co `doc`:

    $ gpg --output doc --decrypt doc.gpg

## Konserwacja kluczy

### Zrób kopię swojego klucza prywatnego

Aby wykonać kopię zapasową klucza prywatnego, wykonaj następujące czynności:

    $ gpg --export-secret-keys --armor <user-id> > privkey.asc

Zwróć uwagę, że "gpg" wersja 2.1 zmieniła domyślne zachowanie, więc powyższe polecenie wymusza ochronę hasłem, nawet jeśli świadomie zdecydowałeś się nie używać go przy tworzeniu klucza. Jest tak, ponieważ w przeciwnym razie każdy, kto uzyska dostęp do powyższego wyeksportowanego pliku, będzie mógł szyfrować i podpisywać dokumenty tak, jakby były "bez", które wymagają znajomości hasła.

Warning Hasło jest zwykle najsłabszym ogniwem chroniącym twój tajny klucz. Umieść klucz prywatny w bezpiecznym miejscu w innym systemie / urządzeniu, takim jak zamknięty pojemnik lub zaszyfrowany dysk. Jest to jedyne bezpieczeństwo, które musisz odzyskać na swoim kluczyku w przypadku, na przykład, awarii napędu, kradzieży lub gorszych.

Aby zaimportować kopię zapasową klucza prywatnego:

    $ gpg --import privkey.asc

### Zrób kopię certyfikatu unieważniającego

Certyfikaty unieważniające są generowane automatycznie dla nowo wygenerowanych kluczy. One domyślnie są usytuowane w `~/.gnupg/openpgp-revocs.d/`. Nazwa pliku tego certyfikatu jest odciskiem palca klucza, którego unieważnia. Certyfikat unieważniający może zostać również ręcznie wygenerowany przez użytkownika użwywając:

    $ gpg --gen-revoke --armor --output revcert.asc user-id

Ten certyfikat może zostać wykorzystany do Unieważnienia klucza[broken link: invalid section], jeśli ten zostanie kiedyś zgubiony lub skompromitowany. Kopia zapasowa jest dlatego właśnie ważna, ponieważ gdy stracimy dostęp do prywatnego klucza, nie będziemy w stanie już później wygenerować takiego certyfikatu, jak za pomocą wyżej wymienionej komendy. Jest on na tyle krótki, aby został wydrukowany i wpisany ręcznie, gdy zajdzie taka potrzeba.

Warning Każdy z dostępem do takiego certyfikatu może unieważnić klucz publicznie, a tego już nie można odwrócić. Strzeż swoich certyfikatów tak jak strzeżesz swoich kluczy.

### Edytuj swój klucz

Uruchomienie polecenia `gpg --edit-key <user-id>` wyświetli menu, które pozwoli ci wykonać większość kluczowych zadań związanych z zarządzaniem.

Kilka przydatnych poleceń w podmenu edycji kluczy:

    > passwd       # change the passphrase
    > clean        # compact any user ID that is no longer usable (e.g revoked or expired)
    > revkey       # revoke a key
    > addkey       # add a subkey to this key
    > expire       # change the key expiration time

Typ `help` w podmenu edycji kluczy, aby uzyskać więcej poleceń.

Tip Jeśli masz wiele kont e-mail, możesz dodać każdą z nich jako tożsamość, używając `adduid` komenda. Możesz wtedy ustawić swój ulubiony jako `primary`.

### Eksportowanie podklucza

Jeśli zamierzasz używać tego samego klucza na wielu urządzeniach, możesz usunąć klucz główny i przechowywać tylko minimalny podklucz szyfrowany na mniej bezpiecznych systemach.

Najpierw sprawdź, który podklucz chcesz wyeksportować.

    $ gpg -K

Wybierz tylko ten podklucz do eksportu.

    $ gpg -a --export-secret-subkeys [subkey id]! > /tmp/subkey.gpg

Warning Jeśli zapomnisz dodać !, wszystkie twoje podklucze zostaną wyeksportowane.

W tym momencie możesz przestać, ale najprawdopodobniej dobrze jest również zmienić hasło. Zaimportuj klucz do folderu tymczasowego.

    $ gpg --homedir /tmp/gpg --import /tmp/subkey.gpg
    $ gpg --homedir /tmp/gpg --edit-key <user-id>
    > passwd
    > save
    $ gpg --homedir /tmp/gpg -a --export-secret-subkeys [subkey id]! > /tmp/subkey.altpass.gpg

Note Otrzymasz ostrzeżenie, że klucz główny nie był dostępny, a hasło nie zostało zmienione, ale można je bezpiecznie zignorować, tak jak hasło podklucza.

W tym momencie możesz teraz użyć `/tmp/subkey.altpass.gpg` na innych urządzeniach.

### Rotacja podkluczy

Warning Nigdy nie usuwaj wygasłych lub cofniętych podkluczów, chyba że masz dobry powód. Spowoduje to utratę możliwości odszyfrowywania plików zaszyfrowanych przy użyciu starego podklucza. Usuwaj tylko klucze wygasłe lub unieważnione od innych użytkowników w celu wyczyszczenia kluczy.

Jeśli ustawiłeś podklucze, aby wygasły po określonym czasie, możesz utworzyć nowe. Zrób to z kilkutygodniowym wyprzedzeniem, aby inni mogli zaktualizować swoją bazę kluczy.

Tip Nie musisz tworzyć nowego klucza tylko dlatego, że wygasł. Możesz przedłużyć datę wygaśnięcia.

Utwórz nowy podklucz (powtórz dla podpisu i klucza szyfrowania)

    $ gpg --edit-key <user-id>
    > addkey

I odpowiedz na następujące pytania, które prosi (patrz#Utwórz parę kluczy dla sugerowanych ustawień).

Zapisz zmiany

    > save

Zaktualizuj go do serwera kluczy.

    $ gpg --keyserver pgp.mit.edu --send-keys <user-id>

Tip Odwołanie wygasłych podkluczy jest niepotrzebną i prawdopodobnie złą formą. Jeśli stale odnawiasz klucze, może to spowodować, że inni nie będą mieli do ciebie zaufania.

### Unieważnij klucz

Unieważnienie klucza powinno się wykonać gdy klucz zostanie skompromitowany, zastąpiony, jest już nieużywany lub gdy zapomnisz do niego swojego hasła. Wykonuje się to scalając klucz z certyfikatem unieważnienia.

Jeśli już nie masz dostępu do swojej pary kluczy, wpierw #Zaimportuj klucz publiczny by zaimportować własny klucz. Wtedy, by unieważnić swój klucz, zaimportuj plik zapisany w #Zrób kopię certyfikatu unieważniającego:

    $ gpg --import revcert.asc

Teraz uniważnienie musi zostać upublicznione. #Użyj serwera kluczy by wysłać swój unieważniony klucz do serwera PGP jeśli takiego wcześniej użyłeś, w przeciwnym razie, eksportuj unieważniony klucz do pliku i roześlij do osób z którymi się komunikujesz.

## Podpisy

Podpisy potwierdzają i znakują czasowo dokumenty. Jeśli dokument zostanie zmodyfikowany, weryfikacja podpisu nie powiedzie się. W przeciwieństwie do szyfrowania, które wykorzystuje klucze publiczne do szyfrowania dokumentu, podpisy tworzone są za pomocą klucza prywatnego. Odbiorca podpisanego dokumentu sprawdza następnie podpis za pomocą klucza publicznego nadawcy.

### Utwórz podpis

#### Zarejestruj plik

Aby podpisać plik, użyj `--sign` lub `-s` flaga:

     $ gpg --output doc.sig --sign doc

`doc.sig` zawiera zarówno skompresowaną zawartość oryginalnego pliku `doc`, jak i podpis w formacie binarnym, ale plik nie jest zaszyfrowany. możesz łączyć podpisywanie z szyfrowaniem

#### Clearsign a file or message

Aby podpisać plik bez kompresowania go do formatu binarnego użyj:

     $ gpg --output doc.sig --clearsign doc

Tutaj zarówno zawartość oryginalnej dokumentacji `doc`, jak i podpis są przechowywane w formie czytelnej dla człowieka w pliku `doc.sig`.

#### Utwórz oddzielny podpis

Aby utworzyć oddzielny plik podpisu, który ma być dystrybuowany oddzielnie od samego dokumentu lub pliku, użyj flagi `--detach-sig`

     $ gpg --output doc.sig --detach-sig doc

Tutaj podpis jest przechowywany w `doc.sig`, ale zawartość `doc` nie jest w nim zapisana. Ta metoda jest często używana w dystrybucji oprogramowania, aby umożliwić użytkownikom sprawdzenie, czy program nie został zmodyfikowany przez stronę trzecią.

### Zweryfikuj podpis

Aby zweryfikować podpis, użyj flagi `--verify`

     $ gpg --verify doc.sig

gdzie `doc.sig` to podpisany plik zawierający podpis, który chcesz zweryfikować.

Jeśli sprawdzasz odłączony podpis, zarówno podpisany plik danych, jak i plik podpisu muszą być obecne podczas weryfikacji. Na przykład, aby sprawdzić najnowszą wersję iso Arch Linux, wykonaj:

     $ gpg --verify archlinux-version.iso.sig

gdzie `archlinux-version.iso` musi znajdować się w tym samym katalogu.

Można również określić podpisany plik danych z drugim argumentem:

     $ gpg --verify archlinux-version.iso.sig /path/to/archlinux-version.iso

Jeśli plik został zaszyfrowany, oprócz podpisu, po prostu odszyfruje plik i jego podpis również zostaną zweryfikowane.

## gpg-agent

gpg-agent jest najczęściej używany jako demon do żądania i buforowania hasła dla pęku kluczy. Jest to przydatne, jeśli GnuPG jest używany z zewnętrznego programu, takiego jak klient poczty gnupg przychodzi z systemd user gniazda, które są domyślnie włączone. Te gniazda są `gpg-agent.socket`, `gpg-agent-extra.socket`, `gpg-agent-browser.socket`, `gpg-agent-ssh.socket`, i `dirmngr.socket`.

This article or section needs expansion.

Reason: Add `gpg-agent-browser.socket` to the list. (Discuss in Talk:GnuPG (Polski))

- Główny `gpg-agent.socket` jest używany przez gpg do łączenia się z demonem gpg-agent.
- Celem użycia `gpg-agent-extra.socket` w systemie lokalnym jest skonfigurowanie przekazywania domeny unixowej z systemu zdalnego. Umożliwia to używanie gpg w systemie zdalnym bez narażania kluczy prywatnych w systemie zdalnym. Aby uzyskać szczegółowe informacje, patrz gpg-agent(1).
- `gpg-agent-ssh.socket` może być używany przez SSH do buforowania kluczy SSH dodanych przez program ssh-add. Zobacz #SSH agent dla potrzebnej konfiguracji.
- `dirmngr.socket` uruchamia demona GnuPG obsługującego połączenia z serwerami kluczy.

Note Jeśli używasz innej niż domyślna lokalizacji GnuPG #Lokalizacja katalogu, będziesz musiał edytować wszystkie pliki gniazd, aby użyć wartości `gpgconf --list-dirs`.

### Konfiguracja

gpg-agent można skonfigurować za pomocą pliku `~/.gnupg/gpg-agent.conf`. Opcje konfiguracji są wymienione w gpg-agent(1). Na przykład możesz zmienić podręczne cache dla nieużywanych kluczy:

    ~/.gnupg/gpg-agent.conf

    default-cache-ttl 3600

Tip Aby zapisać w pamięci podręcznej hasło dla całej sesji, uruchom następujące polecenie:

    $ /usr/lib/gnupg/gpg-preset-passphrase --preset XXXXXX

gdzie XXXX jest kluczem. Możesz uzyskać jego wartość podczas uruchamiania `gpg --with-keygrip -K`. Hasło zostanie zapisane, dopóki `gpg-agent` nie zostanie zrestartowany. Jeśli ustawisz wartość `default-cache-ttl`, będzie ona miała pierwszeństwo.

### Załaduj ponownie agenta

Po zmianie konfiguracji, ponownie załaduj agenta za pomocą gpg-connect-agent:

    $ gpg-connect-agent reloadagent /bye

Polecenie powinno wyświetlić `OK`.

Jednak w niektórych przypadkach tylko ponowne uruchomienie może nie być wystarczające, np. Gdy `keep-screen` został dodany do konfiguracji agenta. W takim przypadku najpierw musisz zabić trwający proces gpg-agent, a następnie możesz go ponownie uruchomić, jak wyjaśniono powyżej.

### pinentry

Wreszcie, agent musi wiedzieć, jak poprosić użytkownika o hasło. Można to ustawić w pliku konfiguracyjnym gpg-agent.

Domyślne używa okna dialogowego gtk. Dostępne są inne opcje - patrz informacja o pinentry. Aby zmienić konfigurację okna dialogowego, ustaw konfigurację programu `pinentry-program`:

    ~/.gnupg/gpg-agent.conf

    # PIN entry program
    # pinentry-program /usr/bin/pinentry-curses
    # pinentry-program /usr/bin/pinentry-qt
    # pinentry-program /usr/bin/pinentry-kwallet

    pinentry-program /usr/bin/pinentry-gtk-2

Jest wiele innych programów pinentry które można wybrać w powyższym - zobacz `pacman -Ql pinentry | grep /usr/bin/`.

Tip

- Programy pinentry `/usr/bin/pinentry-gnome3` (GNOME), `/usr/bin/pinentry-qt`, `/usr/bin/pinentry-qt5` oraz `/usr/bin/pinentry-gtk` (ogólny) [4] obsługują API DBus Secret Service, co umożliwia zapamiętywanie haseł za pomocą zgodnego menedżera, takiego jak GNOME Keyring, KeePassXC lub KDE Wallet.
- Aby użyć `/usr/bin/pinentry-kwallet`, musisz zainstalować pakiet kwalletcliAUR.

Note Podczas korzystania z KDE integracja z API Secret Service jest domyślnie wyłączona, aby zapobiec zakleszczeniu w przypadku, gdy KDE Wallet używa szyfrowania GnuPG. Jeżeli korzystasz z KDE Wallet w trybie klasycznym, tj. z plikiem szyfrowanym algorytmem Blowfish, możesz ponownie włączyć integrację z API Secret Service, ustawiając zmienną środowiskową `PINENTRY_KDE_USE_WALLET` na niepustą wartość. Jeżeli zainstalowałeś KDE z pakietów meta lub grup pakietów, prawdopodobnie masz już zainstalowany pakiet kwallet-pam; w takim przypadku twój KDE Wallet został najpewniej utworzony z użyciem szyfrowania Blowfish z hasłem Twojego konta, więc użycie tej zmiennej środowiskowej powinno być bezpieczne.

Po wprowadzeniu tej zmiany, ponownie załaduj gpg-agent.

### Buforowanie haseł

`max-cache-ttl` oraz `default-cache-ttl` określają, przez ile sekund gpg-agent powinien przechowywać hasła w pamięci podręcznej. Aby wprowadzać hasło tylko raz na sesję, ustaw je na bardzo wysoką wartość, na przykład:

    gpg-agent.conf

    max-cache-ttl 60480000
    default-cache-ttl 60480000

W przypadku buforowania haseł w trybie emulacji SSH należy zamiast tego ustawić `default-cache-ttl-ssh` oraz `max-cache-ttl-ssh`, na przykład:

    gpg-agent.conf

    default-cache-ttl-ssh 60480000
    max-cache-ttl-ssh 60480000

### Bezobsługowe hasło

Począwszy od GnuPG 2.1.0, wymagane jest użycie gpg-agent i pinentry, co może przełamać kompatybilność wsteczną dla haseł wprowadzanych przez STDIN za pomocą opcji `--passphrase-fd 0`. Aby mieć ten sam typ funkcjonalności co starsze wersje, należy zrobić dwie rzeczy:

Najpierw edytuj konfigurację gpg-agent, aby umożliwić tryb pracy z loopback

    ~/.gnupg/gpg-agent.conf

    allow-loopback-pinentry

Załaduj ponownie agenta, jeśli jest uruchomiony, aby zmiana zaczęła obowiązywać.

Po drugie, albo aplikacja musi zostać zaktualizowana, aby zawierała parametr wiersza poleceń, aby użyć trybu pętli zwrotnej, jak na przykład:

    $ gpg --pinentry-mode loopback ...

...lub jeśli nie jest to możliwe, dodaj opcję do konfiguracji:

    ~/.gnupg/gpg.conf

    pinentry-mode loopback

Note Autor projektu upstream wskazuje, że ustawienie `pinentry-mode loopback` w pliku `gpg.conf` może powodować problemy z innymi zastosowaniami; jeżeli to możliwe, należy preferować użycie tej opcji bezpośrednio w wierszu poleceń. [5]

### SSH agent

gpg-agent ma emulację agenta OpenSSH. Jeśli już korzystasz z pakietu GnuPG, możesz rozważyć użycie jego agenta do buforowania SSH keys Ponadto niektórzy użytkownicy mogą preferować okno dialogowe wprowadzania kodu PIN, które zapewnia agent GnuPG w ramach zarządzania hasłami.

#### Set SSH_AUTH_SOCK

Musisz ustawić `SSH_AUTH_SOCK`, aby SSH używał gpg-agent zamiast ssh-agent. Aby upewnić się, że każdy proces może znaleźć Twoją instancję gpg-agent niezależnie od np. typ powłoki jest dzieckiem użytkowania pam_env.

    ~/.config/environment.d/50-ssh_auth_sock.conf

    SSH_AGENT_PID	DEFAULT=
    SSH_AUTH_SOCK	DEFAULT="${XDG_RUNTIME_DIR}/gnupg/S.gpg-agent.ssh"

Note Jeśli ustawisz `SSH_AUTH_SOCK` ręcznie (na przykład w tym przykładzie pam_env), pamiętaj, że lokalizacja gniazda może być inna, jeśli używasz niestandardowego `GNUPGHOME`. Możesz użyć poniższego przykładu bash lub zmienić `SSH_AUTH_SOCK` na wartość `gpgconf --list-dirs agent-ssh-socket`.

Ewentualnie zależą od Bash. Działa to również w przypadku niestandardowych lokalizacji gniazd:

    ~/.bashrc

    unset SSH_AGENT_PID
    if [ "${gnupg_SSH_AUTH_SOCK_by:-0}" -ne $$ ]; then
      export SSH_AUTH_SOCK="$(gpgconf --list-dirs agent-ssh-socket)"
    fi

Note The test involving the `gnupg_SSH_AUTH_SOCK_by` variable is for the case where the agent is started as `gpg-agent --daemon /bin/sh`, in which case the shell inherits the `SSH_AUTH_SOCK` variable from the parent, gpg-agent [6].

#### Skonfiguruj pinentry, aby użyć prawidłowego TTY

Ustaw również GPG_TTY i odśwież TTY, jeśli użytkownik przełączył się w sesję X, jak podano w gpg-agent(1). Na przykład:

    ~/.bashrc

    # Set GPG TTY
    export GPG_TTY=$(tty)

    # Refresh gpg-agent tty in case user switches into an X session
    gpg-connect-agent updatestartuptty /bye >/dev/null

#### Dodaj klucze SSH

Po uruchomieniu gpg-agent możesz użyć ssh-add do zatwierdzenia kluczy, wykonując te same kroki, co dla ssh-agent. Lista zatwierdzonych kluczy przechowywana jest w pliku `~/.gnupg/sshcontrol`.

Po zatwierdzeniu klucza, za każdym razem, gdy potrzebne jest hasło, otrzymasz okno dialogowe z danymi. Możesz kontrolować buforowanie hasła w pliku `~/.gnupg/gpg-agent.conf`. W poniższym przykładzie gpg-agent będzie przechowywać klucze w pamięci podręcznej przez 3 godziny:

    ~/.gnupg/gpg-agent.conf

    default-cache-ttl-ssh 10800
    max-cache-ttl-ssh 10800

#### Używanie klucza PGP do uwierzytelniania SSH

Możesz również używać swojego klucza PGP jako klucza SSH. Wymaga to klucza z możliwością `Authentication` (zob. #Niestandardowe funkcje). Korzystanie z klucza PGP do uwierzytelniania SSH niesie ze sobą szereg korzyści, w tym:

- Mniejszą konieczność utrzymania kluczy, ponieważ nie musisz już zarządzać osobnym kluczem SSH.
- Możliwość przechowywania klucza uwierzytelniającego na karcie kryptograficznej. GnuPG automatycznie wykryje klucz, gdy karta będzie dostępna, i doda go do agenta (sprawdź poleceniem `ssh-add -l` lub `ssh-add -L`). Komentarz do klucza powinien mieć postać zbliżoną do: `openpgp:key-id` lub `cardno:card-id`.

Aby uzyskać część publiczną klucza GPG/SSH, uruchom `gpg --export-ssh-key gpg-key`. Jeżeli klucz posiada możliwość uwierzytelniania, a polecenie to nadal kończy się błędem „Unusable public key”, dodaj sufiks `!` ([7]).

Jeżeli nie przechowujesz klucza GPG na karcie kryptograficznej, musisz dodać go do pliku `$GNUPGHOME/sshcontrol`, aby był rozpoznawany jako klucz SSH. Jeśli klucz znajduje się na karcie, jego keygrip jest dodawany do `sshcontrol` automatycznie. W przeciwnym wypadku uzyskaj keygrip klucza w następujący sposób:

    $ gpg --list-keys --with-keygrip

    sub   rsa4096 2018-07-25 [A]
          Keygrip = 1531C8084D16DC4C36911F1585AF0ACE7AAFD7E7

Następnie edytuj plik `sshcontrol` w następujący sposób. Dodanie keygripu jest czynnością jednorazową; nie będzie potrzeby ponownej edycji pliku, chyba że dodasz kolejne klucze.

    $GNUPGHOME/sshcontrol

    1531C8084D16DC4C36911F1585AF0ACE7AAFD7E7

## Smartcards

GnuPG używa scdaemona jako interfejsu do czytnika kart inteligentnych. Szczegółowe informacje znajdują się w man page

### GnuPG only setups

Note Aby umożliwić scdaemonowi bezpośredni dostęp do czytników kart USB smar, musi być zainstalowana opcjonalna zależność libusb-compat.

Jeśli nie planujesz używać innych kart oprócz tych opartych na GnuPG, powinieneś sprawdzić parametr port-czytnika w `~/.gnupg/scdaemon.conf`. Wartość "0" odnosi się do pierwszego dostępnego czytnika portów szeregowych, a wartość "32768" (domyślnie) odnosi się do pierwszego czytnika USB.

### GnuPG z pcscd (PCSC Lite)

Note Należy zainstalować pcsclite i ccid a zawarta usługa systemd `pcscd.service` musi być uruchomiona, lub gniazdo pcscd.socket musi nasłuchiwać.

pcscd to demon, który obsługuje dostęp do karty inteligentnej (SCard API). Jeśli scduemon GnuPG nie połączy bezpośrednio karty inteligentnej (np. Za pomocą zintegrowanej obsługi CCID), będzie się starał znaleźć kartę elektroniczną za pomocą sterownika PCSC Lite.

#### Zawsze używaj pcscd

Jeśli używasz jakiejkolwiek karty inteligentnej ze sterownikiem opensc (np .: karty identyfikacyjne z niektórych krajów) powinieneś zwrócić uwagę na konfigurację GnuPG. Po wyjęciu z pudełka możesz otrzymać wiadomość podobną do tej, gdy używasz `gpg --card-status`

    gpg: selecting openpgp failed: ec=6.108

Domyślnie scdaemon będzie próbował łączyć się bezpośrednio z urządzeniem. To połączenie zakończy się niepowodzeniem, jeśli czytnik będzie używany przez inny proces. Na przykład: demon pcscd używany przez OpenSC. Aby poradzić sobie z tą sytuacją, powinniśmy użyć tego samego sterownika, co opensc, aby mogli dobrze współpracować. W celu wskazania scdaemona do użycia pcscd powinieneś usunąć `reader-port` z `~/.gnupg/scdaemon.conf`, określić lokalizację biblioteki `libpcsclite.so` i wyłączyć ccid, abyśmy upewnili się, że używamy pcscd:

    ~/.gnupg/scdaemon.conf

    pcsc-driver /usr/lib/libpcsclite.so
    card-timeout 5
    disable-ccid

Sprawdź scdaemon(1), jeśli nie korzystasz z OpenSC.

## Porady i wskazówki

### Inny algorytm

Możesz użyć silniejszych algorytmów:

    ~/.gnupg/gpg.conf

    ...

    personal-digest-preferences SHA512
    cert-digest-algo SHA512
    default-preference-list SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed
    personal-cipher-preferences TWOFISH CAMELLIA256 AES 3DES

W najnowszej wersji GnuPG domyślnymi algorytmami są SHA256 i AES, które są wystarczająco bezpieczne dla większości ludzi. Jeśli jednak używasz wersji GnuPG starszej niż 2.1 lub chcesz uzyskać jeszcze wyższy poziom bezpieczeństwa, wykonaj powyższy krok.

### Zaszyfruj hasło

Przydaje się szyfrowanie hasła, więc nie będzie ono zapisane w pliku konfiguracyjnym. Dobrym przykładem jest twoje hasło e-mail.

Najpierw utwórz plik z hasłem. Po podaniu hasła musisz zostawić jedną pustą linię, w przeciwnym razie gpg zwróci komunikat o błędzie podczas oceniania pliku.

Następnie uruchom:

    $ gpg -e -a -r <user-id> your_password_file

`-e` is for encrypt, `-a` for armor (ASCII output), `-r` for recipient user ID.

Zostaniesz z nowym plikiem `your_password_file.asc`

Tip pass automatyzuje ten proces.

### Odwoływanie klucza

Warning

- Każdy, kto ma dostęp do Twojego certyfikatu unieważnienia, może odwołać klucz, czyniąc go bezużytecznym.
- Odwołanie klucza powinno być wykonywane tylko w przypadku złamania lub zgubienia klucza, lub zapomnienia hasła.

Certyfikaty unieważnienia są generowane automatycznie dla nowo wygenerowanych kluczy, chociaż jeden z nich może zostać wygenerowany ręcznie przez użytkownika później. Są one zlokalizowane w `~/.gnupg/openpgp-revocs.d/`. Nazwa pliku certyfikatu to odcisk palca klucza, który zostanie odwołany.

Aby unieważnić klucz, wystarczy zaimportować certyfikat unieważnienia:

    $ gpg --import <fingerprint>.rev

Teraz zaktualizuj serwer kluczy:

    $ gpg --keyserver subkeys.pgp.net --send-keys <userid>

### Zmiana modelu zaufania

Domyślnie GnuPG używa modelu Web of Trust jako modelu zaufania. Możesz zmienić go na Trust on First Use (TOFU), dodając opcję `--trust-model=tofu` podczas dodawania klucza lub umieszczając ją w pliku konfiguracyjnym GnuPG. Więcej szczegółów znajduje się w tym e-mailu na liście dyskusyjnej GnuPG.

### Ukryj wszystkie identyfikatory odbiorców

Domyślnie identyfikator klucza odbiorcy znajduje się w zaszyfrowanej wiadomości. Można go usunąć w czasie szyfrowania dla odbiorcy za pomocą ukrytego odbiorcy `hidden-recipient <user-id>`. Aby usunąć go dla wszystkich odbiorców, dodaj `throw-keyids` do pliku konfiguracyjnego. Pomaga to ukryć odbiorców wiadomości i stanowi ograniczony środek zaradczy przeciwko analizie ruchu. (Korzystając z małej inżynierii społecznej, każdy, kto potrafi odszyfrować wiadomość, może sprawdzić, czy jeden z pozostałych odbiorców jest tym, kogo podejrzewa.) Po stronie odbierającej może spowolnić proces deszyfrowania, ponieważ wszystkie dostępne klucze tajne muszą zostać wypróbowane ( np. z `--try-secret-key <user-id>`).

### Używanie caff do wysyłania kluczy partiami

Aby umożliwić użytkownikom sprawdzanie poprawności kluczy w serwerach kluczy iw ich plikach kluczy (to znaczy upewnić się, że pochodzą od kogo się podają), PGP/GPG korzysta z Web of Trust. Strony z kluczami pozwalają użytkownikom zebrać się w fizycznej lokalizacji, aby sprawdzić klucze. Protokół podpisywania kluczy Zimmermann-Sassaman jest sposobem na uczynienie ich bardzo skutecznymi. Tutaj znajdziesz artykuł z instrukcjami.

Aby ułatwić proces podpisywania kluczy i wysyłania podpisów do właścicieli po keysigning party możesz użyć narzędzia caff. Można go zainstalować z AUR z pakietem caff-gitAUR.

Aby wysłać podpisy do ich właścicieli, potrzebujesz działającego MTA. Jeśli jeszcze go nie masz, zainstaluj msmtp.

### Zawsze pokazuj długie identyfikatory i odciski palca

Aby zawsze wyświetlać długie identyfikatory klucza, dodaj plik `keyid-format 0xlong` do pliku konfiguracyjnego. Aby zawsze wyświetlać pełne `with-fingerprint` do pliku konfiguracyjnego.

### Niestandardowe funkcje

W celu dalszego dostosowania można również ustawić niestandardowe możliwości do kluczy. Dostępne są następujące możliwości:

- Certify (tylko dla kluczy głównych) - pozwala kluczowi tworzyć podklucze, obowiązkowe dla kluczy głównych.
- Sign - pozwala kluczowi tworzyć podpisy kryptograficzne, które inni mogą zweryfikować za pomocą klucza publicznego.
- Encrypt - umożliwia każdemu szyfrowanie danych za pomocą klucza publicznego, który tylko klucz prywatny może odszyfrować.
- Authenticate - umożliwia uwierzytelnianie klucza za pomocą różnych programów innych niż GnuPG. Klucz może być użyty jako np. klucz SSH.

Możliwe jest określenie możliwości klucza głównego, uruchamiając:

    $ gpg --full-generate-key --expert

Wybierz opcję, która pozwala ustawić własne możliwości.

Comparably, to specify custom capabilities for subkeys, add the `--expert` flag to `gpg --edit-key`, see #Edytuj swój klucz for more information.

Porównywalnie, aby określić niestandardowe możliwości dla podkluczy, dodaj `--expert` flag to `gpg --edit-key` zobacz #Edytuj swój klucz, aby uzyskać więcej informacji.

### Cache passwords

Aby otrzymać hasło do GnuPG tylko raz na sesję, ustaw `max-cache-ttl` i `default-cache-ttl` na coś bardzo wysokiego, na przykład:

    gpg-agent.conf

    max-cache-ttl 60480000
    default-cache-ttl 60480000

Zobacz #gpg-agent.

## Rozwiązywanie problemów:

### Nie ma wystarczającej liczby losowych bajtów

Podczas generowania klucza, gpg można napotkać ten błąd:

    Not enough random bytes available. Please do some other work to give the OS a chance to collect more entropy!

Aby sprawdzić dostępną entropię, sprawdź parametry jądra:

    cat /proc/sys/kernel/random/entropy_avail

Zdrowy system linuksowy z dużą dostępną entropią powróci do pełnej liczby 4096 bitów entropii. Jeśli wartość zwracana jest mniejsza niż 200, systemu zaczyna brakować entropii.

Aby go rozwiązać, pamiętaj, że często nie trzeba tworzyć kluczy, a najlepiej robić to, co sugeruje komunikat (np. Tworzyć aktywność na dysku, poruszać myszą, edytować wiki - wszystko stworzy entropię). Jeśli to nie pomoże, sprawdź, która usługa wykorzystuje entropię i zastanów się, czy nie zatrzymać jej na czas. Jeśli to nie jest alternatywa, zobacz Random number generation#Alternatives.

### su

Podczas używania `pinentry` musisz mieć odpowiednie uprawnienia urządzenia końcowego (np. `/dev/tty1`) w użyciu. Jednak w przypadku su (lub sudo) własność pozostaje z oryginalnym użytkownikiem, a nie nowym. Oznacza to, że pinentry zawiedzie, nawet jako root. Poprawka polega na zmianie uprawnień urządzenia w pewnym momencie przed użyciem pinentry (tj. Za pomocą gpg z agentem). Jeśli robisz gpg jako root, po prostu zmień właściciela na root przed użyciem gpg:

    # chown root /dev/ttyN  # where N is the current tty

a następnie zmienić go po użyciu gpg po raz pierwszy. Odpowiednik ten prawdopodobnie będzie true w `/dev/pts/`.

Note Właściciel tty musi być zgodny z użytkownikiem, dla którego działa pinentry. Bycie częścią grupy `tty` nie wystarczy.
Tip Jeśli uruchomisz gpg ze `script`, użyje on nowego tty z poprawną wartością:

    # script -q -c "gpg --gen-key" /dev/null

### Agent complains end of file

Domyślnym programem pinentry jest pinentry-gtk-2, który do prawidłowego działania potrzebuje magistrali sesji DBus. Zobacz General troubleshooting#Session permissions szczegółowe informacje.

Alternatywnie możesz użyć `pinentry-qt`. Zobacz #pinentry.

### KGpg configuration permissions

Pojawiły się problemy z kgpg możliwością uzyskania dostępu do pliku `~/.gnupg/` options. Jeden problem może być wynikiem przestarzałego pliku opcji, zobacz raport o błędzie bug report.

### GNOME na Wayland zastępuje gniazdo agenta SSH

W przypadku sesji Wayland, `gnome-session` ustawia SSH_AUTH_SOCK na standardowe gniazdo gnome-keyring, $ `$XDG_RUNTIME_DIR/keyring/ssh`. To przesłoni wszelkie wartości ustawione w `~/.pam_environmment` lub systemd jednostek jednostkowych.

Aby wyłączyć to zachowanie, ustaw zmienną `GSM_SKIP_AGENT_WORKAROUND`:

    ~/.pam_environment

    SSH_AGENT_PID	DEFAULT=
    SSH_AUTH_SOCK	DEFAULT="${XDG_RUNTIME_DIR}/gnupg/S.gpg-agent.ssh"
    GSM_SKIP_SSH_AGENT_WORKAROUND	DEFAULT="true"

### mutt

Mutt może nie używać poprawnie gpg-agent, musisz ustawić zmienną środowiskową `GPG_AGENT_INFO` (treść nie ma znaczenia) podczas uruchamiania mutt. Upewnij się także, czy poprawnie buforujesz hasła, patrz #Cache passwords.

Zobacz this forum thread

### "Utracone" klucze, aktualizacja do wersji 2.1 Gnupg

Kiedy gpg `gpg --list-keys` nie pokazuje kluczy, które były tam wcześniej, a aplikacje narzekają na brakujące lub nieprawidłowe klucze, niektóre klucze mogły nie zostać zmigrowane do nowego formatu.

Przeczytaj GnuPG invalid packet workaround Zasadniczo jest napisane, że istnieje błąd związany z kluczami w starych plikach `pubring.gpg` i `secring.gpg`, które zostały zastąpione nowym plikiem `pubring.kbx` oraz podkatalogiem `private-keys-v1.d/` i plikami. Twoje brakujące klucze można odzyskać za pomocą następujących komend:

    $ cd
    $ cp -r .gnupg gnupgOLD
    $ gpg --export-ownertrust > otrust.txt
    $ gpg --import .gnupg/pubring.gpg
    $ gpg --import-ownertrust otrust.txt
    $ gpg --list-keys

### gpg zawiesza się dla wszystkich serwerów kluczy (podczas próby odebrania kluczy)

Jeśli gpg zawieszi się z określonym serwerem kluczy podczas próby odebrania kluczy, być może trzeba zabić dirmngr, aby uzyskać dostęp do innych serwerów kluczy, które faktycznie działają, w przeciwnym razie może zachowywać zawieszenie dla nich wszystkich.

### Nie wykryto SmartCard

Twój użytkownik może nie mieć uprawnień dostępu do karty elektronicznej, co powoduje `card error` , mimo że karta jest poprawnie skonfigurowana i włożona.

Jednym z możliwych rozwiązań jest dodanie nowego `scard` grupy, w tym użytkowników, którzy potrzebują dostępu do smartcard.

Następnie użyj reguły udev , podobnej do następującej:

    /etc/udev/rules.d/71-gnupg-ccid.rules

    ACTION=="add", SUBSYSTEM=="usb", ENV{ID_VENDOR_ID}=="1050", ENV{ID_MODEL_ID}=="0116|0111", MODE="660", GROUP="scard"

Trzeba dostosować VENDOR i MODEL zgodnie z wyjściem `lsusb`, powyższy przykład dotyczy YubikeyNEO.

### gpg: WARNING: server 'gpg-agent' is older than us (x < y)

To ostrzeżenie pojawia się, gdy `gnupg`jest uaktualniony, a stary gpg-agent nadal działa. Zrestartuj `gpg-agent.socket` użytkownika (tj. Użyj flagi `--user` podczas ponownego uruchamiania).

### gpg: ..., IPC connect call failed

The factual accuracy of this article or section is disputed.

Reason: The `gpg-agent*.socket` systemd sockets provided by the gnupg package create the sockets in `/run/user/$UID/gnupg/` which is guaranteed to be an appropriate file system. (Discuss in Talk:GnuPG (Polski))

Upewnij się, że `gpg-agent` i `dirmngr` nie działają z `killall gpg-agent dirmngr`, a folder `$GNUPGHOME/crls.d/` ma uprawnienia ustawione na `700`.

Jeśli twoj keyring jest przechowywana na systemie plików vFat (np. Dysku USB), `gpg-agent` nie będzie w stanie utworzyć wymaganych gniazd (vFat nie obsługuje gniazd), możesz utworzyć przekierowania do lokalizacji, która obsługuje gniazda, np. `/dev/shm`:

    # export GNUPGHOME=/custom/gpg/home
    # printf '%%Assuan%%\nsocket=/dev/shm/S.gpg-agent\n' > $GNUPGHOME/S.gpg-agent
    # printf '%%Assuan%%\nsocket=/dev/shm/S.gpg-agent.browser\n' > $GNUPGHOME/S.gpg-agent.browser
    # printf '%%Assuan%%\nsocket=/dev/shm/S.gpg-agent.extra\n' > $GNUPGHOME/S.gpg-agent.extra
    # printf '%%Assuan%%\nsocket=/dev/shm/S.gpg-agent.ssh\n' > $GNUPGHOME/S.gpg-agent.ssh

Sprawdź, czy gpg-agent uruchamia się pomyślnie z `gpg-agent --daemon`.

## Zobacz też

- GNU Privacy Guard Homepage
- RFC4880 "OpenPGP Message Format"
- Creating GPG Keys (Fedora)
- OpenPGP subkeys in Debian
- A more comprehensive gpg Tutorial
- gpg.conf recommendations and best practices
- Torbirdy gpg.conf
- /r/GPGpractice - a subreddit to practice using GnuPG.
- Protecting code integrity with PGP

Category:

- Encryption (Polski)

Hidden categories:

- Pages or sections flagged with Template:Translateme
- Pages with broken section links
- Pages or sections flagged with Template:Expansion
- Pages or sections flagged with Template:Accuracy

GnuPG (Polski)
Add topic