Traffic Cop - Dokumentáció

¶Bevezetés

A Traffic Cop egy biztonsági WordPress bővítmény, amely első sorban fejlesztőknek, üzemeltetőknek készült. Az alábbi oldalon a bővítmény - első sorban - technikai dokumentációja található.

¶Licenc beszerzése és beállítások

A licenc beszerzését és a beállításokat a telepítés előtt kell elvégeznünk.

• Regisztráció a Shop-ban
• Megerősítő linkre kattintás az kapott email-ben
• Bejelentkezés a Shop-ba
• Számlázási profil létrehozása a Shop-ban
• Termék vásárlás a Shop-ban
• Fizetés bankkártyával vagy átutalással
• Licenc kiválasztása a Shop-ban
• Licenc aktiválás WordPress URL (nem a Site Address) beírással a Shop-ba
• Bővítmény letöltése a Shop-ból
• Bővítmény feltöltése és aktiválása WordPress-ben
• Licenc kulcs kimásolás a Shop-ból
• Licenc kulcs beállítás WordPress-ben

¶Licenc vásárlása

A bővítményt licenc formájában lehet megvásárolni. A vásárlást a Cone Shop felületén lehet megtenni: https://shop.conedevelopment.com/traffic-cop. Regisztráció, bejelentkezés, majd a számlázási adatok megadása után a kívánt oldalszámban lehet licencet vásárolni.

A vásárlást követően a rendszer automatikusan létrehozza a licenc kulcsot, amelyhez előbb aktiválni kell az áruház URL-jét, majd a bővítmény telepítése után meg kell adni a licenckulcsot.

¶URL/domain aktiválása

A korábban vásárolt licenceket a https://shop.conedevelopment.com/account/licenses linken érjük el.

Egy-egy licencen belül hozzá tudjuk rendelni áruházunk URL-jét a licenc kulcshoz, így a későbbi aktiválás sikeresen megtörtént.

¶Telepítés

A telepítést a beszerzés és a beállítások elvégzése után tudjuk elvégezni.

¶WordPress bővítménykezelőn keresztül

A licenc beállítás oldalán a kívánt verziót kiválasztva letölthetjük a bővítményt, amelyet már telepíteni lehet a WordPress példányra.

Letöltés után keressük meg a letöltött .zip fájlt és töltsük fel a kiszemelt WordPress példányra.

1. Navigáljunk a Bővítmények / Új hozzáadása menüpontra.
2. Kattintsunk felül a címsorban található Bővítmény feltöltése gombra.
3. Az újonnan kinyílt szekcióban kattintsunk a fájl kiválasztására, majd tallózzuk be a korábban letöltött fájlt.
4. Kattintsunk a Telepítés most gombra.

A feltöltés után kapunk egy képernyőt, ahol láthatjuk, hogy a bővítményt sikeresen telepítettük. Ez csupán egy egyszerű oldal, ahol a telepítés folyamatait tudjuk végigkísérni.

Ahogy ezen a képernyőn láthatod, egyből tudod is aktiválni. Kattints a Bővítmény bekapcsolása gombra és már fut is a bővítmény.

Ha elmulasztod az aktiválást ezen az oldalon, akkor a Bővítmények / Telepített bővítmények menüpont alatt mindig tudod aktiválni (ki/be kapcsolni, törölni, frissíteni).

A bővítmény beállításait a Bővítmények / Telepített bővítmények / Traffic Cop alatt található a Beállítások link alatt találod meg.

Itt tudod hozzárendelni a licenc kulcsot a bővítményhez. Ez fontos lépés, mert érvényesítés nélkül nem működik a bővítmény, illetve frissítéseket sem lehet letölteni a WordPress rendszerén keresztül.

¶Composer csomagkezelőn keresztül

A Composer egy elterjedt csomagkezelő PHP alkalmazásokhoz. Előfordul, hogy a WordPress példányt és annak függőségeit Composer-rel szeretnénk kezelni.

Az alábbi minta composer.json bemutatja, hogy a conedevelopment/traffic-cop repository-t hogyan szükséges paraméterezni, hogy a megfelelő helyről töltse le a kívánt állományt.

{
    "name": "conedevelopment/example-wp-composer",
    "description": "Example WordPress with Composer",
    "license": "MIT",
    "require": {
        "php": "^8.3.0",
        "conedevelopment/traffic-cop": "^1.3.3",
        "roots/wordpress": "^6.6.0"
    },
    "minimum-stability": "beta",
    "config": {
        "preferred-install": {
            "*": "dist"
        },
        "allow-plugins": {
            "composer/installers": true,
            "ffraenz/private-composer-installer": true,
            "roots/wordpress-core-installer": true
        }
    },
    "extra": {
        "installer-paths": {
            "wp-content/mu-plugins/{$name}/": [
                "type:wordpress-muplugin"
            ],
            "wp-content/plugins/{$name}/": [
                "type:wordpress-plugin"
            ],
            "wp-content/themes/{$name}/": [
                "type:wordpress-theme"
            ]
        }
    },
    "repositories": [
        {
            "type": "composer",
            "url": "https://wpackagist.org"
        },
        {
            "type": "package",
            "package": {
                "name": "conedevelopment/traffic-cop",
                "version": "1.3.3",
                "type": "wordpress-plugin",
                "dist": {
                    "type": "zip",
                    "url": "https://shop.conedevelopment.com/api/packages/{%CONE_LICENSE_KEY}/download?version=v{%VERSION}"
                },
                "require": {
                    "composer/installers": "^2.3.0",
                    "ffraenz/private-composer-installer": "^5.0"
                }
            }
        }
    ]
}

A {%VERSION} változó a version kulcs értékét adja vissza, jelen esetben a 1.3.3-t. A {%CONE_LICENSE_KEY} értékét viszont nem javasolt közvetlenül a composer.json-ban tárolni (főleg ha ez a git-ben is tárolva van), hanem érdemes valamilyen környezeti változóba szervezni. Ez lehet egy .env változó, vagy valamilyen CI (GitHub Actions, GitLab CI, stb.) környezeti változója:

# Nem valós licenc kulcs!

CONE_LICENSE_KEY=eb819bed-ba18-4e60-9d95-d6d6b5d4364c

¶WAF

A WAF (Web Application Firewall) funkció lényege, hogy a HTTP kéréseket bizonyos szabályok alapján szűrje, és azok a kéréseket amelyek fennakadnak a szűrőn blokkolja, mielőtt terhelést jelentene a szerverre.

Ideális esetben ez a funkció nem a WordPress-en belül van megoldva, de osztott tárhelyek esetén gyakran előfordul, hogy a WAF nem elérhető, így egy alternatív megoldásra van szükség. A bővítmény ezt az alternatívát kínálja.

A működése nagyon egyszerű: a beérkező HTTP kéréseket a megadott szabályok alapján elemzi és amennyiben valamelyik kritériumnak nem felel meg a kérés, úgy 403-as (Forbidden) HTTP választ ad a bővítmény, így minimalizálva a terhelést és a biztosági kockázatot a szerveren.

A szabályok rétegenként épülnek fel, így akár több szabály is alkalmazásra kerülhet egy kérés esetén. Például egy kérés esetén először az IP szabály kerül ellenőrzésre, majd ha az megfelel a kritériumnak, akkor az URI szabály kerül ellenőrzésre és így tovább.

A szabályok egyenként ki- és bekapcsolhatóak, így testre szabható a védelem mértéke. Ehhez a traffic-cop/waf/rule_enabled filtert lehet használni.

¶Alapértelmezett WAF Szabályok

• IP szabály: egy ~10 éve, folyamatosan frissen tartott IP cím listából dolgozik, amely lista a kártyékony HTTP kéréseket küldő IP címeket tartalmazza. A szabály lényege, hogy amennyiben a kérés IP címe szerepel a listában, úgy a kérés blokkolásra kerül.
• URI szabály: egy előre definiált URI "feketlistából" dolgozik, amelyek tipikusan érzékeny URI-kat tartalmaznak. A szabály lényege, hogy amennyiben a kérés URI-ja szerepel a listában, úgy a kérés blokkolásra kerül.
• User Agent szabály: egy előre definiált User Agent szabály alapján dolgozik. A szabály lényege, hogy amennyiben a kérés User Agent-je szerepel a listában, úgy a kérés blokkolásra kerül.
• HTTP Protocol szabály: a HTTP kérés protokollját vizsgálja. A szabály lényege, hogy amennyiben a kérés nem felel meg a szabályban meghatározott kritériumnak úgy a kérés blokkolásra kerül.
• Query String szabály: a HTTP kérés query string-jét vizsgálja. A szabály lényege, hogy amennyiben a kérés query string-je nem felel meg a szabályban meghatározott kritériumnak úgy a kérés blokkolásra kerül.
• Redirect szabály: a HTTP kérés átirányítási viselkedését vizsgálja. A szabály lényege, hogy amennyiben a kérés átirányítást tartalmaz, amely URL-je nem felel meg a szabályban meghatározott kritériumnak úgy a kérés blokkolásra kerül.
• Felhasználó enumeráció szabály: az author lekérdezési paraméteren keresztüli felhasználó enumerációs kísérleteket vizsgálja. A szabály lényege, hogy amennyiben a kérés ilyen kísérletet tartalmaz, úgy a kérés blokkolásra kerül.
• Fájl feltöltés szabály: gyanús fájl feltöltési kísérleteket vizsgál. A szabály lényege, hogy amennyiben a kérés ilyen kísérletet tartalmaz, úgy a kérés blokkolásra kerül.

¶Egyedi WAF szabályok létrehozása

A bővítmény lehetőséget biztosít arra, hogy egyedi WAF szabályokat hozzunk létre és alkalmazzunk a meglévő szabályok mellett. Például hozzunk létre egy olyan szabályt, amely blokkolja az OPTIONS HTTP metódusú kéréseket:

use Cone\TrafficCop\Waf\Rule;

class MethodRule extends Rule
{
    /**
     * The HTTP method.
     */
    protected string $method;

    /**
     * Create a new HTTP method rule instance.
     */
    public function __construct(string $method)
    {
        $this->method = $method;
    }

    /**
     * Create a new HTTP method rule instance from raw data.
     */
    public static function fromRaw(): static
    {
        return new static(strtoupper($_SERVER['REQUEST_METHOD'] ?? ''));
    }

    /**
     * Get the source of the rule.
     */
    public function source(): string
    {
        return $this->method;
    }

    /**
     * Check whether the rule applies.
     */
    public function check(): bool
    {
        if ($this->method === 'OPTIONS') {
            return false;
        }

        return true;
    }
}

Egyedi szabályok alkalmazásához a traffic-cop/waf/rules filtert lehet használni:

add_filter('traffic-cop/waf/rules', function (array $rules): array {
    $rules[] = MethodRule::class;

    return $rules;
});

¶Beállítások

A WAF beállításai a Beállítások → Traffic Cop → WAF menüpontban található.

¶Rate Limiter

A Rate Limiter funkció arra hivatott, hogy bizonyos HTTP kéréseket (pl.: Bot kéréseket) egy adott időablakban (pl.: 10 másodperc) limitáljon (pl.: 3 kérés az adott ablakban).

Erre azért van szükség, mert a tartalmat elemző botok (pl.: Google bot, Facebook bot) komoly terhelést képesek kiváltani az adott szerveren nagyon rövid idő alatt. Ez lassítja az oldalt és a minden folyamatot amely rontja a felhasználói élményt, esetenként használhatatlanná teszi a felületet.

Fontos: Amennyiben szeretnénk átengedni botokat (pl.: hirdetések miatt), úgy ezt megfelelően be kell állítani. Jelenleg a legtöbb bot 1 kérést küldhet 10 másodperc alatt.

Jelenleg három Rate Limiter megoldás közül lehet választani: Transient, Redis és Shmop.

¶Környezeti beállítások .htaccess segítségével

Amennyiben szeretnénk, úgy a kívánt szabályoknak megfelelő értékeket adhatunk át a Rate Limiternek az .htaccess segítségével. Például:

RewriteCond %{HTTP_USER_AGENT} "^Mozilla.*(Chrome|Firefox|Safari)"
RewriteCond %{HTTP_ACCEPT_LANGUAGE} "^$"
RewriteCond %{HTTP_ACCEPT_ENCODING} "^gzip$"
RewriteCond %{HTTP_CONNECTION} "^keep-alive$"
RewriteCond %{HTTP_REFERER} "."
RewriteRule ^ - [E=RATE_LIMIT_KEY:Chinese-attacker,E=RATE_LIMIT_INTERVAL:10,E=RATE_LIMIT_LIMIT:1]

Fontos, hogy minden esetben a RATE_LIMIT_KEY, a RATE_LIMIT_INTERVAL és a RATE_LIMIT_LIMIT env változókat kell megadni.

¶Transient Driver

A tranziensek a WordPress core részét képzik. Ezt az opciót előzetes beállítás és konifurálás nélkül használni lehet.

¶Redis Driver

A Redis egy nyílt forráskódú, in-memory, NoSQL kulcs-érték tároló, amely gyors adatfeldolgozást biztosít. Rugalmassága és gyorsasága miatt olyan esetekben ajánlott, amikor az oldal nagyobb forgalmat bonyolít.

A driver használatának előfeltétele, a redis PHP extension megléte és a megfelelő konfiguráció a wp-config.php fájlban:

// pl.:
define('TRAFFIC_COP_REDIS_CONFIG', [
    'host' => '127.0.0.1',
    'port' => 6379,
    'auth' => 'password',
    'database' => 0,
]);

¶Shmop Driver

A "shmop" (shared memory operation) egy PHP bővítmény, amely lehetővé teszi Unix alapú rendszereken a megosztott memória szegmensek egyszerű kezelését. PHP-ben használható funkciókat biztosít a megosztott memória szegmensek olvasásához, írásához, létrehozásához és törléséhez.

A driver használatának előfeltétele, a shmop megléte.

¶Beállítások

A Rate Limiter beállíásai a Beállítások → Traffic Cop → Rate Limiter menüpontban található.

¶Hook index

A bővítmény lehetőséget nyújt arra, hogy filtereken keresztül irányítsuk a működést. A hookok megfelelő használatával akár egészen egyedi megoldásokat is alkalmazhatunk.

¶traffic-cop/waf/rules (Filter)

Amennyiben egyedi WAF szabályt szeretnénk hozzáadni a meglévő szabályokhoz, úgy ezt a traffic-cop/waf/rules filterrel megtehetjük:

add_filter('traffic-cop/waf/rules', function (array $rules): array {
    $rules[] = CustomRule::class;

    return $rules;
});

¶traffic-cop/waf/rule_enabled (Filter)

Amennyiben egyedi logika alapján szeretnénk ki- vagy bekapcsolni egy adott WAF szabályt, úgy ezt a traffic-cop/waf/rule_enabled filterrel megtehetjük:

add_filter('traffic-cop/waf/rule_enabled', function (bool $enabled, Cone\TrafficCop\Waf\Rule $rule): bool {
    return match ($rule) {
        $rule instanceof Cone\WordPress\TrafficCop\Waf\FileUploadRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\IpRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\ProtocolRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\QueryStringRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\RedirectRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\UriRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\UserAgentRule => true,
        $rule instanceof Cone\WordPress\TrafficCop\Waf\UserEnumerationRule => true,
        default => $enabled,
    };
});

¶traffic-cop/waf/blocked (Action)

Amennyiben műveletet szeretnénk elvégezni abban az esetben, amikor a WAF blokkolt egy HTTP kérést, úgy ezt a traffic-cop/waf/blocked action-nel megtehetjük:

add_action('traffic-cop/waf/blocked', function (Cone\TrafficCop\Waf\Rule $rule): void {
    match ($rule) {
        $rule instanceof Cone\WordPress\TrafficCop\Waf\FileUploadRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\IpRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\ProtocolRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\QueryStringRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\RedirectRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\UriRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\UserAgentRule => handleValue($rule->source()),
        $rule instanceof Cone\WordPress\TrafficCop\Waf\UserEnumerationRule => handleValue($rule->source()),
        default => null,
    };
});

¶traffic-cop/waf/ip_bypass (Filter)

Amennyiben egy adott IP címet átengedni vagy éppen ellenkezőleg, blokkolni szeretnénk - függetlenül attól, hogy szerepel-e az IP listában - úgy ezt a traffic-cop/waf/ip_bypass filterrel megtehetjük:

add_filter('traffic-cop/waf/ip_bypass', function (?bool $pass, string $ip): ?bool {
    return match (true) {
        in_array($ip, $enabled) => true,
        in_array($ip, $blocked) => false,
        default => $pass,
    };
}, 10, 2);

¶traffic-cop/rate_limiter/key (Filter)

Amennyiben módosítani szeretnénk a Rate Limiter kulcsát (tehát azt az értéket ami alapján megkülönböztetjük az egyes HTTP kéréseket), úgy ezt a traffic-cop/rate_limiter/key filterrel megtehetjük:

add_filter('traffic-cop/rate_limiter/key', function (string $key): string {
    return $_SERVER['REMOTE_ADDR'];
});

¶traffic-cop/rate_limiter/limit (Filter)

Amennyiben módosítani szeretnénk az adott kulcsra vonatkoztó limitet az adott intervallumban, úgy ezt a traffic-cop/rate_limiter/limit filterrel megtehetjük:

add_filter('traffic-cop/rate_limiter/limit', function (int $limit): int {
    return match (true) {
        isBot() => 1,
        default => $limit,
    };
});

¶traffic-cop/rate_limiter/interval (Filter)

Amennyiben módosítani szeretnénk az intervallumot, úgy ezt a traffic-cop/rate_limiter/interval filterrel megtehetjük:

add_filter('traffic-cop/rate_limiter/interval', function (int $interval): int {
    return match (true) {
        isBot() => 10,
        default => $interval,
    };
});

¶traffic-cop/rate_limiter/limited (Filter)

Amennyiben egyedi logikával irányítani szeretnénk, hogy mely kérések esetén lépjen életbe a rate limit, úgy ezt a traffic-cop/rate_limiter/limited filterrel megtehetjük:

add_filter('traffic-cop/rate_limiter/limited', function (bool $limited): bool {
    return match (true) {
        isBot() => true,
        default => false,
    };
});

¶traffic-cop/rate/limit_hit (Action)

Amennyiben műveletet szeretnénk elvégezni abban az esetben, ha a Rate Limiter lefutott, úgy ezt a traffic-cop/rate/limit_hit action-nel megtehetjük:

add_action('traffic-cop/rate/limit_hit', function (string $ip): void {
    //
});

¶traffic-cop/rate_limiter/blocked (Action)

Amennyiben műveletet szeretnénk elvégezni abban az esetben, ha a Rate Limiter elérte a limitet és blokkolta a kérést, úgy ezt a traffic-cop/rate_limiter/blocked action-nel megtehetjük:

add_action('traffic-cop/rate_limiter/blocked', function (string $ip): void {
    //
});