Installing the Enforcer

1
let mut px: PXEnforcer = PXEnforcer::new(perimeterx_fastly_enforcer::DEFAULT_CONFIGSTORE_NAME);
2
3
px.set_enrich_custom_params_fn(set_enrich_custom_params);
4
px.set_additional_activity_handler_fn(additional_activity_handler);
5
6
let px_result = px.enforce(&mut req)?;
7
if let Some(r) = px_result {
8
    return Ok(r);
9
};
10
11
// ... communicate with the origin server and process the response ...
12
13
px.post_enforce(&mut response);

1
pub fn new(config_store_name: &str) -> Self

1
pub fn enforce(&mut self, req: &mut Request) -> Result<Option<Response>, Error>

1
pub fn post_enforce(&mut self, resp: &mut Response)

1
// Send the score value to the origin, if it is available.
2
if let Some(score) = px.ctx().get_score() {
3
    req.set_header("x-px-score", score.to_string());
4
}

1
pub type PXEnrichCustomParamsFn =
2
    fn(req: &Request, conf: &PXConfig, params: &mut PXCustomParams);

1
pub fn set_enrich_custom_params_fn(&mut self, f: PXEnrichCustomParamsFn)

1
use fastly::{Error, Request, Response};
2
use perimeterx_fastly_enforcer::{
3
    PXModuleMode,
4
    pxconfig::{PXConfig, PXCustomParams},
5
    pxcontext::PXContext,
6
    pxenforce::PXEnforcer,
7
};
8
9
const ORIGIN_BACKEND: &str = "origin_backend";
10
11
// A simple function that sends the request to the origin.
12
fn send_to_origin(req: Request) -> Result<Response, Error> {
13
    println!("sending to Origin...");
14
    match req.send(ORIGIN_BACKEND) {
15
        Ok(r) => Ok(r),
16
        Err(e) => Err(e.into()),
17
    }
18
}
19
20
// Callback function to set custom parameters.
21
fn set_enrich_custom_params(_req: &Request, _conf: &PXConfig, params: &mut PXCustomParams) {
22
    params.custom_param3 = "test3".to_string();
23
    params.custom_param6 = "test6".to_string();
24
}
25
26
// Callback function executed after sending page_requested or block activity to the collector.
27
fn additional_activity_handler(_req: &Request, _conf: &PXConfig, _ctx: &PXContext) {
28
    println!("additional activity handler called");
29
}
30
31
#[fastly::main]
32
fn main(mut req: Request) -> Result<Response, Error> {
33
    log_fastly::Logger::builder()
34
        .max_level(log::LevelFilter::Info)
35
        .default_endpoint("LOG_ENDPOINT")
36
        .init();
37
38
    let mut px: PXEnforcer = PXEnforcer::new(perimeterx_fastly_enforcer::DEFAULT_CONFIGSTORE_NAME);
39
40
    // Usage Example: set several custom parameters, which will be sent to PX Collector
41
    px.set_enrich_custom_params_fn(set_enrich_custom_params);
42
43
    // Usage Example: set a function executed after sending page_requested or block activity to the collector
44
    px.set_additional_activity_handler_fn(additional_activity_handler);
45
46
    // Usage Example: set a function to identify "sensitive" requests
47
    px.set_is_sensitive_request_fn(|req, _conf| {
48
        req.get_url().path().starts_with("/api/v1/user")
49
            || req.get_url().path().starts_with("/api/v1/payment")
50
            || req.get_url().path().starts_with("/login")
51
    });
52
53
    // Usage Example: set a function to filter out requests that should not be verified
54
    px.set_is_filtered_request_fn(|req, _conf| {
55
        req.get_url().path().starts_with("/health")
56
            || req.get_url().path().starts_with("/static")
57
            || req.get_url().path().starts_with("/assets")
58
    });
59
60
    // Usage Example: set module mode (Monitor/Blocking) for specific requests
61
    if req.get_url().path().starts_with("/test/monitor") {
62
        px.set_module_mode(PXModuleMode::Monitor);
63
    }
64
65
    // execute PX Enforcer for Request
66
    let px_result = px.enforce(&mut req)?;
67
68
    // print Data Enrichment values, if available
69
    if let Some(de) = px.ctx().get_data_enrichment() {
70
        log::info!(
71
            "PX Data Enrichment: f_kb={}, f_type={}, f_id={}, f_origin={}, ipc_id={:?}, inc_id={:?}, breached_account={}, f_access_token={}",
72
            de.get_f_kb(),
73
            de.get_f_type(),
74
            de.get_f_id(),
75
            de.get_f_origin(),
76
            de.get_ipc_id(),
77
            de.get_inc_id(),
78
            de.get_breached_account(),
79
            de.get_f_access_token()
80
        );
81
    } else {
82
        log::error!("Data Enrichment is not available");
83
    }
84
85
    // immediately return, if it's a "blocked" or "first party" response
86
    if let Some(r) = px_result {
87
        return Ok(r);
88
    };
89
90
    // ... process Client request ...
91
92
    // it's possible to access "PXContext" structure.
93
    // Usage Example: send "score" value to the Origin, if "score" is available
94
    if let Some(score) = px.ctx().get_score() {
95
        req.set_header("x-px-score", score.to_string());
96
    } else {
97
        log::debug!("Score is not available");
98
    }
99
100
    // a client function to communicate with the Origin
101
    let mut response = send_to_origin(req)?;
102
103
    // ... process Origin response ...
104
105
    // must be called at the end
106
    px.post_enforce(&mut response);
107
108
    // we are ok to send response back to client
109
    Ok(response)
110
}

1
if let Some(score) = px.ctx().get_score() {
2
    req.set_header("x-px-score", score.to_string());
3
}

1
if let Some(vid) = px.ctx().get_vid() {
2
    log::info!("vid: {}", vid);
3
}

1
if let Some(risk_rtt) = px.ctx().get_risk_rtt() {
2
    log::info!("Risk API round-trip time: {} ms", risk_rtt);
3
}

1
if let Some(block_reason) = px.ctx().get_block_reason() {
2
    log::info!("Block reason: {}", block_reason);
3
}

1
if let Some(de) = px.ctx().get_data_enrichment() {
2
    log::info!("Data enrichment type: {}", de.get_f_type());
3
}