HTTP-Konfiguration
******************

.[perex]
Übersicht der Konfigurationsoptionen für Nette HTTP.

Wenn Sie nicht das gesamte Framework, sondern nur diese Bibliothek verwenden, lesen Sie, [wie man die Konfiguration lädt |bootstrap:].


HTTP-Header
===========

```neon
http:
	# Header, die mit jeder Response gesendet werden
	headers:
		X-Powered-By: MyCMS
		X-Content-Type-Options: nosniff
		X-XSS-Protection: '1; mode=block'

	# beeinflusst den Header X-Frame-Options
	frames: ...      # (string|bool|null) Standardwert ist 'SAMEORIGIN'
```

Aus Sicherheitsgründen sendet das Framework den Header `X-Frame-Options: SAMEORIGIN`, der besagt, dass eine Seite nur dann innerhalb einer anderen Seite (in einem `<iframe>`-Element) angezeigt werden darf, wenn sie auf derselben Domain liegt. In bestimmten Situationen kann das unerwünscht sein (etwa wenn Sie eine Facebook-Anwendung entwickeln), das Verhalten lässt sich also ändern: `frames: http://allowed-host.com` erlaubt einen bestimmten Host, `frames: true` erlaubt das Einbetten von überall (der Header entfällt) und `frames: false` verbietet es vollständig (`X-Frame-Options: DENY`).

Standardmäßig sendet Nette außerdem die Header `X-Powered-By: Nette Framework 3` und `Content-Type: text/html; charset=utf-8`. Jeden Header, auch diese Standardheader, können Sie entfernen, indem Sie seinen Wert auf einen leeren String setzen.


Content Security Policy
-----------------------

Die Header `Content-Security-Policy` (CSP) lassen sich leicht konfigurieren; ihre Beschreibung finden Sie in der [CSP-Spezifikation |https://content-security-policy.com]. CSP-Direktiven (etwa `script-src`) können entweder als Strings gemäß der Spezifikation oder für die bessere Lesbarkeit als Arrays von Werten geschrieben werden. Dann müssen um Schlüsselwörter wie `'self'` keine Anführungszeichen gesetzt werden. Nette erzeugt außerdem automatisch einen `nonce`-Wert, sodass im Header etwa `'nonce-y4PopTLM=='` gesendet wird.

```neon
http:
	# Content Security Policy
	csp:
		# String gemäß der CSP-Spezifikation
		default-src: "'self' https://example.com"

		# Array von Werten
		script-src:
			- nonce
			- strict-dynamic
			- self
			- https://example.com

		# bool im Fall von Schaltern
		upgrade-insecure-requests: true
		block-all-mixed-content: false
```

Verwenden Sie in Templates `<script n:nonce>...</script>`, und der nonce-Wert wird automatisch eingesetzt. Sichere Websites in Nette zu bauen ist wirklich einfach.

Ähnlich lassen sich die Header `Content-Security-Policy-Report-Only` (die parallel zu CSP verwendet werden können) und die [Feature Policy |https://developers.google.com/web/updates/2018/06/feature-policy] konfigurieren:

```neon
http:
	# Content Security Policy Report-Only
	cspReportOnly:
		default-src: self
		report-uri: 'https://my-report-uri-endpoint'

	# Feature Policy
	featurePolicy:
		unsized-media: none
		geolocation:
			- self
			- https://example.com
```


HTTP-Cookie
-----------

Sie können die Standardwerte einiger Parameter der Methode [Nette\Http\Response::setCookie() |response#setCookie()] und der Session-Behandlung ändern.

```neon
http:
	# Gültigkeitsbereich des Cookies nach Pfad
	cookiePath: ...          # (string) Standardwert ist '/'

	# Domains, die das Cookie empfangen dürfen
	cookieDomain: 'example.com'  # (string|domain) standardmäßig nicht gesetzt

	# Cookies nur über HTTPS senden?
	cookieSecure: ...        # (bool|auto) Standardwert ist auto

	# schaltet das Senden des Cookies ab, das Nette zum CSRF-Schutz verwendet
	disableNetteCookie: ...  # (bool) Standardwert ist false
```

Das Attribut `cookieDomain` bestimmt, welche Domains (Origins) das Cookie annehmen dürfen. Wird es nicht angegeben, nimmt es dieselbe (Sub-)Domain an, die es gesetzt hat, *ohne* deren Subdomains. Ist `cookieDomain` angegeben, sind auch die Subdomains eingeschlossen. Die Angabe von `cookieDomain` ist also weniger einschränkend als ihr Weglassen.

Ist zum Beispiel `cookieDomain: nette.org` gesetzt, sind die Cookies auch auf allen Subdomains wie `doc.nette.org` verfügbar. Dasselbe erreichen Sie mit dem speziellen Wert `domain`, also `cookieDomain: domain`.

Der Standardwert `auto` beim Attribut `cookieSecure` bedeutet, dass die Cookies mit dem Flag `Secure` gesendet werden und damit nur über HTTPS verfügbar sind, wenn die Website über HTTPS läuft.


HTTP-Proxy
----------

Läuft die Site hinter einem HTTP-Proxy, geben Sie die IP-Adresse des Proxys an, damit die Erkennung der HTTPS-Verbindung und der IP-Adresse des Clients korrekt funktioniert. Also damit [Nette\Http\Request::getRemoteAddress() |request#getRemoteAddress()] und [isSecured() |request#isSecured()] die richtigen Werte zurückgeben und die Links in Templates mit dem Protokoll `https:` erzeugt werden.

```neon
http:
	# IP-Adresse, Bereich (z. B. 127.0.0.1/8) oder ein Array dieser Werte
	proxy: 127.0.0.1       # (string|string[]) standardmäßig nicht gesetzt
```


HTTPS erzwingen .{data-version:3.3.4}
-------------------------------------

Erzwingt bedingungslos das Schema HTTPS für den Request. Das ist nützlich für reine HTTPS-Sites, die hinter einem Load Balancer oder Reverse Proxy laufen, der TLS terminiert, aber den Header `X-Forwarded-Proto` nicht weitergibt, sodass die übliche HTTPS-Erkennung (auch mit konfiguriertem [#HTTP-Proxy]) das nicht bemerken würde.

```neon
http:
	# HTTPS-Schema für alle Requests erzwingen
	forceHttps: true       # (bool) Standardwert ist false
```


Session
=======

Grundlegende Einstellungen der [Sessions |sessions]:

```neon
session:
	# das Session-Panel in der Tracy Bar anzeigen?
	debugger: ...        # (bool) Standardwert ist false

	# Zeit der Inaktivität, nach der die Session abläuft
	expiration: 14 days  # (string) Standardwert ist '3 hours'

	# wann soll die Session starten?
	autoStart: ...       # (smart|always|never) Standardwert ist 'smart'

	# Handler, ein Service, der SessionHandlerInterface implementiert
	handler: @handlerService
```

Die Option `autoStart` steuert, wann die Session starten soll. Der Wert `always` bedeutet, dass die Session immer beim Start der Anwendung startet. Der Wert `smart` bedeutet, dass die Session mit der Anwendung nur dann startet, wenn sie bereits existiert, oder in dem Moment, in dem wir aus ihr lesen oder in sie schreiben wollen. Der Wert `never` schließlich schaltet den automatischen Start der Session ab.

Darüber hinaus können Sie alle [Session-Direktiven |https://www.php.net/manual/en/session.configuration.php] von PHP setzen (im camelCase-Format) und außerdem [readAndClose |https://www.php.net/manual/en/function.session-start.php#refsect1-function.session-start-parameters]. Beispiel:

```neon
session:
	# 'session.name' geschrieben als 'name'
	name: MYID

	# 'session.save_path' geschrieben als 'savePath'
	savePath: "%tempDir%/sessions"
```


Session-Cookie
--------------

Das Session-Cookie wird mit denselben Parametern gesendet wie [andere Cookies |#HTTP-Cookie], Sie können sie aber speziell dafür ändern:

```neon
session:
	# Domains, die das Cookie empfangen dürfen
	cookieDomain: 'example.com'   # (string|domain)

	# Einschränkung für den Cross-Origin-Zugriff
	cookieSamesite: None          # (Strict|Lax|None) Standardwert ist Lax
```

Das Attribut `cookieSamesite` beeinflusst, ob das Cookie bei [Cross-Origin-Requests |nette:glossary#SameSite-Cookie] gesendet wird, was einen gewissen Schutz gegen Angriffe vom Typ [Cross-Site Request Forgery |nette:glossary#Cross-Site Request Forgery (CSRF)] (CSRF) bietet.


DI-Services
===========

Diese Services werden dem DI-Container hinzugefügt:

| Name            | Typ                        | Beschreibung
|-----------------|----------------------------|---------------------------
| `http.request`  | [api:Nette\Http\Request]   | [HTTP-Request |request]
| `http.response` | [api:Nette\Http\Response]  | [HTTP-Response |response]
| `session.session`| [api:Nette\Http\Session]   | [Session-Verwaltung |sessions]
| `http.requestFactory`| [api:Nette\Http\RequestFactory] | Factory, die den HTTP-Request erzeugt