# PHP-grunder för administratörer

> PHP-grunder för administratörer utan utvecklarbakgrund: binärer, php.ini-nivåer, FPM-pooler, viktiga kommandon, loggar och en checklista efter PHP2Shell.

Källa: https://phpsos.de/sv/php/php-grundwissen-admins/  
Aktualitet: 2026-10-25  
Leverantör: PHP SOS, PHP-nödhjälp och serversäkerhet. Omedelbar hjälp via WhatsApp: https://wa.me/491736494914?text=Hej%20PHP%20SOS%2C%20vi%20beh%C3%B6ver%20hj%C3%A4lp%20med%20v%C3%A5r%20PHP-server.%20F%C3%B6retag%3A%20%E2%80%A6%20Webbplats%3A%20%E2%80%A6

**Kort sagt:** För administratörer utan utvecklarbakgrund räcker fem grunder för att driva PHP säkert: PHP består av flera program (kommandorad, PHP-FPM, Apache-modul) med var sin version; inställningar verkar i nivåer från php.ini till applikationen; PHP-FPM fördelar förfrågningar på workers i pooler; en uppdatering verkar först efter omstart av alla processer; och loggar är den viktigaste ledtråden när något inte stämmer. Den som kan de här punkterna kan stänga luckor som PHP2Shell snabbt och påvisbart.

## Vad PHP består av på en server

PHP är inte ett enskilt program. På en typisk Linux-server finns flera varianter som var och en är kopplad via ett servergränssnitt (SAPI):

| Variant | Typiskt namn | Till vad |
|---|---|---|
| Kommandorad (CLI) | `php`, `php8.3` | cronjobs, Composer, underhållsskript |
| PHP-FPM | `php-fpm`, `php-fpm8.3` | webbförfrågningar bakom Nginx eller Apache |
| Apache-modul | `mod_php`, `libphp` | webbförfrågningar direkt i Apache-processen |
| CGI | `php-cgi` | äldre uppbyggnader |

Varje variant kan ha en annan version och en annan php.ini. På många servrar körs dessutom flera PHP-versioner parallellt, till exempel 8.2 och 8.4. Vid en uppdatering måste var och en betraktas för sig. Hur gränssnitten fungerar förklarar [PHP-FPM förklarat](https://phpsos.de/sv/php/php-fpm-erklaert/).

Vilken variant som faktiskt betjänar era webbplatser tar ni reda på via de körande processerna och webbserverkonfigurationen:

```bash
ps -eo pid,user,lstart,cmd | grep -E "php|httpd|apache2" | grep -v grep
apachectl -M 2>/dev/null | grep -i php     # laddar Apache en PHP-modul?
ls /run/php/ 2>/dev/null                    # FPM-sockets, ofta per version och pool
```

Kolumnen med starttiden är senare viktig vid omstarten: Alla PHP-processer måste ha startats efter uppdateringens tidpunkt. Körs processer under olika användare tyder det på separata pooler, vilket är bra. Dyker en PHP-modul upp i Apache fast alla webbplatser ska köras via FPM är det ett tecken på en arvedel som bör tas bort. För hostingpaneler som Plesk eller cPanel gäller samma princip, bara att panelen visar versioner och hanterare per webbplats; avgörande förblir dock vad som faktiskt körs som process.

## De viktigaste kommandona för administratörer

```bash
php -v                    # kommandoradens version
php --ini                 # laddad php.ini och ytterligare lästa kataloger
php --ini=diff            # från PHP 8.5: avvikelser från standard
php -m                    # inkompilerade och laddade moduler
php --ri session          # inställningar för ett tillägg
php -l datei.php          # syntaxkontroll utan körning
php-fpm8.3 -v             # FPM-binärens version (namn beroende på distribution)
php-fpm8.3 -t             # testa FPM-konfigurationen utan att starta om
systemctl status php8.3-fpm
```

Två anmärkningar från manualen: `php -l` hittar syntaxfel men inte fel som först uppstår vid körning. Och `php -i` anropar `phpinfo()`; utskriften hör inte hemma i offentliga filer i webbkatalogen.

## Hur PHP-inställningar verkar

En inställning kan sättas på flera ställen. Vem som får ändra vad regleras av varje direktivs ändringsläge:

1. **php.ini och conf.d:** grundkonfiguration per variant, läses vid start.
2. **FPM-pool:** `php_value` och `php_admin_value` per pool. Värden som sätts med `php_admin_value` kan applikationen enligt manualen inte skriva över med `ini_set()`.
3. **Katalognivå:** `.user.ini` vid FPM eller `.htaccess` vid mod_php, bara för direktiv i läget `INI_PERDIR` eller `INI_ALL`.
4. **Applikation:** `ini_set()` vid körning, bara för direktiv i läget `INI_ALL`.

Ett exempel: `memory_limit` har läget `INI_ALL`, kan alltså ändras av applikationen. `post_max_size` har `INI_PERDIR` och går inte att ändra med `ini_set()`. Därför kräver php.net vid PHP2Shell-åtgärderna att värden sätts så att applikationer inte kan skriva över dem. Detaljer om nivåerna förklarar [php.ini förklarad](https://phpsos.de/sv/php/php-ini-erklaert/).

## PHP-FPM-pooler i korthet

En pool är en grupp workers med egen användare, egen socket och egna inställningar. De viktigaste direktiven enligt manualen:

```ini
[shop]
user = shop
group = shop
listen = /run/php/shop.sock
pm = dynamic                 ; static, dynamic eller ondemand
pm.max_children = 20         ; högst 20 samtidiga förfrågningar
pm.max_requests = 500        ; förnya workern efter 500 förfrågningar
request_slowlog_timeout = 5s
slowlog = /var/log/php-fpm/shop-slow.log
php_admin_value[error_log] = /var/log/php-fpm/shop-error.log
php_admin_flag[log_errors] = on
```

En egen pool per webbplats med egen användare skiljer webbplatser åt. `security.limit_extensions` står som standard på `.php .phar` och förhindrar att FPM kör andra filändelser än PHP. `clear_env` är som standard påslaget och håller miljövariabler borta från workern.

## Loggar: var administratörer bör titta

PHP skriver fel till målet som anges med `error_log`, PHP-FPM dessutom till sin egen logg och vid långsamma förfrågningar till slowlog med backtrace. Dessutom finns webbserverns åtkomst- och felloggar. Se till att `display_errors` är avstängt i produktion och `log_errors` påslaget: Fel hör hemma i loggen, inte på webbsidan. Loggar bör dessutom roteras och sparas under en fastställd tid, så att de finns kvar när det gäller. Efter PHP2Shell rekommenderar fackpressen att spara serverloggar från och med den 20 oktober 2026. En stark varningssignal är en PHP-FPM- eller webbserverprocess som startar ett skal; hur ni känner igen det står under [Varningssignal: webbservern startar ett skal](https://phpsos.de/sv/blog/webserver-startet-shell/).

## Checklista för administratörer efter PHP2Shell

1. Lista alla PHP-varianter och versioner på servern, även de som inte används.
2. Kontrollera paketläget; vid backports från distributionen, sök igenom changelogen efter CVE-2026-109618 och CVE-2026-109619.
3. Uppdatera till 8.5.12, 8.4.27, 8.3.36 eller 8.2.35 respektive den bekräftade backporten.
4. Starta om PHP-FPM, Apache och LiteSpeed och kontrollera processernas starttider.
5. Motkontroll med `php -r 'var_dump(ini_get("memory_hard_limit_percent"));'`; `bool(false)` betyder enligt manualen en drabbad version.
6. Säkra loggar och granska dem efter avvikelser.

Hur ni kan belägga version och patchläge tillförlitligt beskriver [Kontrollera PHP-version och patchläge rätt](https://phpsos.de/sv/php2shell/php-version-pruefen/).

## Hur hjälper PHP SOS konkret?

Inom [säkerhetsunderhållsavtalet](https://phpsos.de/sv/leistungen/security-wartungsvertrag/) tar vi över PHP-grundskötseln tillsammans med ert team:

- **Inventarium:** alla PHP-varianter, versioner, pooler och konfigurationsplatser per server.
- **Konfiguration:** säkerhetsrelevanta värden satta med `php_admin_value`, pooler åtskilda per webbplats.
- **Uppdateringar:** installation, omstart, kontroll och dokumentation vid varje säkerhetsrelease.
- **Föra kunskapen vidare:** Vi förklarar för era administratörer vad vi har ändrat och varför.


## Vanliga frågor

**Varför visar php -v en annan version än webbplatsen?**  
Kommandorad, PHP-FPM och Apache-modul är skilda program med egen version och egen php.ini. php -v visar bara kommandoraden. För webbplatsen räknas versionen av den binär som faktiskt hanterar förfrågningar.

**Vilken php.ini gäller på min server?**  
Det visar php --ini för kommandoraden. För PHP-FPM finns oftast en egen php.ini och ytterligare pool-filer. Sedan PHP 8.5 visar php --ini=diff vilka värden som avviker från standard.

**Vad är skillnaden mellan php_value och php_admin_value?**  
Båda sätter inställningar i en FPM-pool. Värden som sätts med php_admin_value kan applikationen enligt manualen inte skriva över med ini_set(). För säkerhetsrelevanta inställningar är php_admin_value därför rätt val.

**Räcker en uppdatering utan omstart?**  
Nej. Körande PHP-processer behåller den gamla koden i minnet. Efter en uppdatering måste PHP-FPM, Apache med mod_php eller LiteSpeed startas om, annars fortsätter den sårbara versionen att köra.

## Källor

- [PHP-manualen: Kommandoradsalternativ](https://www.php.net/manual/en/features.commandline.options.php)
- [PHP-manualen: FPM-konfiguration](https://www.php.net/manual/en/install.fpm.configuration.php)
- [PHP-manualen: Core-inställningar](https://www.php.net/manual/en/ini.core.php)
- [php.net: Säkerhetsmeddelanden](https://www.php.net/)