Detaillierte Erläuterung der häufig verwendeten Filter von Tomcat

1. Domänenübergreifender Filter CorsFilter

org.apcache.catalina.filters.CorsFilter ist eine Implementierung der Spezifikation zur domänenübergreifenden Ressourcenfreigabe, die häufig zur Trennung von Front-End und Back-End, zur Trennung von statischen Ressourcen und Back-End usw. verwendet wird. Es fügt hauptsächlich Access-Control-*-Header zu HttpServletResponse hinzu, schützt HTTP-Antworten vor der Aufteilung und gibt einen 403-Antwortcode zurück, wenn die Anforderung ungültig ist oder der Zugriff verboten ist.

1.1 Konfigurationsbeispiel

<Filter>
  <filter-name>CorsFilter</filter-name>
  <filter-class>org.apache.catalina.filters.CorsFilter</filter-class>
  <Init-Parameter>
    <param-name>cors.allowed.origins</param-name>
    <Paramwert>*</Paramwert>
  </init-param>
  <Init-Parameter>
    <param-name>cors.zulässige.Methoden</param-name>
    <param-value>GET,POST,HEAD,OPTIONEN,PUT</param-value>
  </init-param>
  <Init-Parameter>
    <param-name>cors.allowed.headers</param-name>
    <param-value>Inhaltstyp, X-Angefordert-Mit, akzeptieren, Ursprung, Zugriffskontroll-Anforderungsmethode, Zugriffskontroll-Anforderungsheader</param-value>
  </init-param>
  <Init-Parameter>
    <param-name>cors.exposed.headers</param-name>
    <param-value>Zugriffskontrolle-Erlauben-Ursprung, Zugriffskontrolle-Erlauben-Anmeldeinformationen</param-value>
  </init-param>
  <Init-Parameter>
    <param-name>cors.support.credentials</param-name>
    <param-value>wahr</param-value>
  </init-param>
  <Init-Parameter>
    <param-name>cors.preflight.maxage</param-name>
    <param-Wert>10</param-Wert>
  </init-param>
</filter>
<Filterzuordnung>
  <filter-name>CorsFilter</filter-name>
  <URL-Muster>/*</URL-Muster>
</filter-mapping>

1.2 Parameterbeschreibung

1. cors.erlaubte.Ursprünge

Eine Liste domänenübergreifender Ressourcen, auf die zugegriffen werden darf. „*“ bedeutet, dass der Zugriff auf Ressourcen aus jeder Domäne zulässig ist. Mehrere Domänen werden durch Kommas getrennt. Der Standardwert ist „*“.

2. cors.zulässige.Methoden

Eine Liste von HTTP-Methoden, die zum Zugriff auf Ressourcen verwendet werden können, getrennt durch "," für domänenübergreifende Anforderungen. Diese Methoden werden als Teil des Access-Control-Allow-Methods-Headers der Preflight-Anforderungsantwort angezeigt und der Standardwert ist „GET, POST, HEAD, OPTIONS“.

3. cors.allowed.headers

Die Anforderungsheader, die beim Erstellen einer Anforderung verwendet werden können, sind durch "," getrennt. Diese Methoden werden als Teil des Preflight-Antwortheaders Access-Control-Allow-Headers angezeigt. Der Standardwert ist Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers

4. cors.exposed.headers

Eine durch "," getrennte Liste von Header-Informationen, auf die der Browser zugreifen darf. Diese Methoden werden im Abschnitt „Access-Control-Allow-Headers“ des Preflight-Antwortheaders angezeigt, der standardmäßig leer ist.

5. cors.preflight.maxage

Die Zeit in Sekunden, die der Browser zum Zwischenspeichern des Ergebnisses einer Preflght-Anforderung gewährt. Wenn es eine negative Zahl ist, bedeutet dies, dass CorsFilter der Preflight-Antwort keine Header hinzufügt. Diese Methoden werden als Teil des Preflight-Antwortheaders Access-Control-Max-Age angezeigt, der standardmäßig auf 1800 eingestellt ist.

6. cors.support.credentials

Gibt an, ob die Ressource Benutzeranmeldeinformationen unterstützt. Diese Methoden werden als Teil des Preflight-Antwortheaders Access-Control-Allow-Credentials angezeigt. Der Standardwert ist „true“.

7. cors.request.decorate

Gibt an, ob das Cors-Spezifikationsattribut zu HttpServletRequest hinzugefügt wurde. Der Standardwert ist „true“. CorsFiter fügt anforderungsbezogene Informationen zu HttpServletRequest hinzu. Wenn cors.request.decorate auf true konfiguriert ist, werden die folgenden Eigenschaften hinzugefügt

1) cors.isCorsRequest: wird verwendet, um zu überprüfen, ob es sich bei der Anfrage um eine Cors-Anfrage handelt.

2) cors.request.origin: Quell-URL, die URL der Seite, von der die Anfrage stammt.

3) cors.request.type: Cors-Anforderungstyp wie folgt:

SIMPLE : Eine Anfrage, der eine Nicht-Preflight-Anfrage vorausgeht.

ACTUAL : Eine Anfrage, der eine Preflight-Anfrage vorausging.

PRE_FLIGHT : Preflight-Anforderung

NOT_CORS : Normale Anfrage in derselben Domäne

INVALID_CORS : Ungültige Domänenanforderung

4) cors.request.headers: Anforderungsheaderinformationen, die als Access-Control-Request-Header-Header der Preflight-Anforderung gesendet werden.

2. CSRF-Schutzfilter CsrfPreventionFilter

org.apcache.catalina.filters.CsrfPreventionFilter bietet grundlegenden CSRF-Schutz für Webanwendungen. Alle vom Client zurückgegebenen Links werden über HttpServletResponse.encodeRedirectURL(String) und HttpServletResponse.encodeURL(String) codiert. Der Filter generiert eine Zufallszahl und speichert diese zum Vergleich in der Sitzung. Die URL wird mithilfe der Zufallszahl codiert. Wenn die nächste Anfrage eingeht, wird die Zufallszahl in der Anfrage mit der in der Sitzung verglichen und die Anfrage wird nur zugelassen, wenn beide gleich sind.

2.1 Konfigurationsbeispiel

<Filter>
    <filter-name>CsrfPreventionFilter</filter-name>
    <filter-class>org.apache.catalina.filters.CsrfPreventionFilter</filter-class>
    <Init-Parameter>
        <param-name>denyStatus</param-name>
        <param-value>403</param-value>
    </init-param>
    <Init-Parameter>
        <param-name>Einstiegspunkte</param-name>
        <param-value>/html,/html/liste</param-value>
    </init-param>
    <Init-Parameter>
        <param-name>nonceCacheGröße</param-name>
        <param-Wert>5</param-Wert>
    </init-param>
</filter>
<Filterzuordnung>
    <filter-name>CsrfPreventionFilter</filter-name>
    <URL-Muster>/*</URL-Muster>
</filter-mapping>

2.2 Parameterbeschreibung

1. denyStatus: HTTP-Antwort, die zum Ablehnen der Anforderung verwendet wird. Der Standardwert ist 403

2. entryPoints: Eine Liste von URLs, getrennt durch ",". Diese Listen werden nicht auf Zufallszahlen überprüft (hauptsächlich verwendet, um von der geschützten Anwendung weg zu navigieren und dann zurückzukehren)

wenn ("GET".equals(req.getMethod()) und this.entryPoints.contains(this.getRequestedPath(req))) {
                skipNonceCheck = wahr;
 }

3. nonceCacheSize: Cachegröße für Zufallszahlen. Zuvor veröffentlichte Zufallszahlen werden in einem LRU-Cache zwischengespeichert, um gleichzeitige Anfragen zu unterstützen. Die Verwendung für Browseraktualisierungen (die zu nicht aktuellen Zufallszahlen führen können) ist eingeschränkt. Der Standardwert ist 5.

private int nonceCacheSize = 5;
....
wenn (nonceCache == null) {
    nonceCache = neuer CsrfPreventionFilter.LruCache(diese.nonceCacheSize);
      wenn (Sitzung == null) {
           Sitzung = erforderlich.getSession(true);
       }

    Sitzung.setAttribute("org.apache.catalina.filters.CSRF_NONCE", nonceCache);
}

4. randomClass: Die Klasse, die zum Generieren von Zufallszahlen verwendet wird. Es muss sich um eine Instanz von java.util.Random handeln. Wenn nicht festgelegt, ist der Standardwert java.security.SecureRandom

3. Verhindern Sie den Verlust von Parametern durch den Filter FailedRequestFilter

org.apcache.catalina.filters.FailedRequestFilter wird verwendet, um die Parameteranalyse der Anfrage auszulösen. Wenn die Parameteranalyse fehlschlägt, wird die Anfrage abgelehnt. Dieser Filter wird verwendet, um sicherzustellen, dass die vom Client übermittelten Parameterinformationen nicht verloren gehen. Das Prinzip dieses Filters lautet: Rufen Sie zuerst ServletRequest.getParameter auf (der erste Aufruf löst die Anforderungsparameteranalyse des Tomcat-Servers aus. Wenn die Parameteranalyse fehlschlägt, wird das Ergebnis in das Anforderungsattribut org.apache.catalina.parameter_parse_failed eingefügt). Bestimmen Sie dann den Wert des Attributs org.apache.catalina.parameter_parse_failed und geben Sie direkt 400 zurück, wenn dieser nicht leer ist.

Um die Parameter richtig zu analysieren, müssen Sie vor diesem Filter den Zeichensatzkodierungsfilter SetCharacterEncodingFilter setzen. Darüber hinaus unterstützt dieser Filter nicht den Initialisierungsparameter r

// Bestimmen Sie, ob es sich um eine gültige Anfrage handelt: org.apache.catalina.parameter_parse_failed ist null
private boolean isGoodRequest(ServletRequest-Anfrage) {
    Anfrage.getParameter("keine");
    Rückgabewert request.getAttribute("org.apache.catalina.parameter_parse_failed") == null;
}

4. Holen Sie sich den Client-IP-Filter RemoteAddrFilter

org.apcache.catalina.filters.RemoteAddrFiler ermöglicht den Vergleich der übermittelten Client-IP-Adresse (erhalten über ServletRequest.getRemoteAddr) mit einem angegebenen regulären Ausdruck.

4.1 Konfigurationsbeispiel

<Filter>
    <filter-name>Remote-Adressfilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteAddrFilter</filter-class>
    <Init-Parameter>
    <param-name>erlauben</param-name>
    <param-value>127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:0:1</param-value>
    </init-param>
</filter>
<Filterzuordnung>
    <filter-name>Remote-Adressfilter</filter-name>
    <URL-Muster>/*</URL-Muster>
</filter-mapping>

4.2 Parameterbeschreibung

1. allow: Gibt die Client-IP-Adresse an, die für den Zugriff berechtigt ist

2. deny: Client-Adresse, die den Zugriff verweigert

3. denyStatus: Die HTTP-Antwort, die zurückgegeben wird, wenn die Anforderung abgelehnt wird.

5. Holen Sie sich den Client-Hostfilter RemoteHostFilter

Mit org.apcache.catalina.filters.RemoteHostFiler können Sie den Client-Hostnamen, der eine Anforderung übermittelt, mit einem angegebenen regulären Ausdruck vergleichen, um zu bestimmen, ob die Anforderung fortgesetzt werden darf. Dieselben Parameter wie RemoteAddrFilter

6. Holen Sie sich den ursprünglichen Client-IP-Filter RemoteIpFilter

Wenn ein Client über einen HTTP-Proxy oder Lastenausgleich auf einen Server zugreift, kommt die Anforderung für den Server direkt vom Front-End-Proxyserver. Zu diesem Zeitpunkt ist die erhaltene Remote-IP tatsächlich die IP-Adresse des Proxyservers.

6.1. So erhalten Sie die ursprüngliche Client-IP-Adresse

Das HTTP-Protokoll zeichnet die IP-Adresse des Front-Proxys vom Client zum Anwendungsserver über die Header-Informationen X-Forwarded-For auf. RemoteIpFilter analysiert den Anforderungsheader und ersetzt die IP-Adresse und den Hostnamen in der Anforderung durch die tatsächliche IP-Adresse und Host-Informationen des Clients. Darüber hinaus können der aktuelle Protokollname http/https, der Server-Port und request.secure über den Anforderungsheader X-Forwarded-Proto ersetzt werden.

Das Format von X-Forwarded-For ist wie folgt:

X-Weitergeleitet für: Client, Proxy1, Proxy2

Der Client ganz links ist die ursprüngliche Client-IP. Im obigen Beispiel durchläuft der Client drei Proxy-Ebenen: Proxy1, Proxy2 und Proxy3 (die letzte Ebene, Proxy3, wird nicht angezeigt und wird über ServletRquest.getRemoteAddr abgerufen). Beim Lastenausgleich müssen RemoteAddrFilter und RemoteHostFilter in Verbindung mit diesem Filter verwendet werden, da sonst der Zugriff auf Clients nicht richtig eingeschränkt werden kann.

Normalerweise erhalten wir X-Forwarded-For mit dem folgenden Java-Code:

öffentliche statische Zeichenfolge getIp(HttpServletRequest-Anfrage) {
    Zeichenfolge requestAddr = request.getHeader("x-forwarded-for");
    if (requestAddr == null || requestAddr.length() == 0 || "unbekannt".equalsIgnoreCase(requestAddr)) {
        requestAddr = request.getHeader("Proxy-Client-IP");
    }

    if (requestAddr == null || requestAddr.length() == 0 || "unbekannt".equalsIgnoreCase(requestAddr)) {
        requestAddr = request.getHeader("WL-Proxy-Client-IP");
    }

    if (requestAddr == null || requestAddr.length() == 0 || "unbekannt".equalsIgnoreCase(requestAddr)) {
        requestAddr = request.getRemoteAddr();
    }

    Anfrageadresse zurückgeben;
}

6.2 Konfigurationsbeispiel

1) Grundlegende Verarbeitung der X-Forwarded-For-Headerkonfiguration

<Filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
</filter>

<Filterzuordnung>
    <filter-name>RemoteIpFilter</filter-name>
    <URL-Muster>/*</URL-Muster>
    <dispatcher>ANFRAGE</dispatcher>
</filter-mapping>

2) Verarbeiten der Header-Konfiguration „X-Forwarded-For“ und „x-forwarded-proto“

<Filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <Init-Parameter>
    <param-name>ProtokollHeader</param-name>
    <param-value>x-weitergeleitet-proto</param-value>
    </init-param>
</filter>

<Filterzuordnung>
    <filter-name>RemoteIpFilter</filter-name>
    <URL-Muster>/*</URL-Muster>
    <dispatcher>ANFRAGE</dispatcher>
</filter-mapping>

3) Erweiterte Konfiguration mit internem Proxy

<Filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <Init-Parameter>
        <param-name>erlaubteinterne Proxys</param-name>
        <param-wert>192\.168\.0\.10|192\.168\.0\.11</param-wert>
    </init-param>
    <Init-Parameter>
        <param-name>remoteIpHeader</param-name>
        <param-value>x-weitergeleitet für</param-value>
    </init-param>
    <Init-Parameter>
        <param-name>remoteIpProxiesHeader</param-name>
        <param-value>x-weitergeleitet von</param-value>
    </init-param>
    <Init-Parameter>
        <param-name>ProtokollHeader</param-name>
        <param-value>x-weitergeleitet-proto</param-value>
    </init-param>
</filter>

4) Verwenden Sie die erweiterte Konfiguration eines vertrauenswürdigen Proxys

<Filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <Init-Parameter>
        <param-name>erlaubteinterne Proxys</param-name>
        <param-wert>192\.168\.0\.10|192\.168\.0\.11</param-wert>
    </init-param>
    <Init-Parameter>
        <param-name>remoteIpHeader</param-name>
        <param-value>x-weitergeleitet für</param-value>
    </init-param>
    <Init-Parameter>
        <param-name>remoteIpProxiesHeader</param-name>
        <param-value>x-weitergeleitet von</param-value>
    </init-param>
    <Init-Parameter>
        <param-name>vertrauenswürdige Proxys</param-name>
        <param-value>Proxy1|Proxy2</param-value>
    </init-param>
</filter>

7. Zeichensatzkodierungsfilter SetCharacterEncodingFilter

Bietet eine Möglichkeit, die Zeichensatzkodierung festzulegen. Normalerweise ist die Standardkodierung ISO-8859-1, in der tatsächlichen Produktionsumgebung wird jedoch UTF-8 empfohlen. Die Kodierung in der Anforderung kann verwendet werden, wenn keine Kodierung angegeben ist, oder sie kann zwangsweise überschrieben werden.

7.1 Konfigurationsbeispiel

<Filter>
    <filter-name>Zeichenkodierungsfilter festlegen</filter-name>
    <filter-class>org.apache.catalina.filters.SetCharacterEncodingFilter</filter-class>
    <Init-Parameter>
        <param-name>Kodierung</param-name>
        <param-Wert>UTF-8</param-Wert>
    </init-param>
    <Init-Parameter>
        <param-name>ignorieren</param-name>
        <param-value>falsch</param-value>
    </init-param>
</filter>
<Filterzuordnung>
    <filter-name>Zeichenkodierungsfilter festlegen</filter-name>
    <URL-Muster>/*</URL-Muster>
</filter-mapping>

7.2 Parameterbeschreibung

1. Kodierung: angegebene Zeichensatzkodierung

2. ignore: Gibt an, ob die durch die Client-Anforderung festgelegte Zeichensatzkodierung ignoriert werden soll. Wenn „true“, wird die angeforderte Zeichensatzkodierung überschrieben. Wenn „false“, wird es festgelegt, wenn die Anforderung die Zeichensatzkodierung nicht angibt. Der Standardwert ist „false“.

Oben finden Sie eine ausführliche Erläuterung der häufig verwendeten Filter von Tomcat. Weitere Informationen zu Tomcat-Filtern finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!