# CGI och FastCGI: grunderna

> CGI och FastCGI med PHP förklarat: process per förfrågan eller permanenta workers, rollen för php-cgi och PHP-FPM, cgi-inställningar och säkerhetsregler.

Källa: https://phpsos.de/sv/php/cgi-und-fastcgi/  
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:** CGI (Common Gateway Interface) är ett gammalt gränssnitt där webbservern startar ett nytt program för varje förfrågan, för PHP programmet `php-cgi`. FastCGI är vidareutvecklingen: PHP-processer körs permanent och tar emot många förfrågningar via en socket. PHP-FPM är den viktigaste FastCGI-implementeringen för PHP. Säkerhetsmässigt viktigast är `cgi.*`-inställningarna och regeln att en FastCGI-åtkomst aldrig får vara offentligt nåbar.

## Vad är CGI?

CGI är en av de äldsta metoderna för webbservrar att skapa dynamiskt innehåll. PHP-manualen hänvisar vid inställningen `cgi.rfc2616_headers` till RFC 3875, specifikationen för Common Gateway Interface. Även PHP:s begynnelse var CGI-program: Rasmus Lerdorf skrev 1994 de första ”Personal Home Page Tools” som CGI-binärfiler i C.

Principen: För varje förfrågan startar webbservern en ny process, lämnar över förfrågningsdata via miljövariabler och standardindata och läser svaret från standardutdata. Därefter avslutas processen. Enligt PHP-manualen läser PHP med CGI och CLI sin php.ini på nytt vid varje anrop, med servermoduler bara vid start.

Det gör CGI robust, eftersom varje förfrågan börjar med en färsk process. Men det gör CGI också långsamt: processtart, inläsning av konfiguration och initiering av tillägg kostar tid vid varje förfrågan.

## Vad är FastCGI?

FastCGI löser prestandaproblemet genom att processer hålls vid liv. Webbservern ansluter via en Unix-socket eller en TCP-port till en körande process och skickar förfrågan till den i FastCGI-protokollet. Processen bearbetar den och väntar på nästa.

| Kännetecken | CGI | FastCGI med php-cgi | FastCGI med PHP-FPM |
|---|---|---|---|
| Process per förfrågan | ja | nej | nej |
| SAPI-namn | `cgi-fcgi` | `cgi-fcgi` | `fpm-fcgi` |
| Pooler med egen användare | nej | nej | ja |
| Processtyrning | webbservern | webbservermodul, t.ex. mod_fcgid | egen masterprocess |
| `.user.ini` läses | ja | ja | ja |

PHP-FPM är enligt manualen PHP:s primära FastCGI-implementering. Den kompletterar protokollet med processförvaltning, pooler, statussidor och en slowlog. Detaljerna står under [PHP-FPM förklarat](https://phpsos.de/sv/php/php-fpm-erklaert/).

## cgi-inställningarna i php.ini

För CGI-drift har PHP egna inställningar. Följande värden och beskrivningar kommer från PHP-manualen:

1. **`cgi.force_redirect`** (standard 1, `INI_SYSTEM`): enligt manualen nödvändig för att driva PHP som CGI säkert under de flesta webbservrar. Stäng av endast ”på egen risk”; under IIS måste den vara avstängd.
2. **`cgi.fix_pathinfo`** (standard 1, `INI_SYSTEM`): ger korrekta värden för `PATH_INFO` och `PATH_TRANSLATED`. Skript ska använda `SCRIPT_FILENAME` i stället för `PATH_TRANSLATED`.
3. **`cgi.discard_path`** (standard 0, `INI_SYSTEM`): gör det möjligt att lägga CGI-binärfilen säkert utanför webbkatalogen utan att `.htaccess`-skydd kan kringgås.
4. **`fastcgi.impersonate`** (standard 0, `INI_SYSTEM`): relevant bara för IIS under Windows.
5. **`user_ini.filename`** och **`user_ini.cache_ttl`** (standard `.user.ini` och 300 sekunder): styr om och hur ofta PHP läser `.user.ini`-filer.

Med Nginx hör en ren överlämning av skriptsökvägen till. Ett läsbart grundmönster, utan garanti för varje miljö:

```nginx
location ~ \.php$ {
    try_files $uri =404;               # lämna bara befintliga filer till PHP
    fastcgi_pass unix:/run/php/php8.3-fpm.sock;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
}
```

Raden `try_files $uri =404;` förhindrar att förfrågningar till obefintliga `.php`-sökvägar förs vidare till PHP.

## Varför en öppen FastCGI-åtkomst är farlig

PHP-manualen varnar uttryckligen: Den som kan öppna en FastCGI-anslutning till PHP styr förfrågans konfiguration, till exempel `auto_prepend_file`, och kan därmed köra godtycklig kod. Orsaken är att webbservrar får skicka med PHP-inställningar via FastCGI-parametrar som `PHP_VALUE` och `PHP_ADMIN_VALUE`.

Därav följer tydliga regler:

- Koppla PHP-FPM eller php-cgi i FastCGI-läge enbart via en Unix-socket om webbservern körs på samma värd.
- Sätt `listen.allowed_clients` vid TCP och spärra porten i brandväggen; tips om detta finns i artikeln [Brandvägg för webbservrar](https://phpsos.de/sv/blog/firewall-fuer-webserver/).
- Håll socketrättigheterna snäva med `listen.owner`, `listen.group` och `listen.mode`.

> **Viktigt:**
> Kontrollera med `ss -lntp | grep -i php` om någon PHP-process lyssnar på en TCP-adress. En bindning till `0.0.0.0` eller en offentlig adress är ett brådskande åtgärdsfall.

## CGI, FastCGI och PHP2Shell

Av PHP2Shell berörs både php-cgi och PHP-FPM. För båda gäller: uppdatera till 8.5.12, 8.4.27, 8.3.36 eller 8.2.35 respektive en bekräftad backport och avsluta och starta sedan om alla körande PHP-processer. I FastCGI-miljöer med php-cgi fortsätter processer ofta att köras obemärkta, eftersom ingen egen tjänst förvaltar dem. Hur ni hittar och avvecklar den här gamla belastningen står under [php-cgi: gammal belastning med risk](https://phpsos.de/sv/server/php-cgi/). I Plesk heter varianterna annorlunda; hjälp finns i [Plesk: förstå PHP-hanterare](https://phpsos.de/sv/blog/plesk-php-handler/).

## Hur hjälper PHP SOS konkret?

- **Kartlägga hanterare:** Vi tar reda på om era webbplatser körs via CGI, FastCGI med php-cgi eller PHP-FPM.
- **Stänga åtkomster:** Vi granskar sockets, portar och brandväggsregler så att ingen FastCGI-åtkomst kan nås utifrån.
- **Patcha och städa upp:** Vi uppdaterar PHP och avslutar alla gamla processer, även övergivna php-cgi-instanser.
- **Avveckla:** Inom ramen för [serverhärdning](https://phpsos.de/sv/leistungen/server-haertung/) ersätter vi CGI-rester med PHP-FPM med egna pooler.


## Vanliga frågor

**Är FastCGI detsamma som PHP-FPM?**  
Nej. FastCGI är ett protokoll som en webbserver använder för att tala med en applikationsprocess. PHP-FPM är ett program som genomför protokollet för PHP och förvaltar processerna. Även php-cgi kan tala FastCGI men saknar pooler.

**Varför anses rent CGI vara föråldrat?**  
Med CGI startar webbservern en ny process för varje förfrågan, och PHP läser då varje gång sin konfiguration. Det kostar tid och resurser. FastCGI och PHP-FPM håller processer permanent redo och är därför betydligt effektivare.

**Vad är en .user.ini?**  
En .user.ini är en liten konfigurationsfil i en webbkatalog. Enligt PHP-manualen läses den bara av CGI- och FastCGI-SAPI, alltså även av PHP-FPM. Den får bara innehålla inställningar med lägena INI_PERDIR, INI_USER eller INI_ALL.

**Hur ser jag om php-cgi körs på min server?**  
Sök med läsande kommandon som ps eller pgrep efter processer som heter php-cgi och leta i webbserverns konfiguration efter poster som mod_fcgid, Action eller ScriptAlias med php-cgi. I hostingpaneler heter driftläget ofta CGI eller FastCGI-applikation.

## Källor

- [PHP-manualen: kärninställningar (cgi.*)](https://www.php.net/manual/en/ini.core.php)
- [PHP-manualen: .user.ini-filer](https://www.php.net/manual/en/configuration.file.per-user.php)
- [PHP-manualen: FPM-konfiguration](https://www.php.net/manual/en/install.fpm.configuration.php)
- [Nginx-dokumentationen](https://nginx.org/en/docs/)