Installation

1
type Runtime interface {
2
    PerformSyncRequest(request *http.Request, timeout int) (*http.Response, error)
3
    PerformAsyncRequest(request *http.Request, timeout int)
4
    Log(message string)
5
    GetOS() string
6
    GetHostName() string
7
}

1
// initialize http client
2
var client = &http.Client{
3
    Transport: &http.Transport{
4
        MaxIdleConnsPerHost:   10,
5
        ResponseHeaderTimeout: 60 * time.Second,
6
    }
7
}
8
9
// declare ExampleRuntime type
10
type ExampleRuntime struct {}
11
12
// implement PerformSyncRequest using http client
13
func (runtime *ExampleRuntime) PerformSyncRequest(req *http.Request, timeout int) (*http.Response, error) {
14
    client.Timeout = time.Duration(timeout) * time.Millisecond
15
    return client.Do(req)
16
}
17
18
// implement PerformAsyncRequest by invoking PerformSyncRequest in new goroutine
19
func (runtime *ExampleRuntime) PerformAsyncRequest(req *http.Request, timeout int) {
20
    go runtime.PerformSyncRequest(req, timeout)
21
}
22
23
// implement GetOS using goruntime package
24
func (runtime *ExampleRuntime) GetOS() string {
25
    return goruntime.GOOS
26
}
27
28
// implement GetHostName using os package
29
func (runtime *ExampleRuntime) GetHostName() string {
30
    osName, _ := os.Hostname()
31
    return osName
32
}
33
34
// implement Log using fmt package
35
func (runtime *ExampleRuntime) Log(message string) {
36
    fmt.Print(message)
37
}

1
// build the configuration from map
2
pxConfig, err := perimterx.BuildPXConfig(map[string]interface{}{
3
    "px_app_id":        "<APP_ID>",
4
    "px_auth_token":    "<AUTH_TOKEN>",
5
    "px_cookie_secret": "<COOKIE_SECRET">,
6
    // ...
7
})

1
// build the configuration from json
2
pxConfig, err := perimeterx.GetPxConfigFromJson("/path/to/enforcer_config.json")

1
// build the configuration with builder
2
pxConfig := perimeterx.NewPXConfigBuilder(map[string]interface{}{
3
        // must initialize with the required configurations only
4
        "px_app_id":        "<APP_ID>",
5
        "px_auth_token":    "<AUTH_TOKEN>",
6
        "px_cookie_secret": "<COOKIE_SECRET">,
7
    })
8
    .SetModuleMode("active_blocking")
9
    // ...
10
    .Build()

1
func main() {
2
    // build the configuration
3
    pxConfig, err := perimterx.BuildPXConfig(map[string]interface{}{
4
        "px_app_id":        "<APP_ID>",
5
        "px_auth_token":    "<AUTH_TOKEN>",
6
        "px_cookie_secret": "<COOKIE_SECRET">,
7
        // ...
8
    })
9
    if err != nil {
10
        fmt.Printf("failed to initialize enforcer configuration: %s", err)
11
        return
12
    }
13
14
    // initialize the runtime
15
    runtime := &ExampleRuntime{}
16
17
    // create the HUMAN enforcement middleware
18
    defaultMiddleware := perimeterx.CreateDefaultHumanSecurityMiddleware(pxConfig, runtime)
19
20
    // use the HUMAN enforcement middleware to wrap HTTP handler functions
21
    http.Handle("/", defaultMiddleware(http.FileServer(http.Dir("./static"))))
22
    // ...
23
24
    // serve
25
    http.ListenAndServe(":3000", nil)
26
}

1
// define global variables
2
var enforcer *perimeterx.HumanSecurityEnforcer
3
var runtime perimeterx.Runtime
4
5
func main() {
6
    // build the configuration
7
    pxConfig, err := perimterx.BuildPXConfig(map[string]interface{}{
8
        "px_app_id":        "<APP_ID>",
9
        "px_auth_token":    "<AUTH_TOKEN>",
10
        "px_cookie_secret": "<COOKIE_SECRET">,
11
        // ...
12
    })
13
    if err != nil {
14
        fmt.Printf("failed to initialize enforcer configuration: %s", err)
15
        return
16
    }
17
18
    // initialize the runtime
19
    runtime = &ExampleRuntime{}
20
21
    // initialize the enforcer
22
    enforcer = NewHumanSecurityEnforcer(pxConfig, runtime)
23
24
    // use the HUMAN enforcement middleware to wrap HTTP handler functions
25
    http.Handle("/", customMiddleware(http.FileServer(http.Dir("./static"))))
26
    // ...
27
28
    // serve
29
    http.ListenAndServe(":3000", nil)
30
}
31
32
// define custom middleware that accepts an HTTP handler function
33
func customMiddleware(handler http.HandlerFunc) http.HandlerFunc {
34
    return func(w http.ResponseWriter, r *http.Request) {
35
        // call the global enforcer's enforcement function
36
        response, context, err := enforcer.Enforce(r, runtime)
37
38
        // set pxhd cookie if needed
39
        if perimeterx.ShouldSetPxhd(context) {
40
            pxhdCookie := perimeterx.GetPxhdCookie(context)
41
            http.SetCookie(w, &pxhdCookie)
42
        }
43
44
        // if there was an error, log it
45
        if err != nil {
46
            runtime.Log(fmt.Sprintf("enforcer error: %s", err))
47
        }
48
49
        if response != nil {
50
            // if the response exists...
51
            // write the response status code, headers, and body with the http.ResponseWriter
52
            for key, value := range response.Header {
53
                w.Header().Set(key, value[0])
54
            }
55
            var body, _ = io.ReadAll(response.Body)
56
            w.WriteHeader(response.StatusCode)
57
            w.Write(body)
58
        } else {
59
            // if the response does not exist...
60
            // invoke the provided handler
61
            handler(w, r)
62
        }
63
    }
64
}

1
func customMiddleware(handler http.HandlerFunc) http.HandlerFunc {
2
    return func(w http.ResponseWriter, r *http.Request) {
3
4
        // enforcement, error handling, setting pxhd, etc...
5
6
        if response != nil {
7
            // ...
8
        } else {
9
            // if the response does not exist...
10
            // create a new response writer wrapper to store the response body
11
            responseWriterWrapper := perimeterx.NewResponseWriterWrapper(w)
12
13
            // defer an invocation to send the additional_s2s activity
14
            defer enforcer.PostEnforce(responseWriterWrapper, context, runtime)
15
16
            // invoke the provided handler with the response writer wrapper
17
            handler(responseWriterWrapper, r)
18
        }
19
    }