Skip to content
The Chat Archive
gpt-4o-mini-2024-07-18· OpenAI WildChat-4.8M (AI2)

how to test fail2ban filter that i wrot4

  1. User

    how to test fail2ban filter that i wrot4

  2. Assistant

    Testing a Fail2Ban filter that you have written involves several steps to ensure that it correctly identifies patterns in the log files and triggers appropriate actions. Here’s how to do it:

    1. Create a Test Log File

    Create a log file that simulates the entries that you expect to match your Fail2Ban filter. For example, if your filter is supposed to match SSH login failures, you might want to add entries that resemble the failed login attempts.

    echo "Failed password for invalid user test from 192.168.1.5 port 22 ssh2" >> /var/log/your_test_log.log
    echo "Failed password for invalid user test from 192.168.1.6 port 22 ssh2" >> /var/log/your_test_log.log
    

    2. Configure the Fail2Ban Filter

    Ensure your filter configuration file is correctly set up in the /etc/fail2ban/filter.d/ directory. For example, if you created a filter file named myfilter.conf, you would ensure that it is properly written to match the log entries you've created.

    Here is an example of a basic filter:

    [Definition]
    failregex = Failed password for .* from <HOST>.*$
    ignoreregex =
    

    3. Configure the Jail

    Now, create or modify the jail configuration to use your filter. You can do this in /etc/fail2ban/jail.local or in a specific jail file.

    [myjail]
    enabled = true
    filter = myfilter
    logpath = /var/log/your_test_log.log
    maxretry = 3
    bantime = 3600
    

    4. Testing the Filter

    1. Reload Fail2Ban

    After configuring, reload Fail2Ban to apply your changes:

    sudo systemctl reload fail2ban
    
    1. Manually Trigger an Update

    You can trigger Fail2Ban to check for new entries using:

    sudo fail2ban-regex /var/log/your_test_log.log /etc/fail2ban/filter.d/myfilter.conf
    

    This command checks your test log against your filter and should output the lines that match, along with additional information regarding how many matches were found.

    5. Check Fail2Ban Status

    You can check the status of your jail to see if any IP addresses have been banned:

    sudo fail2ban-client status myjail
    

    This will show you the current status, how many IPs have been banned, etc.

    6. Testing the Ban

    To see if the banning works correctly, you can test for incorrect behavior. For instance, try to log in with incorrect credentials multiple times to see if your filter and jail trigger an action (ban the IP specified).

    7. Debugging

    If things are not working as expected, check the Fail2Ban log file for debugging information:

    cat /var/log/fail2ban.log
    

    This will contain messages that can help you troubleshoot issues with your filter or jail configuration.

    8. Cleanup You Test

    Once you are done testing, it’s important to clean up your test log file and configurations to maintain a clean environment:

    rm /var/log/your_test_log.log
    

    Final Note

    Make sure to adjust the configurations to reflect your actual use case and logs, as the examples provided are illustrative and may require modifications based on your specific setup.

  3. User

    write fail2ban regex for this

    _ 42.55.85.49 - - [15/Feb/2025:15:35:27 +0000] "\x00" 400 150 "-" "-" "-" 5.000 -

  4. Assistant

    To write a Fail2Ban failregex that matches the log entry you've provided, we need to identify the key components in the log format. Below is a breakdown of your log entry:

    _ 42.55.85.49 - - [15/Feb/2025:15:35:27 +0000] "\x00" 400 150 "-" "-" "-" 5.000 -
    

    Observations:

    1. IP Address: 42.55.85.49
    2. Timestamp: [15/Feb/2025:15:35:27 +0000]
    3. Request: "\x00"
    4. HTTP Status Code: 400
    5. Byte Size: 150
    6. Referrer: "-"
    7. User-Agent: "-"
    8. Response Time: 5.000
    9. Trailing Data: -

    Fail2Ban Regex

    To create a regex pattern that matches the above log format, we'll focus on capturing the IP address and the condition we want to react to, which, in this case, could be an HTTP status code 400. The regex will use the <HOST> placeholder for the IP address.

    Here’s a possible failregex pattern:

    [Definition]
    failregex = ^_ <HOST> - - \[\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4}\] "\x00" 400 \d+ "-" "-" "-" \d+\.\d+ -
    ignoreregex =
    

    Breakdown of the Failregex Pattern:

    • ^_ - Matches the _ at the start of the line.
    • <HOST> - This is a placeholder that will match the IP address (e.g., 42.55.85.49).
    • - - - Matches the - - literally.
    • \[ - Matches the opening square bracket [ for the timestamp.
    • \d{2} - Matches the day of the month (two digits).
    • /[a-zA-Z]{3}/ - Matches the abbreviated month (three letters).
    • \d{4} - Matches the year (four digits).
    • :\d{2}:\d{2}:\d{2} - Matches the hour, minute, and second (formatted as HH:MM:SS).
    • \+\d{4}\] - Matches the timezone offset and the closing square bracket.
    • "\x00" - Matches the request part literally, specifically the string "\x00".
    • 400 - Matches the HTTP status code 400.
    • \d+ - Matches the byte size as one or more digits.
    • "-" "-" "-" - Matches the referrer and user-agent (both -).
    • \d+\.\d+ - - Matches the response time and trailing -.

    Usage in Fail2Ban

    To use this in your Fail2Ban configuration:

    1. Place the regex in your filter file, for example, /etc/fail2ban/filter.d/myfilter.conf.
    [Definition]
    failregex = ^_ <HOST> - - \[\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4}\] "\x00" 400 \d+ "-" "-" "-" \d+\.\d+ -
    ignoreregex =
    
    1. Then configure your jail in /etc/fail2ban/jail.local to use this filter.

    Testing the Regex

    As mentioned previously, you can test your regex to ensure it behaves as expected using the fail2ban-regex command:

    fail2ban-regex /path/to/test.log /etc/fail2ban/filter.d/myfilter.conf
    

    Make sure to replace /path/to/test.log with the path to a log file containing entries that you want to test against your regex.

    Feel free to adjust the regex according to your specific needs or other patterns that might apply!

  5. User

    what is datepattern in filter? is it optional

  6. Assistant

    In Fail2Ban, the datepattern is a configuration option used within a filter definition to define the format of timestamps in the logs that you are scanning. This helps Fail2Ban accurately parse and match log entries that include timestamps.

    Purpose of datepattern

    The datepattern allows you to specify the format of the date and time in the log entries. This configuration is especially useful for logs with timestamps in different formats, as it instructs Fail2Ban how to interpret the timestamp while scanning log files.

    Example of Using datepattern

    Here’s a simple example of how the datepattern might be used within a filter file:

    [Definition]
    failregex = ^_ <HOST> - - \[(?P<date>\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4})\] ...
    datepattern = \d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4}
    

    In this example:

    • The regex captures a timestamp in the format 15/Feb/2025:15:35:27 +0000.
    • datepattern specifies the regex pattern for extracting the date, which can aid in timestamp comparisons within Fail2Ban's own logic.

    Is datepattern Optional?

    • Yes, it is optional. If your log entries do not include timestamps, or if you do not need to match or process the timestamp for any reason, you can omit the datepattern from your filter definition.
    • If the logs do include timestamps and you want to take advantage of date-related features in Fail2Ban (like comparing timestamps when filtering entries), then it's a good practice to define it.

    When to Use datepattern

    • Use datepattern when:
      • Your logs include timestamps.
      • You need to define a specific timestamp format for parsing and matching.
      • You want to enable additional processing based on timestamps.

    Conclusion

    In summary, while the datepattern is not strictly required and can be omitted if your logs do not utilize timestamps, including it can enhance log parsing and filtering functionality when dealing with logs that contain date information. If you are dealing with a specific log format that includes timestamps, it's best practice to define the datepattern to ensure accurate matching and processing.

  7. User

    could you write full filter for my log example line

  8. Assistant

    Certainly! Below is a complete Fail2Ban filter configuration for the log line you provided. The log line is:

    _ 42.55.85.49 - - [15/Feb/2025:15:35:27 +0000] "\x00" 400 150 "-" "-" "-" 5.000 -
    

    Step-by-Step Filter Explanation

    We'll create a filter that matches this specific log format by capturing the elements like the IP address, timestamp, request method, HTTP status code, and other parameters.

    Full Filter Configuration Example

    1. Create a filter file (e.g., myfilter.conf) in the Fail2Ban filter directory, usually located at /etc/fail2ban/filter.d/.
    sudo nano /etc/fail2ban/filter.d/myfilter.conf
    
    1. Add the following content to the filter file:
    # Fail2Ban filter for specific log lines indicating an unusual request pattern
    
    [Definition]
    # Regular expression to match the log line format
    failregex = ^_ <HOST> - - \[\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4}\] "\x00" 400 \d+ "-" "-" "-" \d+\.\d+ -
    
    # Optional: Date pattern for timestamps if you want to use date-related functionalities
    datepattern = \d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4}
    
    # Optional: Ignore regex for specific patterns that should not trigger bans
    ignoreregex =
    

    Explanation of the Filter Configuration:

    • [Definition]: This signifies the beginning of the filter definition.

    • failregex: The regular expression used to match the desired log lines.

      • ^_ <HOST>: Matches a log entry that starts with _ followed by an IP address (captured by <HOST>).
      • - -: Matches the literal - -.
      • \[... \]: Matches the timestamp. The expression here captures the format 15/Feb/2025:15:35:27 +0000.
      • "\x00": Matches the literal request part, specifically looking for "\x00".
      • 400: Matches the HTTP status code 400, indicating a Bad Request.
      • \d+: Matches the byte size (in your case 150).
      • "-" "-" "-": Matches the three - for the referrer and user-agent parts.
      • \d+\.\d+ -: Matches the response time (such as 5.000) and the trailing -.
    • datepattern: Specifies the format for the timestamp if you need to perform any date-related logic. This is optional.

    • ignoreregex: You can define patterns that should be ignored by this filter. Here it's left empty, meaning no specific entries are being ignored.

    Next Steps

    1. Create a Jail Configuration: After creating your filter, you will need to set up a corresponding jail to make Fail2Ban act on matches from this filter. Edit your jail configuration (typically in /etc/fail2ban/jail.local):
    [myjail]
    enabled = true
    filter = myfilter
    logpath = /path/to/your/log/file.log  # Adjust this to the correct log path
    maxretry = 3
    bantime = 3600  # 1 hour
    
    1. Reload Fail2Ban: After saving your filter and jail configurations, reload Fail2Ban to apply the changes.
    sudo systemctl reload fail2ban
    
    1. Test the Configuration: You can use fail2ban-regex to test that your filter works as expected:
    fail2ban-regex /path/to/sample.log /etc/fail2ban/filter.d/myfilter.conf
    
    1. Check Fail2Ban Status: Use this command to check the status of your jail and see if any bans have been triggered.
    sudo fail2ban-client status myjail
    

    Conclusion

    With this configuration, Fail2Ban will monitor the specified log file for entries matching your log line format and can take action (e.g., banning IPs) based on the defined rules. Adjust the configurations as needed for specific requirements in your environment!

  9. User

    Running tests

    Use failregex filter file : nginx-null-byte, basedir: /etc/fail2ban Use datepattern : \d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} +\d{4} Use log file : test.log Use encoding : UTF-8

    Traceback (most recent call last): File "/usr/bin/fail2ban-regex", line 34, in exec_command_line() File "/usr/lib/python3/dist-packages/fail2ban/client/fail2banregex.py", line 765, in exec_command_line if not fail2banRegex.start(args): File "/usr/lib/python3/dist-packages/fail2ban/client/fail2banregex.py", line 706, in start self.process(test_lines) File "/usr/lib/python3/dist-packages/fail2ban/client/fail2banregex.py", line 510, in process line_datetimestripped, ret, is_ignored = self.testRegex(line) File "/usr/lib/python3/dist-packages/fail2ban/client/fail2banregex.py", line 456, in testRegex found = self._filter.processLine(line, date) File "/usr/lib/python3/dist-packages/fail2ban/server/filter.py", line 594, in processLine return self.findFailure(tupleLine, date) File "/usr/lib/python3/dist-packages/fail2ban/server/filter.py", line 769, in findFailure dateTimeMatch = self.dateDetector.getTime(timeText, tupleLine[3]) File "/usr/lib/python3/dist-packages/fail2ban/server/datedetector.py", line 482, in getTime date = template.getDate(line, timeMatch[0], default_tz=self.__default_tz) File "/usr/lib/python3/dist-packages/fail2ban/server/datetemplate.py", line 337, in getDate return (reGroupDictStrptime(dateMatch.groupdict(), default_tz=default_tz), File "/usr/lib/python3/dist-packages/fail2ban/server/strptime.py", line 278, in reGroupDictStrptime date_result = datetime.datetime( TypeError: an integer is required (got type NoneType)

  10. Assistant

    The error traceback you've provided suggests that there's an issue with the date parsing related to the date format in your Fail2Ban filter, specifically while processing the timestamp. This typically indicates that the regex did not correctly extract the timestamp, resulting in a NoneType error when it tries to parse it.

    Possible Causes and Solutions

    1. Check the Date Format: Ensure that the regex in failregex is correctly extracting the timestamp. In your filter, the pattern I suggested includes a regex for the timestamp but does not include a named group to capture it (e.g., using (?P<date>...)), which is likely required by the date parser.

      Here’s how to modify the failregex to capture the timestamp explicitly:

      [Definition]
      failregex = ^_ <HOST> - - \[(?P<date>\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4})\] "\x00" 400 \d+ "-" "-" "-" \d+\.\d+ -
      datepattern = \d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4}
      ignoreregex =
      

      With (?P<date>...), you're explicitly naming the group for the date part. This allows Fail2Ban to pull the date correctly during processing.

    2. Testing the Regex: After making the changes, use the fail2ban-regex command to test the updated filter again against your log file. Make sure the test log (e.g., test.log) contains a line that matches your filter example exactly.

      fail2ban-regex test.log /etc/fail2ban/filter.d/myfilter.conf
      
    3. Sample Log Input: Ensure that test.log includes a log line similar to the original one you showed:

      _ 42.55.85.49 - - [15/Feb/2025:15:35:27 +0000] "\x00" 400 150 "-" "-" "-" 5.000 -
      
    4. Checking Fail2Ban Logs: If issues persist, check the Fail2Ban log file at /var/log/fail2ban.log to see if there are more clues or detailed errors related to the parsing of dates.

    5. Use of datepattern: Since you are capturing the date with the failregex, the datepattern might still be useful for other cases if there are further timestamps, but it might not be necessary if your filter logic works without it. First, try with just the failregex adjustment and verify its functionality.

    Conclusion

    Adjust the failregex to ensure it captures the date correctly, explicitly defining it in the regex. Then, test again with fail2ban-regex. This should alleviate the NoneType error related to date parsing when using the fail2ban-regex tool. If the problem persists or errors continue, review the log content and Fail2Ban's execution environment for further troubleshooting.

  11. User

    [Definition] failregex = ^_ - - [.] "\x00" 400 150 "-" .?$ ignoreregex =

    what is wrong with this regex

  12. Assistant

    The regex you've provided has a few issues that could result in Fail2Ban not functioning as intended. Let's break down your regex and identify what's problematic:

    Provided Regex Breakdown

    failregex = ^_ <HOST> - - [.*] "\x00" 400 150 "-" .*?$
    
    1. Pattern Components:
      • ^_: Matches the underscore (_) at the start of the line.
      • <HOST>: This correctly matches an IP address.
      • - -: Matches the literal characters - -.
      • [.*]: This component is problematic. Square brackets ([...]) in regex define a character class, which means it will match any single character within the brackets. .* inside the brackets would not work as expected because . means "any character" and * means "zero or more of the preceding element." Instead, it should be outside the brackets for it to match multiple characters.
      • "\x00": Matches the exact string "\x00" (which is correct).
      • 400 150: Matches the HTTP status code 400 and the byte size 150.
      • "-" .*?$: Matches a hyphen and then any other characters up to the end of the line. The .*?$ at the end is OK, but since you are interested in that part being a hyphen with possible whitespace or empty afterwards, it can be simplified.

    Suggested Correction

    Here's the corrected regex:

    [Definition]
    failregex = ^_ <HOST> - - \[.*\] "\x00" 400 150 "-" "-" "-" .*$ 
    ignoreregex =
    

    Key Changes Made:

    1. Timestamp: Changed [.*] to \[.*\]:

      • \[.*\]: This matches anything between the square brackets, which is correct for timestamps. You might want it more specific, but this will work as a catch-all.
    2. Regex Syntax:

      • Removed the ambiguity and confusion present in using [...] incorrectly.
    3. Character Groups:

      • Using .* after the last "-" can be improved or made more explicit if you expect specific content, but keeping it broad can work depending on your use case.

    Revised Full Filter Example (Optional Timestamp just to be clear):

    If you want to capture the date explicitly rather than just match any content between the brackets, you might use:

    [Definition]
    failregex = ^_ <HOST> - - \[(?P<date>\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4})\] "\x00" 400 150 "-" "-" "-" .*$ 
    ignoreregex =
    

    This captures the date in a named group called date, which Fail2Ban can use if further processing is needed.

    Conclusion

    Your original regex wasn't correctly matching the timestamp and potentially could lead to Fail2Ban failing to recognize relevant entries. By correcting the regex and ensuring proper constructs, you should have a regex that properly matches the log line you provided. Be sure to test the adjusted regex using fail2ban-regex with sample logs to confirm that it behaves as expected!

  13. User

    do i need to escape \x00 also?

  14. Assistant

    In the context of regex patterns, the need to escape specific characters or sequences depends on how you're using them. Let's clarify this in the context of Fail2Ban and your specific example.

    Understanding the \x00 Sequence

    • \x00: This is an escape sequence representing the null byte in hexadecimal notation. In many programming languages and regex implementations, it is interpreted as a non-printable character.

    In Your Fail2Ban Regex

    In the regex you provided, you are already using "\x00" correctly:

    "\x00"
    

    Here’s how it breaks down:

    • The double quotes (") surrounding \x00 are indicating that you are matching a string that includes the null byte itself.

    Do You Need to Escape It?

    • No, you do not need to escape \x00: In this context, it is correctly represented. You should keep it as is in your regex.
    • Possible Escape Situations: If you included any special regex characters (like ?, *, ., etc.) that are not relevant to your pattern, they would need to be escaped with a backslash (\). \x00 does not fall under this category.

    Final Regex Including \x00

    Here’s what your full modified regex including \x00 would look like:

    [Definition]
    failregex = ^_ <HOST> - - \[.*\] "\x00" 400 150 "-" "-" "-" .*$ 
    ignoreregex =
    

    Summary

    • Do not escape \x00: It is correctly formatted in your regex.
    • The pattern as a whole looks good for matching the log entries as per your previous examples.

    To reiterate, you should continue using "\\x00" as part of your regex without additional escapes. Just double-check your regex overall by testing it with your sample logs using the fail2ban-regex utility to ensure it behaves as expected!

  15. User

    but this not work on my log line

  16. Assistant

    Let's troubleshoot the regex and ensure it works correctly for your log line. The log line you've provided was:

    _ 42.55.85.49 - - [15/Feb/2025:15:35:27 +0000] "\x00" 400 150 "-" "-" "-" 5.000 -
    

    Complete Breakdown of the Log Line

    From the log line, we can identify key elements:

    1. Prefix: _
    2. IP Address: 42.55.85.49
    3. Timestamp: [15/Feb/2025:15:35:27 +0000]
    4. Request: "\x00"
    5. HTTP Status Code: 400
    6. Byte Size: 150
    7. Referrer: "-"
    8. User-Agent: "-"
    9. Response Time: 5.000
    10. Trailing Data: -

    Constructing an Accurate Regex

    Here’s a regex that captures the above components correctly, especially focusing on the timestamp specification:

    [Definition]
    failregex = ^_ <HOST> - - \[(?P<date>\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4})\] "\x00" 400 150 "-" "-" "-" \d+\.\d+ -
    ignoreregex =
    

    Key Components of the New Regex

    1. ^_ - Matches the leading underscore.
    2. <HOST> - Captures the IP address.
    3. - - - Matches the two hyphens literally.
    4. \[(?P<date>\d{2}/[a-zA-Z]{3}/\d{4}:\d{2}:\d{2}:\d{2} \+\d{4})\] - This captures the timestamp in the desired format (for example: 15/Feb/2025:15:35:27 +0000).
    5. "\x00" - Matches the request string "\x00".
    6. 400 - Matches the HTTP status code.
    7. 150 - Matches the byte size.
    8. "-" "-" "-" - Matches the three placeholders represented by hyphens.
    9. \d+\.\d+ - - Matches the response time followed by a hyphen.

    Testing the Regex

    1. Create a Test Log File: Ensure you have a log file (e.g., test.log) with the log line:

      echo '_ 42.55.85.49 - - [15/Feb/2025:15:35:27 +0000] "\x00" 400 150 "-" "-" "-" 5.000 -' > /path/to/test.log
      
    2. Run the Test with Fail2Ban: Use the fail2ban-regex command to test:

      fail2ban-regex /path/to/test.log /etc/fail2ban/filter.d/myfilter.conf
      
    3. Check for Matches: If it still does not match, ensure there are no additional whitespaces or variations in the log line that may affect regex matching.

    Conclusion

    Ensure that you correct the regex and match any additional log message formats based on the log file being used. With the specific regex provided, it should accurately capture entries similar to the one you've outlined. If it still does not work, please double-check that the log format does not have subtle differences or spaces that could be impacting the regex match.

  17. User

    [nginx-null-byte] enabled = true filter = nginx-null-byte logpath = /home/deployer/projects/1mi-v2/log/nginx/access.log maxretry = 1 action = iptables-ipset-proto6[name=nginx-null-byte, chain=FORWARD, port="http,https", p bantime = 12600 findtime = 60

    how to adapt this to ban on first find

  18. Assistant

    To adjust your Fail2Ban configuration to ban an IP immediately on the first detection (first find), you need to change the maxretry setting and ensure the findtime is set appropriately.

    Configuration Changes

    1. Set maxretry to 1: This is already done in your configuration. Setting maxretry to 1 means that if a violation of the filter condition is found, it will trigger an action.

    2. Adjust findtime: You may want the findtime to be very short, as this is the duration during which Fail2Ban will look for repeated violations. If you want to check for violations within 60 seconds and ban immediately after one occurrence, then your configuration is mostly correct.

    Updated Configuration Example

    Here’s a clear and concise version of your Fail2Ban jail configuration that incorporates these recommendations:

    [nginx-null-byte]
    enabled = true
    filter = nginx-null-byte
    logpath = /home/deployer/projects/1mi-v2/log/nginx/access.log
    maxretry = 1               # Ban after the first occurrence
    bantime = 12600            # Time (in seconds) for which the IP will be banned
    findtime = 60              # Time window to consider the maxretry (set to 60 seconds)
    action = iptables-ipset-proto6[name=nginx-null-byte, chain=FORWARD, port="http,https"]
    

    Explanation of Important Parameters:

    • maxretry = 1: This tells Fail2Ban to ban the IP after the first match of the filter.

    • findtime = 60: This is relevant for situations when you want to check across multiple entries. Since maxretry is 1, findtime essentially will not significantly impact your current configuration. You can choose to keep it at 60 seconds if you're planning on future adjustments that might consider multiple entries, or you can lower it further if you want quicker responsiveness.

    • bantime = 12600: This specifies that if an IP is banned, it will remain banned for 12600 seconds (3.5 hours) before it is automatically unbanned.

    Testing Your Configuration

    After modifying the jail configuration:

    1. Reload Fail2Ban: Make sure you reload Fail2Ban to apply the new settings.

      sudo systemctl reload fail2ban
      
    2. Testing with Sample Logs: Test with a log entry that matches your nginx-null-byte filter to ensure the configuration works as intended.

    3. Check Status of the Jail: You can monitor the status to see if bans are being applied immediately after the first find.

      sudo fail2ban-client status nginx-null-byte
      

    Conclusion

    With maxretry set to 1 and an appropriately defined findtime, Fail2Ban will ban the offending IP immediately after its first occurrence in the defined log. Be sure to continuously monitor the logs and the Fail2Ban statistics to ensure that it is functioning as expected.