Protection of AI APIs from Malicious Requests with AWS WAF

Question

Pulumi · Accepted Answer

To protect AI APIs from malicious requests with AWS WAF (Web Application Firewall), we need to perform a few steps. The goal is to create a set of rules that define what type of traffic should be blocked, monitored, or allowed to reach your API. AWS WAF allows you to set up rules based on IP addresses, HTTP headers, HTTP body, URI strings, SQL injection, and many other characteristics.

Here's a high-level overview of what you would typically do to secure your AI APIs with AWS WAF:

1. **Create an IP Set**: This is to filter requests based on client's IP addresses. You would define a set of trusted IP addresses if you want to whitelist them or a set of known malicious IP addresses if you want to blacklist them.

2. **Create a Web ACL**: An Access Control List where you attach the rules which include the IP Set you created.

3. **Create Rules**: These are the conditions that determine if a request should be allowed, blocked, or counted for further monitoring. In this scenario, you can create rules to check for signs of SQL injection, size constraints, or rate-based rules to limit requests from a single IP.

4. **Associate the Web ACL with a resource**: This could be an Application Load Balancer or an API Gateway endpoint that fronts your AI APIs.

Below is a Python program using Pulumi and the AWS provider to set up basic protection using AWS WAF. This program will:
- Create a size constraint set to block requests with unusually large bodies, which can be a sign of an attack.
- Create an IP set that you can populate with suspicious IP addresses.
- Create a SQL injection match set to protect your APIs from SQL injection attacks.
- Combine these into a Web ACL and associate it with an API Gateway.

```python
import pulumi
import pulumi_aws as aws

# Define an IP Set - you would populate this with known bad IP addresses
ip_set = aws.waf.IpSet("ipSet",
    name="my-ip-set",
    ip_set_descriptors=[
        {"type": "IPV4", "value": "192.0.2.44/32"},
    ]
)

# Define a Size Constraint Set to block requests with bodies greater than 8192 bytes
size_constraint_set = aws.waf.SizeConstraintSet("sizeConstraintSet",
    name="my-size-constraint-set",
    size_constraints=[
        {
            "field_to_match": {
                "type": "BODY",
            },
            "text_transformation": "NONE",
            "comparison_operator": "GT",
            "size": 8192,
        },
    ]
)

# Define a SQL Injection Match Set
sql_injection_match_set = aws.waf.SqlInjectionMatchSet("sqlInjectionMatchSet",
    name="my-sql-injection-match-set",
    sql_injection_match_tuples=[
        {
            "field_to_match": {
                "type": "QUERY_STRING",
            },
            "text_transformation": "URL_DECODE",
        },
    ]
)

# Then you could define more Constraints and Rules as per your requirements...

# Finally, create a Web ACL and attach the rules
web_acl = aws.waf.WebAcl("webAcl",
    name="my-web-acl",
    default_action={
        "type": "ALLOW",
    },
    rules=[
        {"action": {"type": "BLOCK"}, "priority": 1, "rule_id": ip_set.id},
        {"action": {"type": "BLOCK"}, "priority": 2, "rule_id": size_constraint_set.id},
        {"action": {"type": "BLOCK"}, "priority": 3, "rule_id": sql_injection_match_set.id},
    ],
    # Optional: Add additional rules or rate-based rules if needed
)

# Output the Web ACL ID
pulumi.export('web_acl_id', web_acl.id)

# Note: You would then attach this ACL to the resource fronting your AI APIs,
# for example, an Application Load Balancer or Amazon API Gateway.
```

This program sets up the basic blocks for using AWS WAF:
- It first creates an `IpSet` where you can add IP addresses that you want to block.
- A `SizeConstraintSet` to define rules for the size of the HTTP request body.
- A `SqlInjectionMatchSet` to define rules for SQL injection patterns in query strings.

The `WebAcl` resource then combines these sets into a set of rules with actions to take (block the request in this case), and a default action if none of the rules match.

**Remember to handle permissions**:
Make sure that the role used to deploy this with Pulumi has the appropriate permissions to create and manage AWS WAF resources. If you need to assign permissions, you'll likely need the `waf:*` permission, or more fine-grained permissions depending on what exact operations you'll be performing.

After deploying this basic infrastructure, you'll need to attach the `WebAcl` to your resource, such as an Application Load Balancer or an API Gateway stage. Instructions for that would depend on the specifics of your API Gateway deployment and are beyond the scope of this initial setup.

This Pulumi program provides a good starting point. You would need to adapt it to your use case, possibly adding more rules and fine-tuning each rule based on actual traffic patterns and security requirements of your AI APIs.