# expose_php och Server-huvudet: dölj versionsuppgifter

> expose_php, X-Powered-By och Server-huvudet: var PHP och webbservern avslöjar sin version och hur ni stänger av det i php.ini, Nginx och Apache.

Källa: https://phpsos.de/sv/blog/expose-php-versionsangaben/  
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:** Med `expose_php = Off` i php.ini försvinner huvudet `X-Powered-By: PHP/…`. Dit hör `server_tokens off;` i Nginx samt `ServerTokens Prod` och `ServerSignature Off` i Apache. Det gör ingen server säkrare men tar bort en färdig versionslista för automatiserade skanningar. Den egna patchnivån kontrollerar ni därefter via pakethanteraren och processerna, inte via huvuden.

## Visitkortet i varje svar

Den som efter den 21 oktober 2026 ville veta hur många servrar som fortfarande visar en gammal PHP-version behövde inte leta länge. Många webbservrar anger sin PHP-version i varje enskilt svar, till exempel som `X-Powered-By: PHP/8.2.20`. Söktjänster som täcker hela internet läser med dessa uppgifter, och Unit 42 från Palo Alto Networks räknade för PHP2Shell med mer än 22,6 miljoner exponerade, potentiellt sårbara instanser.

För angripare är en sådan uppgift en genväg. De kan förhandssortera mål i stället för att pröva i blindo. För driftansvariga är den däremot värdelös, eftersom den inte ens belägger den egna patchnivån: distributioner levererar rättelser ofta som backport utan nytt versionsnummer.

Det här inlägget visar var PHP och webbservrar avslöjar versionsinformation och hur ni stänger av uppgifterna. Det säger också öppet vad det ger och vad det inte ger.

## Var versionsuppgifter dyker upp

PHP-versionen är bara ett av flera ställen. En fullständig genomgång lönar sig, eftersom ett enda glömt ställe urholkar de andra åtgärderna.

| Fyndplats | Exempel | Stängs av via |
|---|---|---|
| HTTP-huvud från PHP | `X-Powered-By: PHP/8.3.x` | `expose_php = Off` i php.ini |
| HTTP-huvud från webbservern | `Server: nginx/1.x` eller `Server: Apache/2.4.x (Debian)` | `server_tokens off;` respektive `ServerTokens Prod` |
| Webbserverns felsidor | versionsrad under 404- eller 500-sidor | samma inställningar, i Apache dessutom `ServerSignature Off` |
| Huvuden från applikationen | egna `X-Powered-By`-uppgifter från ramverk | `fastcgi_hide_header` respektive `Header unset` |
| Filer i webbroten | `phpinfo()`-testfiler, readme- och changelog-filer | radera eller spärra |
| PHP-felmeddelanden | sökvägar och versionsdetaljer i webbläsaren | `display_errors = Off` |

Testfiler med `phpinfo()` är den givande källan för angripare. De avslöjar inte bara versionen utan hela konfigurationen; mer om det i inlägget [phpinfo()-filer: varför de måste bort](https://phpsos.de/sv/blog/phpinfo-dateien-entfernen/).

## Stäng av expose_php i php.ini

Enligt PHP-manualen är `expose_php` påslagen som standard och kan bara ändras i php.ini, inte i poolen, inte via `.htaccess` och inte vid körning. Sätt därför värdet i php.ini för varje driftläge som levererar webbplatser, alltså på Debian och Ubuntu till exempel under `/etc/php/<version>/fpm/` och eventuellt `/etc/php/<version>/apache2/`.

```ini
; php.ini för webb-SAPI, starta därefter om PHP-FPM respektive Apache
expose_php = Off
```

Körs flera PHP-versioner parallellt behöver var och en sin post. En omstart av respektive tjänst är obligatorisk, eftersom PHP läser php.ini bara vid start.

## Korta Server-huvuden i Nginx och Apache

Nginx anger som standard sin version i `Server`-huvudet och på felsidor. Med `server_tokens off;` återstår bara produktnamnet. Dessutom går ett `X-Powered-By`-huvud som applikationen själv sätter att filtrera bort med `fastcgi_hide_header`. Enligt Nginx-dokumentationen döljer Nginx av sig självt bara `Status` och `X-Accel-…`, inte `X-Powered-By`.

```nginx
# i http-blocket, gäller för alla webbplatser
server_tokens off;
fastcgi_hide_header X-Powered-By;
```

I Apache styr `ServerTokens` `Server`-huvudet och samtidigt versionsraden under felsidor. Inställningen gäller enligt Apache-dokumentationen bara servergemensamt, inte per VirtualHost. Eftersom PHP-FPM-svar via `mod_proxy_fcgi` hamnar i en annan huvudtabell än svar från servern själv sätter ni borttagningen i båda varianterna.

```apache
# servergemensam konfiguration, t.ex. /etc/apache2/conf-available/security.conf
ServerTokens Prod
ServerSignature Off

# kräver mod_headers
<IfModule mod_headers.c>
    Header unset X-Powered-By
    Header always unset X-Powered-By
</IfModule>
```

Kontrollera konfigurationen före omladdningen med `nginx -t` respektive `apachectl configtest`. Hur ni via huvuden aktivt slår på skydd för besökare, till exempel med HSTS eller en Content-Security-Policy, beskriver guiden [Säkerhetsrubriker för webbplatser](https://phpsos.de/sv/ratgeber/sicherheits-header/).

## Så kontrollerar ni resultatet utifrån

Kontrollera efter omställningen varje domän för sig, helst även en felsida. Kommandona nedan skickar bara normala förfrågningar till era egna webbplatser:

```bash
# Huvuden för startsidan
curl -sI https://www.example.de/ | grep -iE '^(server|x-powered-by):'
# Huvuden för en sida som inte finns
curl -sI https://www.example.de/gibt-es-nicht-4711 | grep -iE '^(server|x-powered-by):'
```

Förväntat är ett `Server`-huvud utan versionsnummer och inget `X-Powered-By`. Står där fortfarande en PHP-version är oftast en annan php.ini aktiv eller en tjänst ännu inte omstartad. Ligger ett CDN framför servern kontrollerar ni dessutom ursprungsservern direkt, i den mån den är nåbar.

> **Tips:**
> Notera ändå PHP-versionen internt: i er serverinventering, med paketversion och datum för senaste kontroll. Patchnivån belägger ni via servern, som beskrivs i [Kontrollera PHP-version och patchnivå rätt](https://phpsos.de/sv/php2shell/php-version-pruefen/).

## Vad döljandet ger och vad det inte ger

Ärligt bedömt är avstängningen av versionsuppgifter en liten åtgärd med låg arbetsinsats. Den minskar sannolikheten att dyka upp i riktade sökningar efter vissa versioner och minskar den information som en angripare får utan ansträngning.

Men den skyddar inte mot automatiserade angrepp som helt enkelt skickar sina förfrågningar till varje nåbar server. Hur sådana massskanningar går till beskriver inlägget [Massskanningar efter ej patchad PHP](https://phpsos.de/sv/blog/automatisierte-massenscans/). Mot PHP2Shell hjälper bara uppdateringen till PHP 8.5.12, 8.4.27, 8.3.36 eller 8.2.35 respektive en bekräftad backport, följd av omstart av alla PHP-processer.

En bieffekt är däremot utpräglat nyttig: den som stänger av versionsuppgifter utåt måste föra ordentlig förteckning över sina versioner internt. I ett läge som PHP2Shell avgör just den överblicken hur snabbt ni vet vilka servrar som berörs.

Döljandet är därför meningsfullt som en del av en grundhärdning, inte som enskild åtgärd. Det hör hemma i samma checklista som avstängda felutskrifter, raderade testfiler och spärrade konfigurationsvärden.

## Hur hjälper PHP SOS konkret?

- **Kartlägga fyndplatser:** Vi kontrollerar huvuden, felsidor och webbrot för alla domäner efter versionsuppgifter och bortglömda testfiler.
- **Anpassa konfigurationen:** Vi sätter `expose_php`, Server-huvuden och huvudfilter i varje PHP-version och varje webbserver och startar om tjänsterna kontrollerat.
- **Belägga patchnivån internt:** Vi dokumenterar versioner och paketversioner där de hör hemma, i inventeringen i stället för i HTTP-huvudet.
- **Bädda in i härdningen:** Åtgärden är en del av vår [serverhärdning för PHP-webbservrar](https://phpsos.de/sv/leistungen/server-haertung/).


## Vanliga frågor

**Gör expose_php = Off min server säker?**  
Nej. Inställningen tar bara bort versionsuppgiften ur HTTP-huvudet. En sårbar PHP-version förblir sårbar, och automatiserade angrepp skickar ofta ändå sina förfrågningar till varje nåbar server. Men ni tar bort en enkel förhandsurvalsmöjlighet för angripare och minskar synligheten i sökmotorer för servrar.

**Kan jag sätta expose_php i FPM-poolen eller via .htaccess?**  
Enligt PHP-manualen kan expose_php bara ändras i php.ini. Sätt därför värdet i php.ini för varje webb-SAPI och starta därefter om PHP-FPM eller Apache.

**Varför ser jag X-Powered-By trots expose_php = Off?**  
Då sätter oftast applikationen eller ett ramverk huvudet själv, eller så är en annan php.ini aktiv. Ta dessutom bort huvudet i webbservern: med fastcgi_hide_header i Nginx eller Header unset i Apache.

**Hur kontrollerar jag min patchnivå när versionen inte längre syns?**  
Via servern själv: pakethanteraren, paketets changelog med CVE-numren och starttiden för PHP-processerna. Uppgiften i HTTP-huvudet var ändå inget belägg, eftersom distributioner ofta levererar backports utan nytt versionsnummer.

## Källor

- [PHP-manualen: kärninställningar (expose_php)](https://www.php.net/manual/en/ini.core.php)
- [Nginx: server_tokens (ngx_http_core_module)](https://nginx.org/en/docs/http/ngx_http_core_module.html)
- [Apache: ServerTokens och ServerSignature](https://httpd.apache.org/docs/2.4/mod/core.html)
- [OWASP Cheat Sheets](https://cheatsheetseries.owasp.org/)