Installation

The HUMAN Fastly VCL Enforcer uses many Fastly features and

• Ensure all prerequisites are satisfied.
• Add the HUMAN Enforcer VCL files, snippets, conditions, and logging endpoints.
• Configure the HUMAN Enforcer using the PX_CONFIGS and PX_CUSTOM VCL files.
• Modify the MAIN VCL file (or upload a default one) to invoke the enforcer flow.

Prerequisites

1. Enable HUMAN Support.

In order to enable the HUMAN support on your Fastly service, the HUMAN Fastly Enforcer requires advanced functionality from Fastly.

Send the following e-mail to support@fastly.com:

• Subject: “Please enable HUMAN support for our Fastly service ID”
• Body: Please enable HUMAN support for our service ID and confirm when it is completed.

Once Fastly enables HUMAN support, the following pragmas should be enabled at your service:

• fix_unsent_body_drain - pragma that can be used in VCL to resolve an issue with HTTP response bodies not being fully sent to the client.
• no_body_if_bereq_is_get_or_head - pragma that can be used in VCL to prevent a response body from being sent to the client if the request method is GET or HEAD.

You must request to enable functionality for each service ID that is being protected by HUMAN. If this functionality is not enabled, requests will fail with a 503 Service Unavailable error.

If both the fix_unsent_body_drain and no_body_if_bereq_is_get_or_head pragmas are there, HUMAN has been enabled for the service.

Uploading the HUMAN Enforcer Files

The HUMAN Fastly VCL Enforcer comprises logging endpoints, snippets, conditions, and custom VCL files. All these components work together to provide the required enforcement functionality.

1. Add the required Custom VCL files.

The HUMAN Fastly VCL Enforcer consists of 3 custom VCL files that need to be uploaded to your service. These three files define the logic, configurations, and desired customizations for the VCL enforcer. These VCL files will be provided to you by a HUMAN Solution Architect.

You may upload the files via the Fastly Console by following the instructions here or you can create the VCL files using the Fastly API or Fastly CLI.

* VCL file names are case-sensitive.

| Error Code | Meaning |

| ---------- | ------------------------------------------------------------ |

| 990 | custom_preflight_handler |

| 991 | first_party_disabled |

| 992 | first_party_xhr_disabled |

| 995 | exceeded_rate_limit, s2s_high_score, cookie_high_score |

| 996 | cookie_high_score |

2. Add the required Logging Endpoints.

The HUMAN Enforcer uses two HTTPS logging endpoints: PX-Async-Activities and PX-Telemetry. The PX-Async-Activities logging endpoint sends asynchronous activities (e.g., page_requested, block) to HUMAN’s servers. The PX-Telemetry endpoint enables the telemetry feature, which can send on-demand data about the enforcer configuration to HUMAN.

If you’re using the Fastly Console, create the logging endpoints with the following settings (for any field not mentioned, use the default value).

• PX-Async-Activities

• Name: PX-Async-Activities

• URL: https://collector-<APP_ID>.perimeterx.net/api/v1/collector/s2s

• Placement: none

• Maximum bytes: 500000

• Advanced Options

• Content type: application/json

• JSON log entry format: Array of JSON

• PX-Telemetry

• Name: PX-Telemetry

• URL: https://collector-<APP_ID>.perimeterx.net/api/v2/risk/telemetry

• Placement: none

• Maximum Logs: 1

• Advanced Options

• Content type: application/json

If you’re using the Fastly API or Fastly CLI, the following JSON objects can be used to generate these same logging endpoints.

1
{
2
3
"content_type": "application/json",
4
5
"json_format": "1",
6
7
"name": "PX-Async-Activities",
8
9
"placement": "none",
10
11
"request_max_bytes": 500000,
12
13
"url": "https://collector-<APP_ID>.perimeterx.net/api/v1/collector/s2s"
14
15
}

1
{
2
3
"content_type": "application/json",
4
5
"json_format": "0",
6
7
"name": "PX-Telemetry",
8
9
"placement": "none",
10
11
"url": "https://collector-<APP_ID>.perimeterx.net/api/v2/risk/telemetry",
12
13
"request_max_entries": 1
14
15
}

3. Add the required VCL Snippets.

VCL Snippets are small bits of logic that can be included and invoked at various points in the Fastly service. While most of the Enforcer logic is contained in the custom VCL files, snippets are required when it is necessary to modify the logic inside Fastly’s default macros (more information here).

The px_shield snippet is required for Fastly Shielding functionality to stay enabled after a restart triggered by the Enforcer. See more information on enabling and disabling shielding here.

If you’re using the Fastly Console, create the snippet with the following settings (for any field not mentioned, use the default value).

• px_shield

• Name: px_shield

• Type: within subroutine - recv (vcl_recv)

• VCL: set var.fastly_req_do_shield = (req.restarts == 0 || (req.restarts == 1 && req.http.px-tmp:internal-flow == "1"));

• Advanced Options:

• Priority: 1

If you’re using the Fastly API or Fastly CLI, the following JSON object can be used to generate the same snippet.

1
{
2
3
"name": "px_shield",
4
5
"dynamic": "0",
6
7
"type": "recv",
8
9
"content": "set var.fastly_req_do_shield = (req.restarts == 0 || (req.restarts == 1 && req.http.px-tmp:internal-flow == \"1\"));",
10
11
"priority": "1"
12
13
}

4. Add the optional WAF Prefetch Condition.

If you are using Fastly WAF, we recommend adding condition to your Fastly service to address a potential issue that may arise from running WAF rules multiple times. This condition will effectively prevent the duplication of WAF activations and ensure a smoother operation of the integration for customers who have enabled Fastly WAF but have not implemented the WAF prefetch condition.

If you’re using the Fastly Console, create the condition with the following settings (for any field not mentioned, use the default value).

• PX-Waf-Prefetch-Condition
  • Name: PX-Waf-Prefetch-Condition
  • Type: prefetch
  • Apply If: req.backend.is_origin && !req.http.bypasswaf
  • Advanced Options:
    • Priority: 10

If you’re using the Fastly API or Fastly CLI, the following JSON object can be used to generate the same condition.

1
{
2
    "name": "PX-Waf-Prefetch-Condition",
3
    "comment": "Condition to prevent duplicate activations of the WAF",
4
    "priority": "10",
5
    "type": "PREFETCH",
6
    "statement": "req.backend.is_origin && !req.http.bypasswaf"
7
}

5. Enable the Remote Configuration feature (optional).

The HUMAN Fastly VCL Enforcer supports the remote configuration feature, which allows you to update the enforcer configuration from the HUMAN Portal without redeploying your Fastly service. The remote configuration feature makes use of Fastly dictionaries to store the configuration.

To enable this feature, follow the steps below.

1. Set the px_remote_config_secret in the enforcer configuration in the PX_CONFIGS custom VCL file.
2. Create a Fastly dictionary named px_enforcer_config_rdata via the Fastly Console, CLI, or API. This dictionary should be left empty and will be populated with entries by HUMAN. Remove the table declaration of the same name in the PX_CUSTOM VCL.
3. Add the two required entries to the cs_data table (or dictionary).
4. Create a new logging endpoint named HS-Log. If you’re using the Fastly Console, create the logging endpoint with the following settings (for any field not mentioned, use the default value).

• HS-Log
  • Name: HS-Log
  • URL: https://sapi-<APP_ID>.perimeterx.net/enforcer-logs/
  • Placement: none
  • Format:
  • Advanced Options
    • Content type: application/json
    • Custom Header Name: Authorization
    • Custom Header Value: Bearer <LOGGER_AUTH_TOKEN>
    • JSON log entry format: Array of JSON
    • Log Line Format: Blank

If you’re using the Fastly API or Fastly CLI, the following JSON object can be used to generate these same logging endpoints.

1
{
2
  "content_type": "application/json",
3
  "format": "{}",
4
  "header_name": "Authorization",
5
  "header_value": "Bearer <LOGGER_AUTH_TOKEN>",
6
  "json_format": "1",
7
  "message_type": "blank",
8
  "name": "HS-Log",
9
  "placement": "none",
10
  "url": "https://sapi-<APP_ID>.perimeterx.net/enforcer-logs/"
11
}

6. Add the optional Logging Endpoints.

The HUMAN Fastly Enforcer can send messages about the Fastly request flow to logging endpoints configured in the Fastly Service. The enforcer can send two kinds of logs depending on the configured px_logger_severity: debug and error.

To receive enforcer logs, follow the steps below:

1. Set the px_logger_severity configuration in the PX_CONFIG VCL file to the logging level desired. If error logs are desired, set px_enable_error_logs to "true".
2. Create a logging endpoint with the name PX-Debug or PX-Error. Depending on the logging endpoint type, you’ll have to configure where you want the logs to go (e.g., URL). Other settings can typically stay as the default values.
3. Activate the service.

Configure the HUMAN Enforcer

1. Add your configurations to the PX_CONFIGS file.

The PX_CONFIGS file declares a Fastly VCL table named px_configs. This table is where the enforcer configuration is defined. All possible configurations for this table are documented here. At a minimum, the px_configs table should contain the application ID, authentication token, and cookie secret associated with your application.

1
table px_configs {
2
    "px_app_id": "<PX_APP_ID>",
3
    "px_cookie_secret": "<PX_COOKIE_SECRET>",
4
    "px_auth_token": "<PX_AUTH_TOKEN>"
5
}

The PX_CONFIGS file also declares a Fastly backend named PX_API . This backend will be used to execute Risk API requests. The only value that should be changed here is the value of .host, in which <PX_APP_ID> should be replaced with your application’s ID. (For instance, if your app ID is PX12345678, then the .host value of the PX_API backend should be set to sapi-PX12345678.perimeterx.net.)

1
backend PX_API {
2
    # ...
3
    .host = "sapi-<PX_APP_ID>.perimeterx.net";
4
    # ...
5
}

All other settings in this file can be left as is.

2. Add custom logic to the PX_CUSTOM file.

The PX_CUSTOM file serves as an extension of the PX_CONFIGS file where more complicated configurations and custom enforcer logic can be defined. The implementations of the subroutines defined in this file can be modified to customize the enforcer behavior as desired. Explanations and sample implementations of all the subroutines are documented here.

Modify (or Add) the MAIN VCL File

There is no single entry point for VCL code. Instead, Fastly exposes a number of different subroutines that function as “hooks” during the various stages of the VCL request lifecycle. These specific subroutines (e.g., vcl_recv, vcl_deliver) must be defined in a special custom VCL file known as the MAIN file. Fastly uses a boilerplate MAIN file if one is not explicitly set.

Integrating the HUMAN enforcer into the MAIN VCL requires invoking the appropriate HUMAN subroutine in every VCL hook subroutine.

* px_recv_clustering_fixup should be called after the #FASTLY recv macro.

If you DO NOT have an existing MAIN VCL file…

We recommend using our default MAIN VCL file, which is Fastly’s boilerplate MAIN file with the HUMAN enforcer subroutines already added in all the right places.

The default MAIN VCL file code is available here:

1
include "PX_CONFIGS"
2
include "PX_CUSTOM"
3
include "PX"
4
5
sub vcl_recv {
6
    call px_recv;
7
#FASTLY recv
8
    call px_recv_clustering_fixup;
9
10
    # Normally, you should consider requests other than GET and HEAD to be uncacheable
11
    # (to this we add the special FASTLYPURGE method)
12
    if (req.method != "HEAD" && req.method != "GET" && req.method != "FASTLYPURGE") {
13
        return(pass);
14
    }
15
16
    return(lookup);
17
}
18
19
sub vcl_hash {
20
    #FASTLY hash
21
    set req.hash += req.http.host;
22
    set req.hash += req.url;
23
    return(hash);
24
}
25
26
sub vcl_hit {
27
#FASTLY hit
28
    return(deliver);
29
}
30
31
sub vcl_miss {
32
    call px_miss;
33
#FASTLY miss
34
    return(fetch);
35
}
36
37
sub vcl_pass {
38
    call px_pass;
39
#FASTLY pass
40
    return(pass);
41
}
42
43
sub vcl_fetch {
44
    call px_fetch;
45
#FASTLY fetch
46
47
    # In the event of a server-failure response from origin, retry once more
48
    if ((beresp.status == 500 || beresp.status == 503) && (req.restarts < 1 || is_px_server_failure()) && (req.method == "GET" || req.method == "HEAD")) {
49
        restart;
50
    }
51
52
    # Log the number of restarts for debugging purposes
53
    if (req.restarts > 0) {
54
        set beresp.http.Fastly-Restarts = req.restarts;
55
    }
56
57
    # If the response is setting a cookie, make sure it is not cached
58
    if (beresp.http.Set-Cookie) {
59
        return(pass);
60
    }
61
62
    # By default we set a TTL based on the `Cache-Control` header but we don't parse additional directives
63
    # like `private` and `no-store`.  Private in particular should be respected at the edge:
64
    if (beresp.http.Cache-Control ~ "(private|no-store)") {
65
        return(pass);
66
    }
67
68
    # If no TTL has been provided in the response headers, set a default
69
    if (!beresp.http.Expires && !beresp.http.Surrogate-Control ~ "max-age" && !beresp.http.Cache-Control ~ "(s-maxage|max-age)") {
70
        set beresp.ttl = 3600s;
71
    }
72
73
    return(deliver);
74
}
75
76
sub vcl_error {
77
    call px_error;
78
#FASTLY error
79
    return(deliver);
80
}
81
82
sub vcl_deliver {
83
    call px_deliver;
84
#FASTLY deliver
85
    return(deliver);
86
}
87
88
sub vcl_log {
89
#FASTLY log
90
}

It should look very similar to the boilerplate MAIN VCL file provided by Fastly.

If you DO have an existing MAIN VCL file…

Add the HUMAN Enforcer subroutines (e.g., px_recv, px_deliver) to your VCL hooks (e.g., vcl_recv, vcl_deliver) one by one. Follow these guidelines when adding these subroutine calls:

• The HUMAN subroutines should be called as early as possible in the defined hook. This is because the subroutines use request headers and return statements to switch between different Fastly states and apply HUMAN enforcement logic only when necessary. Plus, calling the enforcement flow in the very beginning helps avoid invoking business logic unnecessarily.
• The HUMAN subroutines should always be called before the Fastly macro (e.g., #FASTLY recv, #FASTLY deliver).

The only exception to the above is the px_recv_clustering_fixup subroutine, which should be called immediately after the #FASTLY recv macro.

RECV

1
sub vcl_recv {
2
    call px_recv;
3
    # ...
4
#FASTLY recv
5
    call px_recv_clustering_fixup;
6
    # ...
7
}

MISS

1
sub vcl_miss {
2
    call px_miss;
3
    # ...
4
#FASTLY miss
5
    # ...
6
}

PASS

1
sub vcl_pass {
2
    call px_pass;
3
    # ...
4
#FASTLY pass
5
    # ...
6
}

FETCH

1
sub vcl_fetch {
2
    call px_fetch;
3
    # ...
4
#FASTLY fetch
5
    # ...
6
}

DELIVER

1
sub vcl_deliver {
2
    call px_deliver;
3
    # ...
4
#FASTLY deliver
5
    # ...
6
}

ERROR

1
sub vcl_error {
2
    call px_error;
3
    # ...
4
#FASTLY error
5
    # ...
6
}