Otwórz plik .env dowolnej produkcyjnej aplikacji w Laravelu. Najpewniej znajdziesz tam hasło do bazy danych, klucz szyfrujący APP_KEY, dane dostępowe do serwera pocztowego, token bramki płatności, klucz do S3 i, coraz częściej, klucz API do modelu językowego. Kilkanaście najcenniejszych informacji w firmie, zapisanych otwartym tekstem w jednym pliku, który leży w katalogu aplikacji obok kodu.
Przez lata nikt się tym specjalnie nie przejmował, bo „przecież .env nie trafia do repozytorium”. Problem polega na tym, że repozytorium to tylko jedna z wielu dróg, którymi ten plik może wyciec. A wyciek APP_KEY w Laravelu nie oznacza „tylko” ujawnienia danych. W pewnych warunkach oznacza możliwość wykonania dowolnego kodu na Twoim serwerze.
W tym artykule pokażę, którędy naprawdę uciekają sekrety z pliku .env, dlaczego zmienne środowiskowe nie są tu dobrym zamiennikiem i jak przenieść sekrety Laravela do mechanizmu systemd credentials: zaszyfrowanych na dysku, dostępnych wyłącznie dla jednego procesu i łatwych do wymiany. Na końcu zmienimy hasło do bazy i klucz aplikacji bez wylogowywania użytkowników.
Którędy wycieka plik .env?
Zanim zaczniemy cokolwiek zmieniać, warto zobaczyć, przed czym właściwie się bronimy. Dróg jest kilka i tylko jedna z nich prowadzi przez repozytorium.
Źle ustawiony katalog główny serwera WWW
Zacznijmy od najbardziej prozaicznej drogi. Laravel serwuje aplikację z katalogu public/, a plik .env leży katalog wyżej, poza zasięgiem przeglądarki. Wystarczy jednak, że ktoś przy konfiguracji serwera WWW ustawi katalog główny na /var/www/sklep zamiast na /var/www/sklep/public, i plik staje się dostępny pod adresem https://sklep.example.com/.env.
Brzmi jak błąd, który nikomu się nie przydarza. Boty skanujące internet odpytują jednak ten adres nieustannie, właśnie dlatego, że regularnie coś tam znajdują. Istnieje nawet wyspecjalizowane złośliwe oprogramowanie, takie jak AndroxGh0st, które robi to wyłącznie po to, aby zbierać dane dostępowe z aplikacji Laravela.
Repozytorium i „tymczasowe” kopie pliku
Druga droga to repozytorium. .env jest w .gitignore, ale .env.backup, .env.production.old czy env.txt utworzony „na chwilę” podczas migracji już nie.
Skala tego zjawiska jest zaskakująca. W 2025 roku firmy GitGuardian i Synacktiv przeanalizowały publiczne repozytoria GitHuba z ostatnich lat i znalazły ponad 260 tysięcy kluczy APP_KEY. Wśród nich były klucze działających aplikacji, które dało się przejąć przez zdalne wykonanie kodu.
Kopie zapasowe, archiwa i laptopy
Trzecia droga jest najmniej oczywista. Plik .env ląduje w kopii zapasowej katalogu aplikacji, w snapshocie LVM, w archiwum .tar.gz wysłanym koledze „do debugowania”, w obrazie maszyny wirtualnej i na laptopie programisty, który pobrał go z serwera, żeby odtworzyć błąd.
Każda z tych kopii żyje własnym życiem i ma własny poziom zabezpieczeń, zazwyczaj niższy niż serwer produkcyjny. Ty pilnujesz serwera, a sekret od dawna leży gdzie indziej.
Narzędzia, które czytają cały projekt
Czwarta droga to narzędzia, które przeglądają cały katalog projektu. Jeżeli agent AI pracuje w repozytorium lub na serwerze, ma dostęp do wszystkiego, co może odczytać użytkownik, na którym działa. Plik .env jest dla niego zwykłym plikiem tekstowym, który chętnie przeczyta, żeby „zrozumieć konfigurację”. Ta treść może potem trafić do kontekstu modelu, do logów albo do zewnętrznej usługi.
Dlaczego akurat APP_KEY jest tak niebezpieczny?
Wśród wszystkich sekretów w .env jeden zasługuje na szczególną uwagę. Hasło do bazy daje dostęp do danych. APP_KEY w niektórych sytuacjach daje dostęp do całego serwera.
Podrobione ciasteczko sesji
APP_KEY to klucz, którym Laravel szyfruje i podpisuje ciasteczka, w tym ciasteczko sesji. Aplikacja ufa każdemu ciasteczku, które da się poprawnie odszyfrować tym kluczem, bo zakłada, że tylko ona go zna.
Kto zna ten klucz, może więc przygotować ciasteczko, które aplikacja uzna za własne. To już wystarczy, żeby w wielu konfiguracjach podszyć się pod zalogowanego użytkownika.
Od ciasteczka do wykonania kodu
Gorzej, że funkcja decrypt() w Laravelu domyślnie deserializuje odszyfrowane dane. Deserializacja w PHP oznacza odtworzenie obiektów z zapisanego wcześniej ciągu znaków. Jeżeli ten ciąg przygotował atakujący, może tak dobrać łańcuch obiektów, że ich odtworzenie uruchomi wybrany przez niego kod.
Właśnie tak wyglądał scenariusz opisany przez GitGuardian i Synacktiv: znany klucz plus znany adres aplikacji pozwalały w części przypadków przejąć serwer bez znajomości jakiegokolwiek hasła. Dlatego APP_KEY warto traktować tak samo poważnie jak hasło roota.
Zmienne środowiskowe to nie jest rozwiązanie
Naturalna reakcja na problem z plikiem brzmi: „to nie trzymajmy sekretów w pliku, przekażmy je przez zmienne środowiskowe”. Tak zresztą zaleca popularna metodologia Twelve-Factor App. Na serwerze ten pomysł ma jednak kilka słabych punktów.
Dziedziczy je każdy proces potomny
Zmienne środowiskowe przechodzą automatycznie na każdy program, który aplikacja uruchomi. Jeżeli Twoja aplikacja wywołuje convert do obróbki zdjęć, wkhtmltopdf do generowania faktur albo skrypt w Pythonie, każdy z tych programów dostaje komplet sekretów, choć żadnego z nich nie potrzebuje. Wystarczy luka w jednym z nich, żeby sekrety wyciekły.
Widać je w wielu miejscach
Środowisko działającego procesu można odczytać z pliku /proc/<pid>/environ. Funkcja phpinfo() czy strona błędu w trybie debugowania potrafią wyświetlić je w przeglądarce. Narzędzia do raportowania błędów chętnie dołączają środowisko do zgłoszenia, które trafia na zewnętrzny serwer.
Zmienne środowiskowe nie są więc bezpieczniejszym miejscem na sekrety. Są po prostu innym miejscem, z którego sekrety wyciekają w inny sposób.
Czego właściwie chcemy?
Zanim przejdziemy do rozwiązania, trzeba uczciwie ustalić, co jest możliwe, a co nie.
Granica, której nie przesuniemy
Aplikacja musi znać hasło do bazy, żeby się z nią połączyć. Jeżeli atakujący zdoła wykonać kod jako użytkownik aplikacji, pozna to hasło niezależnie od tego, gdzie je schowamy. Żaden mechanizm tego nie zmieni i warto mieć to z tyłu głowy, czytając dalszą część.
Co da się ograniczyć
Celem nie jest więc ukrycie sekretów przed samą aplikacją, tylko zamknięcie wszystkich pozostałych dróg wycieku. Sekret nie powinien leżeć otwartym tekstem w katalogu aplikacji, a na dysku i w kopiach zapasowych powinien istnieć wyłącznie w postaci zaszyfrowanej. W czasie działania powinien go móc odczytać tylko jeden konkretny proces, a nie każdy program uruchomiony na tym samym koncie. Nie powinien trafiać do zmiennych środowiskowych. I wreszcie, powinno dać się go wymienić w kilka minut, bez edytowania plików aplikacji.
Dokładnie to zapewnia mechanizm wbudowany w systemd, którego najpewniej i tak używasz na swoich serwerach.
systemd credentials w prostych słowach
Credentials (dane uwierzytelniające) to sposób, w jaki systemd przekazuje usłudze poufne dane. Najłatwiej zrozumieć go, śledząc drogę jednego sekretu od dysku do aplikacji.
Na dysku: zaszyfrowany plik
Sekret leży w pliku na dysku w postaci zaszyfrowanej. Szyfruje go narzędzie systemd-creds kluczem przechowywanym w /var/lib/systemd/credential.secret, który może odczytać tylko root.
Jeżeli serwer ma układ TPM2, czyli sprzętowy moduł bezpieczeństwa wbudowany w płytę główną, sekret jest dodatkowo szyfrowany kluczem, który nigdy nie opuszcza tego układu. Taki plik da się odszyfrować wyłącznie na tej jednej maszynie.
W pliku usługi: lista sekretów
Każda usługa w systemd jest opisana plikiem jednostki (ang. unit file), w którym określasz między innymi, jaki program uruchomić i jako jaki użytkownik. W tym samym pliku wskazujesz, które sekrety usługa ma dostać. Wszystkie inne pozostają dla niej niewidoczne.
W czasie działania: katalog w pamięci
Przy starcie usługi systemd odszyfrowuje jej sekrety i umieszcza je jako zwykłe pliki w katalogu /run/credentials/<nazwa-usługi>/. Katalog znajduje się w pamięci operacyjnej, która nie trafia do pliku wymiany, a jego zawartość może odczytać wyłącznie użytkownik, na którym działa usługa.
Usługa dostaje zmienną środowiskową CREDENTIALS_DIRECTORY ze ścieżką do tego katalogu. W zmiennej jest tylko ścieżka, nie sam sekret. Gdy usługa się zatrzymuje, katalog znika.
Z perspektywy aplikacji sekret jest więc po prostu plikiem, który trzeba odczytać. Z perspektywy reszty systemu sekret nie istnieje nigdzie poza tym jednym procesem.
Przyjemny efekt uboczny: bezpieczne kopie
Jest jeszcze jedna konsekwencja, którą docenisz przy kopiach zapasowych. Jeżeli wdrożyłeś kopię katalogu /etc według artykułu o restic, zaszyfrowane sekrety trafią do kopii, ale klucz do ich odszyfrowania leży w /var/lib/systemd i do niej nie trafi. Ktoś, kto ukradnie kopię, dostanie bezużyteczne zaszyfrowane pliki.
Pułapka, o której nie piszą poradniki: PHP-FPM
Tu zaczyna się część, która odróżnia teorię od działającego wdrożenia.
Master działa jako root, workery jako apache
PHP-FPM to program, który wykonuje kod PHP na zlecenie serwera WWW. Składa się z procesu głównego (master), który zarządza całością, oraz procesów roboczych (workerów), które obsługują żądania.
Na systemach z rodziny RHEL PHP-FPM działa jako jedna usługa systemd, php-fpm.service. Master działa jako root, a workery przełączają się na użytkownika apache. Systemd udostępnia sekrety użytkownikowi usługi, czyli w tym przypadku rootowi. Workery, które naprawdę potrzebują hasła do bazy, nie mają do nich dostępu.
Osobna instancja dla aplikacji
Można by próbować to obejść, kopiując sekrety w inne miejsce albo luzując uprawnienia, ale wtedy tracimy to, o co nam chodziło. Lepszym rozwiązaniem jest osobna instancja PHP-FPM dla aplikacji, uruchamiana od początku jako jej własny użytkownik. Master i workery działają wtedy na tym samym koncie, a sekrety trafiają dokładnie tam, gdzie powinny.
To rozwiązanie ma wartość także poza sekretami. Każda aplikacja na serwerze dostaje osobnego użytkownika i osobny proces, więc błąd w jednej nie daje automatycznie dostępu do plików drugiej.
Przygotowanie serwera
Środowisko i założenia
Do demonstracji wykorzystamy AlmaLinux 10, zgodny z RHEL 10. Korzystamy z dyrektywy ImportCredential=, która wymaga systemd w wersji co najmniej 254. AlmaLinux 10 ma nowszą, więc nie musisz niczego doinstalowywać.
Zakładam, że aplikacja Laravel w wersji 11 lub nowszej już działa na serwerze z nginx i PHP-FPM, korzysta z PostgreSQL i znajduje się w katalogu /var/www/sklep. W przykładach nazwa aplikacji to sklep, a jej użytkownik systemowy też nazywa się sklep. Wszędzie, gdzie widzisz tę nazwę, wstaw nazwę swojej aplikacji.
Wszystkie polecenia systemowe wykonujemy jako root, na przykład po sudo -i. Kilka z nich zapisuje pliki w /etc przez przekierowanie, które z prostym sudo przed poleceniem by nie zadziałało.
Zabezpiecz możliwość powrotu
Będziemy zmieniać sposób uruchamiania PHP i konfigurację nginx. Jeżeli serwer działa na LVM, utwórz snapshot według artykułu o cofaniu zmian albo przećwicz całość najpierw w laboratorium KVM.
Dobra wiadomość jest taka, że do momentu przełączenia nginx na nowy socket stara konfiguracja działa bez zmian. Jeżeli coś pójdzie nie tak po przełączeniu, wystarczy przywrócić poprzedni plik konfiguracyjny nginx i przeładować usługę.
Użytkownik aplikacji
Jeżeli aplikacja nie ma jeszcze własnego użytkownika, utwórz go:
useradd --system --no-create-home --shell /sbin/nologin sklep
To konto systemowe bez katalogu domowego i bez możliwości zalogowania się. Służy wyłącznie do uruchamiania procesów aplikacji.
Użytkownik sklep musi móc pisać do katalogów storage/ i bootstrap/cache/, tak jak wcześniej robił to apache:
chown -R sklep:sklep /var/www/sklep/storage /var/www/sklep/bootstrap/cache
Zaszyfrowane sekrety na serwerze
Magazyn sekretów i klucz szyfrujący
Systemd szuka zaszyfrowanych sekretów między innymi w katalogu /etc/credstore.encrypted. Utwórzmy go z uprawnieniami tylko dla roota:
install -d -m 0700 /etc/credstore.encrypted
Następnie przygotujmy klucz, którym systemd będzie szyfrować sekrety, i sprawdźmy, czy serwer ma układ TPM2:
systemd-creds setup
systemd-creds has-tpm2
Pierwsze polecenie tworzy klucz w /var/lib/systemd/credential.secret, jeżeli jeszcze nie istnieje. Drugie pokazuje, czy TPM2 jest dostępny. Jeśli jest, sekrety zostaną związane ze sprzętem i nie da się ich odszyfrować na innej maszynie, nawet mając plik credential.secret. W maszynie wirtualnej bez wirtualnego TPM wykorzystany zostanie sam klucz z pliku i to również jest poprawna konfiguracja.
Z tego wynika ważna zasada: oryginalne wartości sekretów przechowuj w menedżerze haseł, a nie wyłącznie na serwerze. Zaszyfrowany plik jest związany z konkretną maszyną. Gdy będziesz odtwarzać serwer po awarii, zaszyfrujesz sekrety na nowo.
Szyfrowanie hasła do bazy
Chcemy, aby hasło nie trafiło do historii poleceń ani na listę procesów, dlatego wczytamy je bez wyświetlania na ekranie:
umask 077
read -rsp 'Hasło do bazy: ' SECRET; echo
printf '%s' "$SECRET" | systemd-creds encrypt --name=sklep.db_password - /etc/credstore.encrypted/sklep.db_password
unset SECRET
umask 077 sprawia, że tworzone pliki będą dostępne wyłącznie dla roota. Opcja -s w poleceniu read ukrywa wpisywane znaki. printf jest poleceniem wbudowanym w powłokę, więc hasło nie pojawi się jako argument procesu widoczny w ps. Znak - mówi systemd-creds, aby czytał sekret ze standardowego wejścia.
Opcja --name zapisuje w zaszyfrowanym pliku nazwę sekretu. Przy odszyfrowywaniu systemd sprawdzi, czy nazwa się zgadza. To zabezpieczenie przed pomyłką lub celową podmianą: plik z hasłem do bazy nie zostanie po cichu użyty jako klucz aplikacji. Nazwa pliku jest taka sama jak nazwa sekretu, a wspólny prefiks sklep. pozwoli za chwilę wczytać wszystkie sekrety aplikacji jedną linią.
Szyfrowanie klucza aplikacji
Jeżeli przenosisz istniejącą aplikację, użyj na razie obecnego klucza z pliku .env, razem z prefiksem base64::
read -rsp 'APP_KEY: ' SECRET; echo
printf '%s' "$SECRET" | systemd-creds encrypt --name=sklep.app_key - /etc/credstore.encrypted/sklep.app_key
unset SECRET
Pod koniec artykułu wyjaśnię, dlaczego po migracji i tak warto oba sekrety zmienić. W ten sam sposób możesz zaszyfrować pozostałe sekrety, na przykład token bramki płatności jako sklep.payment_token.
Sprawdzenie bez ujawniania wartości
Upewnijmy się, że systemd potrafi odszyfrować to, co przygotowaliśmy, nie wyświetlając przy tym samych wartości:
systemd-run --pipe --wait -p 'ImportCredential=sklep.*' systemd-creds list
Polecenie uruchamia tymczasową usługę z sekretami aplikacji i wyświetla ich listę. Powinieneś zobaczyć nazwy sklep.app_key i sklep.db_password razem z ich rozmiarem. Jeżeli któryś sekret ma złą nazwę lub uszkodzony plik, dowiesz się o tym teraz, a nie przy starcie produkcyjnej usługi.
Osobna instancja PHP-FPM
Konfiguracja puli
Utwórz katalog na konfigurację i plik z ustawieniami PHP-FPM dla aplikacji:
install -d -m 0755 /etc/sklep
cat > /etc/sklep/php-fpm.conf <<'EOF'
[global]
error_log = syslog
syslog.ident = sklep-fpm
[sklep]
listen = /run/sklep-fpm/php-fpm.sock
listen.acl_users = nginx
listen.mode = 0600
pm = dynamic
pm.max_children = 10
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3
env[CREDENTIALS_DIRECTORY] = $CREDENTIALS_DIRECTORY
EOF
W konfiguracji nie ma dyrektyw user i group. Nie są potrzebne, bo PHP-FPM od początku działa jako użytkownik sklep, a nie przełącza się na niego z konta roota.
Wartości pm.* określają, ile workerów PHP może działać jednocześnie. Dobierz je do możliwości serwera i ruchu w aplikacji. Jeżeli wcześniej aplikacja korzystała z puli www, możesz przenieść ustawienia stamtąd.
Socket dostępny tylko dla nginx
Socket to plik specjalny, przez który nginx przekazuje żądania do PHP. Nasz ma uprawnienia 0600, czyli tylko dla właściciela. Dyrektywa listen.acl_users dodaje do niego uprawnienie ACL, czyli dodatkowy wpis w uprawnieniach pliku, dla użytkownika nginx.
Dzięki temu nginx może się połączyć z PHP, ale nie musimy dodawać go do żadnej grupy ani dawać mu dostępu do plików aplikacji. Inni użytkownicy systemu nie połączą się z socketem wcale.
Jedna zmienna, nie wszystkie
Najciekawsza jest ostatnia linia konfiguracji. PHP-FPM domyślnie czyści środowisko workerów (clear_env = yes), dlatego żadna zmienna przekazana przez systemd nie dociera do kodu PHP, dopóki jawnie na to nie pozwolimy.
Zapis env[CREDENTIALS_DIRECTORY] = $CREDENTIALS_DIRECTORY kopiuje do workerów dokładnie jedną zmienną: ścieżkę do katalogu z sekretami. Same sekrety nie przechodzą przez środowisko, więc nie odziedziczy ich żaden program uruchomiony przez aplikację.
Usługa systemd
Teraz opiszemy usługę, która uruchomi PHP-FPM jako użytkownik sklep i przekaże mu sekrety:
cat > /etc/systemd/system/sklep-fpm.service <<'EOF'
[Unit]
Description=PHP-FPM aplikacji sklep
After=network.target
[Service]
Type=notify
User=sklep
Group=sklep
RuntimeDirectory=sklep-fpm
ExecStart=/usr/sbin/php-fpm --nodaemonize --fpm-config /etc/sklep/php-fpm.conf
ExecReload=/bin/kill -USR2 $MAINPID
KillSignal=SIGQUIT
ImportCredential=sklep.*
PrivateTmp=yes
PrivateMounts=yes
[Install]
WantedBy=multi-user.target
EOF
ImportCredential=sklep.* to serce całej konfiguracji. Systemd przeszuka swoje magazyny sekretów, w tym /etc/credstore.encrypted, wybierze wszystkie sekrety o nazwach zaczynających się od sklep., odszyfruje je i umieści w katalogu dostępnym tylko dla tej usługi. Dodanie nowego sekretu nie będzie wymagało zmiany pliku jednostki.
RuntimeDirectory=sklep-fpm tworzy przy starcie katalog /run/sklep-fpm należący do użytkownika sklep. W nim PHP-FPM utworzy socket.
KillSignal=SIGQUIT sprawia, że przy zatrzymaniu lub restarcie PHP-FPM najpierw kończy obsługiwane żądania, zamiast przerywać je w połowie. To będzie ważne przy wymianie sekretów, która wymaga restartu.
PrivateTmp=yes daje usłudze własny katalog /tmp, niewidoczny dla innych procesów. PrivateMounts=yes uruchamia ją we własnej przestrzeni montowań, czyli we własnym widoku systemu plików, dzięki czemu katalog z sekretami nie jest widoczny z perspektywy innych usług. Dokumentacja systemd wprost zaleca to ustawienie dla usług korzystających z credentials.
SELinux
AlmaLinux domyślnie działa z włączonym SELinuksem, który kontroluje dostęp niezależnie od zwykłych uprawnień plików. Każdy proces i każdy plik ma etykietę, a polityka określa, które etykiety mogą się ze sobą komunikować.
PHP-FPM działa w domenie httpd_t, a nginx łączy się z jego socketem. Standardowy socket PHP-FPM leży w /run/php-fpm, który ma etykietę httpd_var_run_t. Nadajmy tę samą etykietę naszemu katalogowi:
semanage fcontext -a -t httpd_var_run_t '/run/sklep-fpm(/.*)?'
Systemd nada tę etykietę katalogowi w chwili jego tworzenia, przy starcie usługi.
Uruchomienie i diagnostyka
systemctl daemon-reload
systemctl enable --now sklep-fpm.service
systemctl status sklep-fpm.service
ls -lZ /run/sklep-fpm/
Status powinien pokazywać usługę jako aktywną, a w katalogu powinien znajdować się socket php-fpm.sock z etykietą httpd_var_run_t.
Jeżeli usługa nie startuje albo kolejne kroki kończą się błędem Permission denied, zanim cokolwiek wyłączysz, sprawdź, co zablokował SELinux:
ausearch -m AVC -ts recent
Każdy wpis pokazuje, który proces (scontext) próbował uzyskać dostęp do jakiego obiektu (tcontext). To konkretna informacja, od której zaczyna się naprawa. Rozwiązaniem nigdy nie jest setenforce 0, tylko poprawna etykieta albo, w ostateczności, mała lokalna reguła polityki obejmująca dokładnie ten jeden dostęp.
nginx: jedna linia, która chroni .env
Konfiguracja serwisu
Zanim przełączysz nginx, upewnij się, że katalog główny serwisu wskazuje na public/. To jedna linia, ale to ona decyduje, czy plik .env da się pobrać przez przeglądarkę. Konfiguracja serwisu leży zwykle w pliku w katalogu /etc/nginx/conf.d/, na przykład sklep.conf. Zanim go zmienisz, zrób jego kopię, żeby mieć do czego wrócić:
server {
listen 80;
server_name sklep.example.com;
root /var/www/sklep/public;
index index.php;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location ~ \.php$ {
fastcgi_pass unix:/run/sklep-fpm/php-fpm.sock;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
}
location ~ /\.(?!well-known) {
deny all;
}
}
Trzy elementy, które mają znaczenie
Konfigurację TLS pominąłem dla czytelności. Kluczowe są trzy elementy. root wskazuje na public/, więc wszystko, co leży wyżej, w tym .env, jest poza zasięgiem przeglądarki. fastcgi_pass kieruje żądania do nowego socketu. Ostatni blok blokuje dostęp do wszystkich plików zaczynających się od kropki, z wyjątkiem katalogu .well-known, używanego między innymi przez Let's Encrypt. To druga linia obrony na wypadek, gdyby ktoś kiedyś znowu zmienił root.
Nie przeładowuj jeszcze nginx. Najpierw aplikacja musi nauczyć się czytać sekrety.
Laravel czyta sekrety z plików
Service provider
Laravel nie wie nic o systemd credentials, ale nauczenie go tego wymaga jednej klasy. Wykorzystamy do tego service provider, czyli klasę, którą Laravel uruchamia na starcie każdego żądania i każdego polecenia, aby przygotować aplikację do pracy.
Utwórz plik app/Providers/SecretsServiceProvider.php:
<?php
namespace App\Providers;
use Illuminate\Support\ServiceProvider;
use RuntimeException;
class SecretsServiceProvider extends ServiceProvider
{
private const PREFIX = 'sklep.';
public function register(): void
{
$directory = getenv('CREDENTIALS_DIRECTORY');
if ($directory === false || $directory === '') {
return;
}
if ($this->isCachingConfiguration()) {
return;
}
$connection = config('database.default');
$this->apply($directory, 'app_key', 'app.key');
$this->apply($directory, 'db_password', "database.connections.{$connection}.password");
$previousKeys = $this->read($directory, 'app_previous_keys');
if ($previousKeys !== null) {
config(['app.previous_keys' => array_values(array_filter(array_map('trim', explode(',', $previousKeys))))]);
}
}
private function isCachingConfiguration(): bool
{
if (! $this->app->runningInConsole()) {
return false;
}
$command = $_SERVER['argv'][1] ?? '';
return in_array($command, ['config:cache', 'optimize'], true);
}
private function apply(string $directory, string $name, string $configKey): void
{
$value = $this->read($directory, $name);
if ($value !== null) {
config([$configKey => $value]);
}
}
private function read(string $directory, string $name): ?string
{
$path = $directory . '/' . self::PREFIX . $name;
if (! is_file($path)) {
return null;
}
$value = file_get_contents($path);
if ($value === false) {
throw new RuntimeException("Nie można odczytać sekretu: {$name}");
}
return rtrim($value, "\r\n");
}
}
Zarejestruj go w pliku bootstrap/providers.php, dopisując na liście:
App\Providers\SecretsServiceProvider::class,
Gdy zmiennej CREDENTIALS_DIRECTORY nie ma, provider nic nie robi i Laravel korzysta z wartości w .env. Dzięki temu lokalne środowisko programisty działa tak jak dotąd.
Dlaczego nie w plikach config/
Pierwszy pomysł, jaki przychodzi do głowy, to dopisanie file_get_contents() bezpośrednio w plikach z katalogu config/. Problem tkwi w cache konfiguracji.
Laravel na produkcji zwykle działa z włączonym cache konfiguracji. Polecenie php artisan config:cache wykonuje wszystkie pliki konfiguracyjne raz i zapisuje wynik jako tablicę PHP w pliku bootstrap/cache/config.php. To oznacza, że każdy sekret odczytany w pliku konfiguracyjnym trafia do tego pliku otwartym tekstem. Wiele aplikacji, które „nie trzymają haseł w .env”, i tak ma je zapisane na dysku, tylko w innym miejscu.
Service provider działa inaczej. Jego metoda register() wykonuje się przy każdym żądaniu, już po wczytaniu konfiguracji, także tej z cache. Sekrety są wstawiane do konfiguracji w pamięci procesu. Cache konfiguracji zawiera puste wartości, a aplikacja działa z prawdziwymi.
Pułapka: config:cache też uruchamia providery
Jest tu jeden haczyk, na który łatwo się nadziać. Żeby zbudować cache, polecenie config:cache uruchamia aplikację w całości, łącznie z metodami register() wszystkich providerów, i dopiero potem zapisuje gotową konfigurację do pliku. Gdyby nasz provider w tym momencie wstawił sekrety, trafiłyby one prosto do bootstrap/cache/config.php, czyli dokładnie tam, gdzie nie chcemy.
Dlatego metoda isCachingConfiguration() sprawdza, czy aplikacja działa właśnie w ramach config:cache albo optimize, które buduje cache konfiguracji przy okazji. Jeżeli tak, provider niczego nie wstawia. Na końcu artykułu sprawdzimy, czy cache rzeczywiście jest pusty, i to jest test, którego nie warto pomijać.
Przełączenie ruchu
Wdróż zmianę standardową ścieżką, a następnie przełącz nginx:
nginx -t && systemctl reload nginx
Polecenie nginx -t sprawdza poprawność konfiguracji, a przeładowanie nastąpi tylko wtedy, gdy test przejdzie. Otwórz aplikację w przeglądarce i sprawdź, czy działa, w tym logowanie, które korzysta z APP_KEY.
Kolejki, harmonogram i Artisan
Sekrety dostaje usługa sklep-fpm, ale aplikacja Laravel to nie tylko żądania HTTP. Workery kolejki, zadania harmonogramu i polecenia Artisana uruchamiane ręcznie to osobne procesy, które o katalogu z sekretami nic nie wiedzą. Każdy z nich trzeba podłączyć osobno.
Worker kolejki jako usługa
Worker kolejki powinien być osobną usługą z tymi samymi sekretami:
cat > /etc/systemd/system/sklep-queue.service <<'EOF'
[Unit]
Description=Kolejka Laravel aplikacji sklep
After=network.target
[Service]
User=sklep
Group=sklep
WorkingDirectory=/var/www/sklep
ExecStart=/usr/bin/php artisan queue:work --sleep=3 --tries=3 --max-time=3600
Restart=always
ImportCredential=sklep.*
PrivateTmp=yes
PrivateMounts=yes
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable --now sklep-queue.service
--max-time=3600 sprawia, że worker kończy pracę po godzinie, a Restart=always uruchamia go ponownie. Dzięki temu proces regularnie się odświeża i nie gromadzi wycieków pamięci.
Harmonogram zamiast crona
Jeżeli harmonogram Laravela uruchamiasz z crona, wpis w cronie nie dostanie sekretów. Najprościej zastąpić go usługą, która uruchamia schedule:work. To polecenie działa w pierwszym planie i co minutę wywołuje harmonogram, czyli robi dokładnie to, co wcześniej robił cron:
cat > /etc/systemd/system/sklep-schedule.service <<'EOF'
[Unit]
Description=Harmonogram Laravel aplikacji sklep
After=network.target
[Service]
User=sklep
Group=sklep
WorkingDirectory=/var/www/sklep
ExecStart=/usr/bin/php artisan schedule:work
Restart=always
ImportCredential=sklep.*
PrivateTmp=yes
PrivateMounts=yes
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable --now sklep-schedule.service
Po uruchomieniu usługi usuń stary wpis z crona, żeby zadania nie wykonywały się dwa razy. Dokumentacja Laravela przedstawia schedule:work głównie jako narzędzie do pracy lokalnej, ale pod nadzorem systemd sprawdza się dobrze. Ma też tę zaletę, że zadania uruchamiane w tle przez runInBackground() działają w ramach tej samej usługi i mają dostęp do tych samych sekretów.
Polecenia uruchamiane ręcznie
Do ręcznych poleceń, takich jak migracje, przygotujmy mały skrypt, który uruchomi Artisana jako tymczasową usługę z sekretami:
cat > /usr/local/bin/sklep-artisan <<'EOF'
#!/bin/bash
if [ -t 0 ]; then mode=--pty; else mode=--pipe; fi
exec systemd-run --quiet --wait --collect "$mode" \
--uid=sklep --gid=sklep \
-p WorkingDirectory=/var/www/sklep \
-p 'ImportCredential=sklep.*' \
/usr/bin/php artisan "$@"
EOF
chmod 0755 /usr/local/bin/sklep-artisan
Skrypt sprawdza, czy działa w interaktywnym terminalu. Jeśli tak, uruchamia polecenie z pełnym terminalem, więc działają pytania o potwierdzenie i tinker. Jeśli nie, na przykład w skrypcie wdrożeniowym, przekazuje wejście i wyjście przez potok. Od teraz migracje uruchamiasz jako root poleceniem:
sklep-artisan migrate --force
Sprzątanie i sprawdzenie efektu
Usuń sekrety z .env
Gdy aplikacja, kolejka, harmonogram i polecenia Artisana działają, usuń z pliku .env wartości APP_KEY, DB_PASSWORD i pozostałych przeniesionych sekretów. Same nazwy zmiennych możesz zostawić puste.
Plik .env nadal przechowuje zwykłą konfigurację, taką jak nazwa bazy, adres serwera czy środowisko. Problemem nigdy nie był sam plik, tylko to, co w nim trzymaliśmy.
Przebuduj cache konfiguracji i zrestartuj usługi:
sklep-artisan config:cache
systemctl restart sklep-fpm.service sklep-queue.service sklep-schedule.service
Teraz sprawdźmy, czy osiągnęliśmy to, co założyliśmy na początku.
Cache konfiguracji jest pusty
Klucz aplikacji i hasło do bazy nie powinny pojawić się w pliku cache:
grep -nE "'(key|password)' =>" /var/www/sklep/bootstrap/cache/config.php
Przy wpisach dotyczących aplikacji i bazy powinieneś zobaczyć puste wartości ('' lub NULL), a nie swoje sekrety. Jeżeli widzisz prawdziwe hasło, provider nie rozpoznał budowania cache. Usuń wtedy plik poleceniem sklep-artisan config:clear i sprawdź, czy metoda isCachingConfiguration() trafiła do wdrożonej wersji kodu.
Środowisko workera nie zawiera sekretów
Zajrzyjmy do środowiska działającego workera PHP:
pid=$(pgrep -f 'php-fpm: pool sklep' | head -1)
tr '\0' '\n' < /proc/$pid/environ
Zobaczysz między innymi CREDENTIALS_DIRECTORY ze ścieżką do katalogu, ale żadnego hasła ani klucza.
Inni użytkownicy nie widzą sekretów
Na koniec sprawdźmy, czy sekrety są niedostępne dla innych użytkowników, na przykład dla nginx:
ls -l /run/credentials/sklep-fpm.service/
sudo -u nginx cat /run/credentials/sklep-fpm.service/sklep.db_password
Pierwsze polecenie pokaże pliki należące do użytkownika sklep. Drugie powinno zakończyć się błędem Permission denied. To dobry wynik: proces nginx działa na tym samym serwerze, obsługuje tę samą aplikację, a mimo to nie ma dostępu do jej hasła.
Jeżeli aplikacja nie korzysta już z puli www w systemowym php-fpm.service, a żadna inna aplikacja jej nie używa, możesz wyłączyć tę usługę.
Sekret, który był w .env, uważaj za ujawniony
To najważniejszy i najczęściej pomijany krok całej migracji.
Usunięcie hasła z pliku .env nie usuwa go z miejsc, do których ten plik zdążył trafić. Stare wartości są w kopiach zapasowych, snapshotach, archiwach i na laptopach. Restic przechowa je w historii przez cały okres retencji. Nie wiesz, kto i kiedy miał do nich dostęp.
Dlatego po migracji wymień sekrety. Dzięki systemd credentials to kilka poleceń, a ta sama procedura posłuży później do regularnej rotacji.
Zmiana hasła do bazy
Wygeneruj nowe hasło w menedżerze haseł, a następnie zaszyfruj je do pliku tymczasowego poza magazynem sekretów:
umask 077
read -rsp 'Nowe hasło do bazy: ' SECRET; echo
printf '%s' "$SECRET" | systemd-creds encrypt --name=sklep.db_password - /root/sklep.db_password.new
unset SECRET
Plik tymczasowy leży poza /etc/credstore.encrypted, ponieważ wszystko, co znajduje się w magazynie i pasuje do wzorca sklep.*, zostałoby wczytane przy najbliższym starcie którejkolwiek z usług.
Teraz zmień hasło w PostgreSQL i od razu podmień sekret oraz zrestartuj usługi:
sudo -u postgres psql -c '\password sklep'
mv /root/sklep.db_password.new /etc/credstore.encrypted/sklep.db_password
systemctl restart sklep-fpm.service sklep-queue.service sklep-schedule.service
Polecenie \password w psql pyta o hasło interaktywnie i wysyła do serwera jego skrót, a nie otwarty tekst. Dzięki temu hasło nie trafi do historii poleceń ani do logów PostgreSQL, jak mogłoby się zdarzyć przy ALTER ROLE ... PASSWORD '...'.
Krótka przerwa przy zmianie hasła
Systemd odszyfrowuje sekrety przy starcie usługi, dlatego potrzebny jest restart, a nie samo przeładowanie. Między zmianą hasła w bazie a restartem nowe połączenia z bazą będą odrzucane. Zwykle trwa to kilka sekund.
Jeżeli aplikacja nie może sobie pozwolić nawet na tak krótką przerwę, stosuje się dwóch użytkowników bazy, z których aplikacja przełącza się z jednego na drugi. To jednak temat na osobny artykuł.
Zmiana APP_KEY bez wylogowania użytkowników
Zmiana klucza aplikacji ma jedną nieprzyjemną konsekwencję: wszystkie ciasteczka zaszyfrowane starym kluczem przestają być ważne, więc użytkownicy zostają wylogowani. Od wersji 11 Laravel rozwiązuje ten problem listą poprzednich kluczy. Nowe dane szyfruje aktualnym kluczem, ale przy odczycie, jeśli aktualny klucz nie pasuje, próbuje kolejno kluczy poprzednich.
Nasz provider już obsługuje tę listę jako sekret sklep.app_previous_keys. Najpierw przepiszemy obecny klucz do roli poprzedniego, bez wyświetlania go na ekranie:
umask 077
systemd-creds decrypt --name=sklep.app_key /etc/credstore.encrypted/sklep.app_key - \
| systemd-creds encrypt --name=sklep.app_previous_keys - /etc/credstore.encrypted/sklep.app_previous_keys
Potem wygenerujemy nowy klucz i zastąpimy nim obecny:
printf 'base64:%s' "$(openssl rand -base64 32)" \
| systemd-creds encrypt --name=sklep.app_key - /root/sklep.app_key.new
mv /root/sklep.app_key.new /etc/credstore.encrypted/sklep.app_key
systemctl restart sklep-fpm.service sklep-queue.service sklep-schedule.service
Laravel domyślnie używa szyfru AES-256-CBC, który wymaga klucza o długości 32 bajtów, i właśnie tyle losowych bajtów generuje openssl rand.
Ponieważ ImportCredential=sklep.* wczytuje wszystkie sekrety aplikacji, nowy plik z poprzednim kluczem trafi do usług bez zmiany konfiguracji. Użytkownicy pozostaną zalogowani.
Kiedy lepiej jednak wylogować wszystkich
Łagodna rotacja ma swoją cenę i trzeba ją znać. Dopóki stary klucz jest na liście poprzednich, aplikacja nadal akceptuje dane nim zaszyfrowane. Dotyczy to także ciasteczek przygotowanych przez atakującego, który ten klucz zna.
Jeżeli migrujesz profilaktycznie i nie masz sygnałów, że klucz wyciekł, krótki okres przejściowy jest rozsądnym kompromisem. Jeżeli jednak masz powód sądzić, że APP_KEY rzeczywiście trafił w niepowołane ręce, na przykład plik .env był dostępny przez przeglądarkę albo znalazł się w publicznym repozytorium, pomiń krok z sklep.app_previous_keys. Wylogowanie wszystkich użytkowników jest wtedy znacznie mniejszym problemem niż pozostawienie otwartej furtki.
Sprzątanie po rotacji
Poprzedni klucz nie powinien zostać na zawsze. Gdy minie czas życia sesji, usuń plik /etc/credstore.encrypted/sklep.app_previous_keys i zrestartuj usługi.
Jeżeli aplikacja przechowuje w bazie dane szyfrowane funkcją encrypt() albo przez rzutowanie encrypted w modelach Eloquent, przed usunięciem starego klucza trzeba je odszyfrować i zaszyfrować ponownie nowym kluczem. Inaczej staną się nieczytelne.
A co z env:encrypt, Vaultem i podobnymi rozwiązaniami?
env:encrypt rozwiązuje inny problem
Laravel ma wbudowane polecenie php artisan env:encrypt, które szyfruje plik .env do postaci .env.encrypted. Pozwala bezpiecznie trzymać konfigurację w repozytorium, ale na serwerze plik i tak jest odszyfrowywany z powrotem do zwykłego .env. Na serwerze nic się więc nie zmienia.
Vault i OpenBao to kolejny poziom
Systemy takie jak HashiCorp Vault czy jego otwarty odpowiednik OpenBao to centralne miejsce przechowywania sekretów, dostęp z audytem i sekrety generowane na żądanie, ważne tylko przez kilka godzin. To właściwy wybór, gdy zarządzasz dziesiątkami serwerów i aplikacji. Dla jednego czy kilku serwerów to jednak osobna infrastruktura, którą trzeba utrzymać, zabezpieczyć i objąć kopią zapasową.
systemd credentials plasuje się pośrodku
systemd credentials nie wymaga żadnej dodatkowej usługi. Jest częścią systemu, którego i tak używasz, a rozwiązuje większość realnych problemów z plikiem .env na pojedynczym serwerze. A jeśli kiedyś przejdziesz na Vaulta, aplikacja nie będzie musiała się zmieniać: sekrety nadal mogą trafiać do niej przez katalog CREDENTIALS_DIRECTORY.
Czego to nie załatwi?
Na koniec uczciwie o ograniczeniach.
Atakujący działający jako aplikacja
Atakujący, który wykona kod jako użytkownik sklep, odczyta sekrety. Aplikacja musi je znać, więc on też je pozna. To, co zbudowaliśmy, ogranicza szkody w każdym innym scenariuszu, ale nie zastąpi aktualizacji, przeglądu kodu ani separacji uprawnień.
Administrator serwera
Atakujący z uprawnieniami roota odczyta wszystko, łącznie z kluczem szyfrującym w /var/lib/systemd. Szyfrowanie sekretów chroni przede wszystkim kopie: zrzuty dysku, kopie zapasowe, wycofane dyski. Nie chroni działającego serwera przed jego administratorem.
Jeżeli chcesz wiedzieć, kto i kiedy zmieniał pliki w magazynie sekretów, możesz objąć katalog /etc/credstore.encrypted regułą auditd, tak jak w artykule o śledzeniu zmian w plikach.
Miejsce, w którym trzymasz oryginał
Sekret jest bezpieczny tylko w takim stopniu, w jakim bezpieczne jest miejsce przechowywania jego oryginału. Menedżer haseł zabezpieczony słabym hasłem przekreśla wszystko, co zrobiliśmy na serwerze.
Podsumowanie
Plik .env nie jest zły. Złe jest trzymanie w nim sekretów, bo wtedy każda kopia tego pliku, każdy błąd w konfiguracji serwera WWW i każde narzędzie, które czyta katalog projektu, staje się potencjalnym wyciekiem.
Po tej zmianie sekrety Laravela są na dysku zaszyfrowane kluczem związanym z serwerem. W czasie działania może je odczytać tylko proces aplikacji, a nie każdy program na tym samym koncie. Nie trafiają do zmiennych środowiskowych ani do cache konfiguracji. Po drodze okazało się, że PHP-FPM wymaga osobnej instancji dla aplikacji, a config:cache potrafi zapisać sekrety na dysku nawet wtedy, gdy nie ma ich w .env. Na koniec zmieniliśmy hasło do bazy i klucz aplikacji tak, że użytkownicy niczego nie zauważyli.
Osobna instancja PHP-FPM działająca jako własny użytkownik to pierwszy krok do czegoś większego: izolowania aplikacji od siebie nawzajem i od reszty systemu. Systemd oferuje do tego cały zestaw mechanizmów, od blokowania zapisu w katalogach systemowych po ograniczanie wywołań systemowych. Jak wykorzystać je, aby błąd w aplikacji PHP nie stał się przejęciem serwera, pokażę w kolejnym artykule.