F5 NGINX Security Technical Implementation Guide - V1R1

  • Version/Release: V1R1
  • Published: 2026-01-07
  • Released: 2025-11-25
  • Expand All:
  • Severity:
  • Sort:
Compare

Select any two versions of this STIG to compare the individual requirements

View

Select any old version/release of this STIG to view the previous requirements

This Security Technical Implementation Guide is published as a tool to improve the security of Department of Defense (DOD) information systems. The requirements are derived from the National Institute of Standards and Technology (NIST) 800-53 and related documents. Comments or proposed revisions to this document should be sent via email to the following address: disa.stig_spt@mail.mil.
b
NGINX must limit the number of concurrent sessions to an organization-defined number for all accounts and/or account types.
AC-10 - Medium - CCI-000054 - V-278380 - SV-278380r1172745_rule
RMF Control
AC-10
Severity
Medium
CCI
CCI-000054
Version
NGNX-APP-000010
Vuln IDs
  • V-278380
Rule IDs
  • SV-278380r1172745_rule
NGINX management includes the ability to control the number of users and user sessions that use an application. Limiting the number of allowed users and sessions per user is helpful in limiting risks related to denial-of-service (DoS) attacks. This requirement can be met via the application or by using information system session control provided by a web server with specialized session management capabilities. If it has been specified that this requirement will be handled by the application, the capability to limit the maximum number of concurrent single user sessions must be designed and built into the application. This requirement addresses concurrent sessions for information system accounts and does not address concurrent sessions by single users via multiple system accounts. The maximum number of concurrent sessions should be defined based upon mission needs and the operational environment for each system.
Checks: C-82914r1172691_chk

Determine path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. nginx -c <path to nginx config> -qT | grep worker_connections worker_connections 512; Verify "worker_connections" is set in the configuration to an organization-defined number. If the "worker_connections" is not set to an organization-defined number, this is a finding.

Fix: F-82819r1172744_fix

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Add or modify the number of "worker_connections" based on the needs of the application. Note: By default, NGINX limits the number of concurrent connections to 512 per worker process, and the number of worker processes is equal the number of CPUs present. This results in a maximum number of connections equal to "worker_connections" multiplied by the number of "worker_processes". In a proxy configuration, NGINX will use a connection on both the client side and the server side. This results in two connections for each client side connection. Restart NGINX: systemctl restart nginx

c
NGINX must use TLS 1.2, at a minimum, to protect data confidentiality using remote access.
AC-17 - High - CCI-000068 - V-278381 - SV-278381r1171895_rule
RMF Control
AC-17
Severity
High
CCI
CCI-000068
Version
NGNX-APP-000040
Vuln IDs
  • V-278381
Rule IDs
  • SV-278381r1171895_rule
Using older unauthorized versions or incorrectly configuring protocol negotiation makes the gateway vulnerable to known and unknown attacks that exploit vulnerabilities in this protocol. This requirement applies to Transport Layer Security (TLS) gateways (also known as Secure Sockets Layer [SSL] gateways), web servers, and web applications and is not applicable to virtual private network (VPN) devices. Application protocols such as HTTPS and DNSSEC use TLS as the underlying security protocol and thus are in scope for this requirement. NIST SP 800-52 provides guidance for client negotiation on either DOD-only or on public-facing servers. Satisfies: SRG-APP-000014, SRG-APP-000015, SRG-APP-000560, SRG-APP-000565
Checks: C-82915r1171893_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Verify "ssl_protocols" are set to TLSv1.2 or higher: nginx -c <path to nginx config> -qT | grep ssl_protocols ssl_protocols TLSv1.2 TLSv1.3; If "ssl_protocols" does not exist or does not specify TLSv1.2 or greater, this is a finding

Fix: F-82820r1171894_fix

Specify the allowed TLS protocols by adding the following line to the server {} block: ssl_protocols TLSv1.2 TLSv1.3; Restart NGINX with saved configuration: nginx -s reload

b
The NGINX service account must be configured to not have shell access.
AC-3 - Medium - CCI-000213 - V-278382 - SV-278382r1171898_rule
RMF Control
AC-3
Severity
Medium
CCI
CCI-000213
Version
NGNX-APP-000140
Vuln IDs
  • V-278382
Rule IDs
  • SV-278382r1171898_rule
To mitigate the risk of unauthorized access to sensitive information by entities that have been issued certificates by DOD-approved PKIs, all DOD systems (e.g., networks, web servers, and web portals) must be properly configured to incorporate access control methods that do not rely solely on the possession of a certificate for access. Successful authentication must not automatically give an entity access to an asset or security boundary. Authorization procedures and controls must be implemented to ensure each authenticated entity also has a validated and current authorization. Authorization is the process of determining whether an entity, once authenticated, is permitted to access a specific asset. Information systems use access control policies and enforcement mechanisms to implement this requirement. Access control policies include identity-based policies, role-based policies, and attribute-based policies. Access enforcement mechanisms include access control lists, access control matrices, and cryptography. These policies and mechanisms must be employed by the application to control access between users (or processes acting on behalf of users) and objects (e.g., devices, files, records, processes, programs, and domains) in the information system. This requirement is applicable to access control enforcement applications (e.g., authentication servers) and other applications that perform information and system access control functions.
Checks: C-82916r1171896_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Identify the NGINX runtime user: grep -E '^\s*user\s+' /etc/nginx/nginx.conf Expected output (example): user nginx; Verify the user has no login shell: getent passwd nginx Expected output: nginx:x:998:998:Nginx user:/nonexistent:/sbin/nologin Ensure the shell is "/sbin/nologin", "/usr/sbin/nologin", or "/bin/false". If the NGINX runtime user has shell access, this is a finding.

Fix: F-82821r1171897_fix

Set a nonlogin shell for the nginx user: sudo usermod -s /sbin/nologin nginx

b
The NGINX service account must be configured to not have admin group access.
AC-4 - Medium - CCI-001368 - V-278383 - SV-278383r1171901_rule
RMF Control
AC-4
Severity
Medium
CCI
CCI-001368
Version
NGNX-APP-000150
Vuln IDs
  • V-278383
Rule IDs
  • SV-278383r1171901_rule
A mechanism to detect and prevent unauthorized communication flow must be configured or provided as part of the system design. If information flow is not enforced based on approved authorizations, the system may become compromised. Information flow control regulates where information is allowed to travel within a system and between interconnected systems. The flow of all system information must be monitored and controlled so it does not introduce any unacceptable risk to the systems or data. Application-specific examples of enforcement occur in systems that employ rule sets or establish configuration settings that restrict information system services, or message-filtering capability based on message content (e.g., implementing key word searches or using document characteristics). Applications providing information flow control must be able to enforce approved authorizations for controlling the flow of information within the system in accordance with applicable policy.
Checks: C-82917r1171899_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Identify the NGINX runtime user: grep -E '^\s*user\s+' /etc/nginx/nginx.conf Expected output (example): user nginx; Ensure the user is not in a privileged group: id nginx Expected output: uid=980(nginx) gid=979(nginx) groups=979(nginx) The user should not be a member of sudo, wheel, admin, or similar elevated groups. If the NGINX runtime user is a member of an elevated group, this is a finding.

Fix: F-82822r1171900_fix

Remove the user from privileged groups: sudo gpasswd -d nginx sudo sudo gpasswd -d nginx wheel sudo gpasswd -d nginx admin

b
NGINX must display the Standard Mandatory DOD Notice and Consent Banner before granting access to the application.
AC-8 - Medium - CCI-000048 - V-278384 - SV-278384r1171904_rule
RMF Control
AC-8
Severity
Medium
CCI
CCI-000048
Version
NGNX-APP-000180
Vuln IDs
  • V-278384
Rule IDs
  • SV-278384r1171904_rule
Display of the DOD-approved use notification before granting access to the application ensures privacy and security notification verbiage used is consistent with applicable federal laws, Executive Orders, directives, policies, regulations, standards, and guidance. System use notifications are required only for access via logon interfaces with human users and are not required when such human interfaces do not exist. The banner must be formatted in accordance with DTM-08-060. Use the following verbiage for applications that can accommodate banners of 1300 characters: "You are accessing a U.S. Government (USG) Information System (IS) that is provided for USG-authorized use only. By using this IS (which includes any device attached to this IS), you consent to the following conditions: -The USG routinely intercepts and monitors communications on this IS for purposes including, but not limited to, penetration testing, COMSEC monitoring, network operations and defense, personnel misconduct (PM), law enforcement (LE), and counterintelligence (CI) investigations. -At any time, the USG may inspect and seize data stored on this IS. -Communications using, or data stored on, this IS are not private, are subject to routine monitoring, interception, and search, and may be disclosed or used for any USG-authorized purpose. -This IS includes security measures (e.g., authentication and access controls) to protect USG interests--not for your personal benefit or privacy. -Notwithstanding the above, using this IS does not constitute consent to PM, LE or CI investigative searching or monitoring of the content of privileged communications, or work product, related to personal representation or services by attorneys, psychotherapists, or clergy, and their assistants. Such communications and work product are private and confidential. See User Agreement for details." Use the following verbiage for operating systems that have severe limitations on the number of characters that can be displayed in the banner: "I've read & consent to terms in IS user agreem't." Satisfies: SRG-APP-000068, SRG-APP-000069, SRG-APP-000070
Checks: C-82918r1171902_chk

Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Check nginx.conf for a section that verifies that user consent has been given. Setting a cookie upon user acceptance after reading the banner and checking for the presence of that cookie is one way to accomplish this. Check for this block in nginx.conf under the http block: # Define whether consent has been given based on the cookie map $http_cookie $consent_given { "~*user_consent=1" 1; default 0; } Check nginx.conf for a section that handles user consent and setting the cookie under the server block: # Serve the consent banner page if consent is not given location /consent { default_type text/html; return 200 "<html><body> <h1>Consent Required</h1> <p>You are accessing a U.S. Government (USG) Information System (IS) that is provided for USG-authorized use only. By using this IS (which includes any device attached to this IS), you consent to the following conditions: -The USG routinely intercepts and monitors communications on this IS for purposes including, but not limited to, penetration testing, COMSEC monitoring, network operations and defense, personnel misconduct (PM), law enforcement (LE), and counterintelligence (CI) investigations. -At any time, the USG may inspect and seize data stored on this IS. -Communications using, or data stored on, this IS are not private, are subject to routine monitoring, interception, and search, and may be disclosed or used for any USG-authorized purpose. -This IS includes security measures (e.g., authentication and access controls) to protect USG interests--not for your personal benefit or privacy. -Notwithstanding the above, using this IS does not constitute consent to PM, LE or CI investigative searching or monitoring of the content of privileged communications, or work product, related to personal representation or services by attorneys, psychotherapists, or clergy, and their assistants. Such communications and work product are private and confidential. See User Agreement for details.</p> <a href='/set-consent'>I Accept</a> </body></html>"; } # Handle consent acceptance and set the cookie location /set-consent { add_header Set-Cookie "user_consent=1; Path=/; Max-Age=31536000; HttpOnly"; return 302 /; } location / { # Redirect users to the consent page if they haven't given consent if ($consent_given = 0) { return 302 /consent; } If NGINX is not configured to display the Standard Mandatory DOD Notice and Consent Banner before granting access to the application, this is a finding.

Fix: F-82823r1171903_fix

Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Configure nginx.conf for a section that verifies that user consent has been given. Setting a cookie upon user acceptance after reading the banner and checking for the presence of that cookie is one way to accomplish this. Add this block in nginx.conf under the http block: # Define whether consent has been given based on the cookie map $http_cookie $consent_given { "~*user_consent=1" 1; default 0; } Configure nginx.conf for a section that handles user consent and setting the cookie under the server block: # Serve the consent banner page if consent is not given location /consent { default_type text/html; return 200 "<html><body> <h1>Consent Required</h1> <p>You are accessing a U.S. Government (USG) Information System (IS) that is provided for USG-authorized use only. By using this IS (which includes any device attached to this IS), you consent to the following conditions: -The USG routinely intercepts and monitors communications on this IS for purposes including, but not limited to, penetration testing, COMSEC monitoring, network operations and defense, personnel misconduct (PM), law enforcement (LE), and counterintelligence (CI) investigations. -At any time, the USG may inspect and seize data stored on this IS. -Communications using, or data stored on, this IS are not private, are subject to routine monitoring, interception, and search, and may be disclosed or used for any USG-authorized purpose. -This IS includes security measures (e.g., authentication and access controls) to protect USG interests--not for your personal benefit or privacy. -Notwithstanding the above, using this IS does not constitute consent to PM, LE or CI investigative searching or monitoring of the content of privileged communications, or work product, related to personal representation or services by attorneys, psychotherapists, or clergy, and their assistants. Such communications and work product are private and confidential. See User Agreement for details.</p> <a href='/set-consent'>I Accept</a> </body></html>"; } # Handle consent acceptance and set the cookie location /set-consent { add_header Set-Cookie "user_consent=1; Path=/; Max-Age=31536000; HttpOnly"; return 302 /; } location / { # Redirect users to the consent page if they haven't given consent if ($consent_given = 0) { return 302 /consent; } Save nginx.conf, test the config, and reload NGINX: nginx -t && nginx -s reload

b
NGINX must provide audit records for DOD-defined auditable events.
AU-12 - Medium - CCI-000169 - V-278385 - SV-278385r1171907_rule
RMF Control
AU-12
Severity
Medium
CCI
CCI-000169
Version
NGNX-APP-000240
Vuln IDs
  • V-278385
Rule IDs
  • SV-278385r1171907_rule
Without the capability to generate audit records, it would be difficult to establish, correlate, and investigate the events relating to an incident, or identify those responsible for one. Audit records can be generated from various components within the application (e.g., process, module). Certain application functionalities may be audited as well. The list of audited events is the set of events for which audits are to be generated. This set of events is typically a subset of the list of all events for which the system can generating audit records. DOD has defined the list of events for which NGINX will provide an audit record generation capability as the following: (i) Successful and unsuccessful attempts to access, modify, or delete privileges, security objects, security levels, or categories of information (e.g., classification levels); (ii) Access actions, such as successful and unsuccessful logon attempts, privileged activities or other system level access, starting and ending time for user access to the system, concurrent logons from different workstations, successful and unsuccessful accesses to objects, all program initiations, and all direct access to the information system; and (iii) All account creation, modification, disabling, and termination actions. Satisfies: SRG-APP-000089, SRG-APP-000080, SRG-APP-000091, SRG-APP-000095, SRG-APP-000096, SRG-APP-000097, SRG-APP-000098, SRG-APP-000099, SRG-APP-000100, SRG-APP-000374, SRG-APP-000375, SRG-APP-000492, SRG-APP-000493, SRG-APP-000494, SRG-APP-000495, SRG-APP-000496, SRG-APP-000497, SRG-APP-000498, SRG-APP-000499, SRG-APP-000500, SRG-APP-000501, SRG-APP-000502, SRG-APP-000507
Checks: C-82919r1171905_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. cat &lt;path to config&gt; Verify that $server_name, $server_addr, $remote_addr, $remote_user, $time_local, $status, $request, $request_id, $http_user_agent, $http_x_forwarded_for, and/or any organization defined variables are included in any custom log_format directive. If a custom log_format is defined and does not include a minimum of $server_name, $server_addr, $remote_addr, $remote_user, $time_local, $status, $request, $request_id, $http_user_agent, and $http_x_forwarded_for, this is a finding.

Fix: F-82824r1171906_fix

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Include the $server_name, $server_addr, $remote_addr, $remote_user, $time_local, $status, $request, $request_id, $http_user_agent, $http_x_forwarded_for, or any organization defined variable in any custom log_format directives. For example: log_format custom '$remote_addr - $remote_user [$time_local] "$request" ' '$status $body_bytes_sent "$http_referer" ' '"$http_user_agent" "$http_x_forwarded_for"'; Restart NGINX: nginx -s reload

b
NGINX must allow only the information system security manager (ISSM) (or individuals or roles appointed by the ISSM) to select which auditable events are to be audited.
AU-12 - Medium - CCI-000171 - V-278386 - SV-278386r1171910_rule
RMF Control
AU-12
Severity
Medium
CCI
CCI-000171
Version
NGNX-APP-000250
Vuln IDs
  • V-278386
Rule IDs
  • SV-278386r1171910_rule
Without the capability to restrict which roles and individuals can select which events are audited, unauthorized personnel may be able to prevent the auditing of critical events. Misconfigured audits may degrade the system's performance by overwhelming the audit log. Misconfigured audits may also make it more difficult to establish, correlate, and investigate the events relating to an incident, or identify those responsible for one. The list of audited events is the set of events for which audits are to be generated. This set of events is typically a subset of the list of all events for which the system can generating audit records.
Checks: C-82920r1171908_chk

Check the current permissions of nginx.conf: ls -l /etc/nginx/nginx.conf -rw-r--r-- 1 root root 0 May 23 15:04 /etc/nginx/nginx.conf If file has write permissions for anyone other than the owner, this is a finding.

Fix: F-82825r1171909_fix

By default, nginx.conf has file permissions set to admins only. Performing the chmod command will set file permissions on nginx.conf. sudo chmod 600 /etc/nginx/nginx.conf This example command will set read/write permissions for the owner only.

b
NGINX must prevent the execution of unapproved modules.
SC-18 - Medium - CCI-001695 - V-278387 - SV-278387r1172701_rule
RMF Control
SC-18
Severity
Medium
CCI
CCI-001695
Version
NGNX-APP-000370
Vuln IDs
  • V-278387
Rule IDs
  • SV-278387r1172701_rule
Decisions regarding the employment of mobile code within organizational information systems are based on the potential for the code to cause damage to the system if used maliciously. Mobile code is defined as software modules obtained from remote systems, transferred across a network, and then downloaded and executed on a local system without explicit installation or execution by the recipient. Actions enforced before executing mobile code include prompting users prior to opening email attachments and disabling automatic execution. Usage restrictions and implementation guidance apply to both the selection and using the mobile code installed, downloaded, or executed on all endpoints (e.g., servers, workstations, and smart phones). This requirement applies to applications that execute, evaluate, or otherwise process mobile code (e.g., web applications, browsers, and antivirus applications).
Checks: C-82921r1172700_chk

Check nginx.conf for external modules being loaded (grep load_module). If additional modules are being loaded, confirm the directory does not include write or execute for other users. Determine the path to nginx config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. # grep load_module /etc/nginx/nginx.conf load_module modules/ngx_http_app_protect_module.so; # ls -la /etc/nginx/modules lrwxrwxrwx 1 root root 22 Oct 10 2023 modules -&gt; /usr/lib/nginx/modules # ls -la /usr/lib/nginx drwxr-xr-x root root 4096 Jan 30 2024 modules If directory where modules are loaded is writeable by other, this is a finding.

Fix: F-82826r1171912_fix

Set permissions on directory containing external modules to read only for "Other" only. The directory may be organizationally defined. The default path is /usr/lib/nginx/modules. # chmod o-wx /usr/lib/nginx/modules

b
NGINX must protect audit information from unauthorized access.
AU-9 - Medium - CCI-000162 - V-278388 - SV-278388r1171916_rule
RMF Control
AU-9
Severity
Medium
CCI
CCI-000162
Version
NGNX-APP-000400
Vuln IDs
  • V-278388
Rule IDs
  • SV-278388r1171916_rule
If audit data were to become compromised, then competent forensic analysis and discovery of the true source of potentially malicious system activity is difficult if not impossible to achieve. In addition, access to audit records provides information an attacker could potentially use to their advantage. To ensure the veracity of audit data, the information system and/or the application must protect audit information from any and all unauthorized access. This includes read, write, and copy access. This requirement can be achieved through multiple methods, which will depend upon system architecture and design. Commonly employed methods for protecting audit information include least privilege permissions as well as restricting the location and number of log file repositories. Additionally, applications with user interfaces to audit records must not allow for the unfettered manipulation of or access to those records via the application. If the application provides access to the audit data, the application becomes accountable for ensuring audit information is protected from unauthorized access. Audit information includes all information (e.g., audit records, audit settings, and audit reports) needed to successfully audit information system activity. Satisfies: SRG-APP-000118, SRG-APP-000119, SRG-APP-000120, SRG-APP-000121, SRG-APP-000122, SRG-APP-000123, SRG-APP-000267
Checks: C-82922r1171914_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Determine the location of the access and error logs: grep "_log" &lt;path to config&gt; Determine the permissions for the log files: ls -la &lt;path to error.log&gt; -rw-r--r-- 1 root root 0 May 23 15:04 /var/log/nginx/error.log ls -la &lt;path to access.log&gt; -rw-r--r-- 1 root root 0 May 23 15:04 /var/log/nginx/access.log If files have write permissions for anyone other than the owner, this is a finding.

Fix: F-82827r1171915_fix

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Determine the location of the access and error logs: grep "_log" <path to config> Set appropriate permissions for the log files: chmod 644 <path to error.log> chmod 644 <path to access.log>

b
NGINX must be configured to prohibit or restrict using ports, protocols, and/or services.
CM-7 - Medium - CCI-000382 - V-278389 - SV-278389r1172704_rule
RMF Control
CM-7
Severity
Medium
CCI
CCI-000382
Version
NGNX-APP-000510
Vuln IDs
  • V-278389
Rule IDs
  • SV-278389r1172704_rule
Authenticity protection provides protection against man-in-the-middle attacks/session hijacking and the insertion of false information into sessions. Application communication sessions are protected using transport encryption protocols, such as TLS. TLS provides web applications with a means to be able to authenticate user sessions and encrypt application traffic. Session authentication can be single (one-way) or mutual (two-way) in nature. Single authentication authenticates the server for the client, whereas mutual authentication provides a means for both the client and the server to authenticate each other. This requirement applies to applications that use communications sessions. This includes, but is not limited to, web-based applications and service-oriented architectures (SOA). This requirement addresses communications protection at the application session, versus the network packet, and establishes grounds for confidence at both ends of communications sessions in ongoing identities of other parties and in the validity of information transmitted. Depending on the required degree of confidentiality and integrity, web services/SOA will require using TLS mutual authentication (two-way/bidirectional). Satisfies: SRG-APP-000142, SRG-APP-000141, SRG-APP-000383, SRG-APP-000645
Checks: C-82923r1171917_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Review the configurations looking for any listen directives. If listen directives are enabled but unnecessary, this is a finding. Verify that listeners are using SSL and redirects to SSL-enabled listeners. # nginx -c &lt;path to nginx config&gt; -qT | grep -A5 listen listen 192.168.0.254:80; return 301 https://$host/$request_uri; } ` listen 192.168.0.254:443 ssl default_server; ... If the listen directive does not include SSL and there is not a redirect to an SSL listener, this is a finding.

Fix: F-82828r1171918_fix

Edit the NGINX configuration file(s) and remove any unnecessary listen directives. On listen directives that are organizationally defined to need TLS, ensure that the listen directive includes SSL and SSL redirection. After saving the configuration, reload NGINX: # nginx -s reload

b
NGINX must implement replay-resistant authentication mechanisms for network access.
IA-2 - Medium - CCI-001941 - V-278390 - SV-278390r1172747_rule
RMF Control
IA-2
Severity
Medium
CCI
CCI-001941
Version
NGNX-APP-000590
Vuln IDs
  • V-278390
Rule IDs
  • SV-278390r1172747_rule
A replay attack may enable an unauthorized user to gain access to the application. Authentication sessions between the authenticator and the application validating the user credentials must not be vulnerable to a replay attack. Anti-replay is a cryptographically based mechanism; thus, it must use FIPS-approved algorithms. An authentication process resists replay attacks if it is impractical to achieve a successful authentication by recording and replaying a previous authentication message. Note that the anti-replay service is implicit when data contains monotonically increasing sequence numbers and data integrity is ensured. Using DOD PKI is inherently compliant with this requirement for user and device access. Using Transport Layer Security (TLS), including application protocols such as HTTPS and DNSSEC, is also compliant. Configure the information system to use the hash message authentication code (HMAC) algorithm for authentication services to Kerberos, SSH, web management tool, and any other access method.
Checks: C-82924r1171920_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Identify authentication mechanism in use by checking whether NGINX is configured to protect access to administrative interfaces or APIs: grep -Ri 'auth_' /etc/nginx/nginx.conf grep -Ri 'proxy_pass' /etc/nginx/nginx.conf grep -Ri 'ssl_verify_client' /etc/nginx/nginx.conf Also inspect references to: auth_jwt auth_request ssl_client_certificate If JWT is in use, validate the config: auth_jwt_key_file /etc/nginx/jwt.pub; auth_jwt_require exp iat; Ensure the token includes expiration (exp) and ideally issued-at (iat) fields. If using mutual TLS: ssl_verify_client on; ssl_client_certificate /etc/nginx/certs/ca.pem; Ensure client-side certificate verification is required and the certificate authority (CA) trust is defined. If using auth_request: Ensure the upstream authentication server is enforcing replay resistance (such as nonce or short-lived tokens). Validate token behavior and session timeout logic. If no replay-resistant mechanism is found for network-based access, this is a finding.

Fix: F-82829r1172746_fix

Implement a replay-resistant authentication method for any NGINX Plus resource that allows network access. Option A: JWT with expiration: Configure NGINX to use JWT authentication: auth_jwt "Protected"; auth_jwt_key_file /etc/nginx/keys/jwt_key.pub; auth_jwt_require exp iat; Ensure the token issuer includes a short-lived exp (e.g., less than five minutes) and iat claims. Option B: Mutual TLS: Enable client certificate authentication: ssl_verify_client on; ssl_client_certificate /etc/nginx/certs/client_ca.pem;

b
NGINX must be configured to use a Certificate Revocation List (CRL) for certificate path validation and revocation. (Online Certificate Status Protocol [OCSP] is the preferred configuration.)
IA-5 - Medium - CCI-000185 - V-278391 - SV-278391r1171925_rule
RMF Control
IA-5
Severity
Medium
CCI
CCI-000185
Version
NGNX-APP-000720
Vuln IDs
  • V-278391
Rule IDs
  • SV-278391r1171925_rule
Without path validation, an informed trust decision by the relying party cannot be made when presented with any certificate not already explicitly trusted. To meet this requirement, the information system must create trusted channels between itself and remote trusted authorized IT product (e.g., syslog server) entities that protect the confidentiality and integrity of communications. The information system must create trusted paths between itself and remote administrators and users that protect the confidentiality and integrity of communications. A trust anchor is an authoritative entity represented via a public key and associated data. It is most often used in the context of public key infrastructures, X.509 digital certificates, and DNSSEC. However, applications that do not use a trusted path are not approved for nonlocal and remote management of DOD information systems. Use of SSHv2 to establish a trusted channel is approved. Use of FTP, TELNET, HTTP, and SNMPV1 is not approved since they violate the trusted channel rule set. Use of web management tools that are not validated by common criteria may also violate trusted channel rule set. When there is a chain of trust, usually the top entity to be trusted becomes the trust anchor; it can be, for example, a Certification Authority (CA). A certification path starts with the subject certificate and proceeds through a number of intermediate certificates up to a trusted root certificate, typically issued by a trusted CA. This requirement verifies that a certification path to an accepted trust anchor is used for certificate validation and that the path includes status information. Path validation is necessary for a relying party to make an informed trust decision when presented with any certificate not already explicitly trusted. Status information for certification paths includes certificate revocation lists or online certificate status protocol responses. Validation of the certificate status information is out of scope for this requirement. Satisfies: SRG-APP-000175, SRG-APP-000401
Checks: C-82925r1171923_chk

If using OCSP for certificate revocation, this requirement is Not Applicable. Determine the path to NGINX config file: # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. # cat &lt;path to config&gt; Check the http { blocks for the following example: http { server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/server.crt; ssl_certificate_key /etc/nginx/ssl/server.key; ssl_client_certificate /etc/nginx/ssl/ca.crt; ssl_verify_client on; ssl_crl /etc/nginx/ssl/crl.pem; ssl_ocsp on; ssl_ocsp_responder http://ocsp.disa.mil; ssl_stapling on; ssl_stapling_verify on; ssl_stapling_file /etc/nginx/ssl/ocsp_cache.pem; ssl_stapling_responder_timeout 3s; # Timeout for OCSP responder queries ssl_stapling_responder_error_cache_time 300s; # Cache time for responder errors location / { proxy_pass http://backend; } } } Check for certificate path validation. If "ssl_verify_client on" is not present in the configuration, this is a finding. Check if a CRL file is configured. If "ssl_crl &lt;file&gt;" is not present in the configuration, this is a finding.

Fix: F-82830r1171924_fix

If using OCSP for certificate revocation, this requirement is Not Applicable. Determine path to NGINX config file: # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. # cat <path to config> Configure the following lines in the http { blocks using the example below. Set ssl_verify_client on. Set ssl_crl /etc/nginx/ssl/crl.pem to match the CRL file name. http { server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/server.crt; ssl_certificate_key /etc/nginx/ssl/server.key; ssl_client_certificate /etc/nginx/ssl/ca.crt; ssl_verify_client on; ssl_crl /etc/nginx/ssl/crl.pem; ssl_ocsp on; ssl_ocsp_responder http://ocsp.disa.mil; ssl_stapling on; ssl_stapling_verify on; ssl_stapling_file /etc/nginx/ssl/ocsp_cache.pem; ssl_stapling_responder_timeout 3s; # Timeout for OCSP responder queries ssl_stapling_responder_error_cache_time 300s; # Cache time for responder errors location / { proxy_pass http://backend; } } }

b
NGINX, when using PKI-based authentication, must enforce authorized access to the corresponding private key.
IA-5 - Medium - CCI-000186 - V-278392 - SV-278392r1171928_rule
RMF Control
IA-5
Severity
Medium
CCI
CCI-000186
Version
NGNX-APP-000730
Vuln IDs
  • V-278392
Rule IDs
  • SV-278392r1171928_rule
If the private key is discovered, an attacker can use the key to authenticate as an authorized user and gain access to the network infrastructure. The cornerstone of the PKI is the private key used to encrypt or digitally sign information. If the private key is stolen, this will lead to the compromise of the authentication and nonrepudiation gained through PKI because the attacker can use the private key to digitally sign documents and pretend to be the authorized user. Both the holders of a digital certificate and the issuing authority must protect the computers, storage devices, or whatever they use to store private keys.
Checks: C-82926r1171926_chk

Determine the path to NGINX config file: nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. cat &lt;path to config&gt; Verify that private key(s) are only readable by the owner. Example: root@e4a935153ece:/etc/ssl/nginx# nginx -qT | grep certificate_key ssl_certificate_key /etc/ssl/nginx/server.key; root@e4a935153ece:/etc/ssl/nginx# ls -la /etc/ssl/nginx/server.key -rw------- 1 root root 1704 Dec 4 18:31 /etc/ssl/nginx/server.key If the private key(s) are readable anyone other than owner, this is a finding.

Fix: F-82831r1171927_fix

Change permissions on any TLS keys used in NGINX configuration: nginx -qT | grep certificate_key chmod 600 <path to TLS key> Example: root@e4a935153ece:/etc/ssl/nginx# nginx -qT | grep certificate_key ssl_certificate_key /etc/ssl/nginx/server.key; root@e4a935153ece:/etc/ssl/nginx# chmod 600 /etc/ssl/nginx/server.key Restart NGINX: nginx -s reload

b
NGINX must identify prohibited mobile code.
SC-18 - Medium - CCI-001166 - V-278393 - SV-278393r1171931_rule
RMF Control
SC-18
Severity
Medium
CCI
CCI-001166
Version
NGNX-APP-000850
Vuln IDs
  • V-278393
Rule IDs
  • SV-278393r1171931_rule
Decisions regarding the employment of mobile code within applications are based on the potential for the code to cause damage to the system if used maliciously. Mobile code is defined as software modules obtained from remote systems, transferred across a network, and then downloaded and executed on a local system without explicit installation or execution by the recipient. DOD has identified prohibited mobile code in DODI 8552.01 as: all Category 1X mobile code, unsigned Category 1A mobile code, Category 2 mobile code that violates usage requirements, all Emerging Technologies mobile code (all mobile code technologies, systems, platforms, or languages whose capabilities and threat level have not yet undergone a risk assessment and been assigned to a risk category), and all mobile code that downloads via an email body or email attachment that executes automatically when the user opens the email body or attachment. Usage restrictions and implementation guidance apply to both the selection and use of mobile code installed, downloaded, or executed on all endpoints (e.g., servers, workstations, and smart phones). This requirement applies to applications that execute, evaluate, or otherwise process mobile code (e.g., web applications, browsers, and antivirus applications). Satisfies: SRG-APP-000206, SRG-APP-000207, SRG-APP-000209, SRG-APP-000210
Checks: C-82927r1171929_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. # grep load_module /etc/nginx/nginx.conf load_module modules/ngx_http_app_protect_module.so; If modules are loaded that are not required or known, this is a finding.

Fix: F-82832r1171930_fix

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Remove any unnecessary or unpermitted modules from the configuration. After saving the configuration, reload NGINX: # nginx -s reload

b
NGINX must restrict the ability of individuals to launch denial-of-service (DoS) attacks against other information systems.
SC-5 - Medium - CCI-001094 - V-278394 - SV-278394r1171934_rule
RMF Control
SC-5
Severity
Medium
CCI
CCI-001094
Version
NGNX-APP-001030
Vuln IDs
  • V-278394
Rule IDs
  • SV-278394r1171934_rule
DoS is a condition in which a resource is not available for legitimate users. When this occurs, the organization either cannot accomplish its mission or must operate at degraded capacity. Individuals of concern can include hostile insiders or external adversaries that have successfully breached the information system and are using the system as a platform to launch cyberattacks on third parties. Applications and application developers must take the steps needed to ensure users cannot use an authorized application to launch DoS attacks against other systems and networks. For example, applications may include mechanisms that throttle network traffic so users are not able to generate unlimited network traffic via the application. Limiting system resources allocated to any user to a bare minimum may also reduce the ability of users to launch some DoS attacks. The methods employed to counter this risk will be dependent upon the application layer methods that can be used to exploit it.
Checks: C-82928r1171932_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Verify timeouts and send timeouts exist in config file and the timeout value of 10 seconds (or less) has been configured for client headers and body. nginx -c &lt;path to nginx config&gt; -qT | grep timeout client_body_timeout 10s; client_header_timeout 10s; send_timeout 10s; If the client_header_timeout, client_body_timeout and send_timeout are unset or have values greater than 10, this is a finding.

Fix: F-82833r1171933_fix

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Add or modify the client_body_timeout, client_header_timeout and send_timeout directives to have a value of 10 seconds or lower. Setting this value in the http context will cover everything unless overridden in subsequent server or location contexts. client_body_timeout 10s; client_header_timeout 10s; send_timeout 10s; After saving the configuration, reload NGINX: # nginx -s reload

b
NGINX must generate error messages that provide information necessary for corrective actions without revealing information that could be exploited by adversaries.
SI-11 - Medium - CCI-001312 - V-278395 - SV-278395r1172748_rule
RMF Control
SI-11
Severity
Medium
CCI
CCI-001312
Version
NGNX-APP-001070
Vuln IDs
  • V-278395
Rule IDs
  • SV-278395r1172748_rule
Any application providing too much information in error messages risks compromising the data and security of the application and system. The structure and content of error messages must be carefully considered by the organization and development team. Organizations carefully consider the structure/content of error messages. The extent to which information systems are able to identify and handle error conditions is guided by organizational policy and operational requirements. Information that could be exploited by adversaries includes, for example, erroneous logon attempts with passwords entered by mistake such as the username, mission/business information that can be derived from (if not stated explicitly by) information recorded, and personal information, such as account numbers, social security numbers, and credit card numbers.
Checks: C-82929r1171935_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Verify that the "server_tokens" directive is present, is not set to "on", and is not set to a custom string that identifies version information. nginx -c &lt;path to nginx config&gt; -qT | grep server_tokens server_tokens off; If the "server_tokens" directive is missing, this is a finding. If the "server_tokens" directive is set to "on", this is a finding. If the "server_tokens" directive includes the version number, this is a finding.

Fix: F-82834r1171936_fix

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Add or modify the "server_tokens" directive to set to "off" or set to a custom string without the version information. http { server_tokens off; ... } Restart nginx after modifying the configuration: # nginx -s reload

c
NGINX must off-load audit records to a central log server.
AU-4 - High - CCI-001851 - V-278396 - SV-278396r1172699_rule
RMF Control
AU-4
Severity
High
CCI
CCI-001851
Version
NGNX-APP-001400
Vuln IDs
  • V-278396
Rule IDs
  • SV-278396r1172699_rule
Information stored in one location is vulnerable to accidental or incidental deletion or alteration. Off-loading is a common process in information systems with limited audit storage capacity. Satisfies: SRG-APP-000358, SRG-APP-000125, SRG-APP-000515
Checks: C-82930r1171938_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Verify that "syslog:server= prefix" is included in any log directive: # cat &lt;path to config&gt; Find the "error_log: or "access_log" directives and verify the syslog:server= prefix is included. If "error_log" or "access_log" exists and does not include "syslog:server=", this is a finding.

Fix: F-82835r1172698_fix

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Include the "syslog:server= prefix" (which can be a domain name, an IP address, or a UNIX-domain socket path. A domain name or IP address can be specified with a port to override the default port, 514. A UNIX-domain socket path can be specified after the unix: prefix:) in any log directives and configure the optional parameters (facility, tag, severity). After saving the configuration, reload NGINX: # nginx -s reload

b
NGINX must restrict access to configuration files.
CM-5 - Medium - CCI-001813 - V-278397 - SV-278397r1171943_rule
RMF Control
CM-5
Severity
Medium
CCI
CCI-001813
Version
NGNX-APP-001590
Vuln IDs
  • V-278397
Rule IDs
  • SV-278397r1171943_rule
Failure to provide logical access restrictions associated with changes to application configuration may have significant effects on the overall security of the system. When dealing with access restrictions pertaining to change control, it must be noted that any changes to the hardware, software, and/or firmware components of the information system and/or application can potentially have significant effects on the overall security of the system. Accordingly, only qualified and authorized individuals must be allowed to obtain access to application components for the purposes of initiating changes, including upgrades and modifications. Logical access restrictions include, for example, controls that restrict access to workflow automation, media libraries, abstract layers (e.g., changes implemented into third-party interfaces rather than directly into information systems), and change windows (e.g., changes occur only during specified times, making unauthorized changes easy to discover). Satisfies: SRG-APP-000380, SRG-APP-000381
Checks: C-82931r1171941_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Check the permissions on the directory: # ls -la /etc drwxr-x-r-x 3 root root 4096 Sep 16 18:28 nginx If permissions to write are allowed for "Other", this is a finding.

Fix: F-82836r1171942_fix

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Ensure permissions on the configuration directory do not allow write permissions for "Other": # chmod o-w /etc/nginx

b
NGINX must be configured with a deny-all, permit-by-exception policy to allow the execution of authorized software programs.
CM-7 - Medium - CCI-001774 - V-278398 - SV-278398r1171946_rule
RMF Control
CM-7
Severity
Medium
CCI
CCI-001774
Version
NGNX-APP-001630
Vuln IDs
  • V-278398
Rule IDs
  • SV-278398r1171946_rule
Using an allowlist provides a configuration management method for allowing the execution of only authorized software. Using only authorized software decreases risk by limiting the number of potential vulnerabilities. The organization must identify authorized software programs and permit execution of authorized software. The process used to identify software programs that are authorized to execute on organizational information systems is commonly referred to as allowlisting. Verification of allowlisted software can occur either prior to execution or at system startup. This requirement applies to configuration management applications or similar types of applications designed to manage system processes and configurations (e.g., ESS and software wrappers). Satisfies: SRG-APP-000386, SRG-APP-000384
Checks: C-82932r1171944_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Verify allow/deny is set according to organizational policy: location / { allow 192.168.0.0; allow 10.0.0.0/16; deny all; } If allow or deny is not set to organizational policy, this is a finding.

Fix: F-82837r1171945_fix

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Set allow/deny according to organizational policy. Restart NGINX after modifying the configuration. # nginx -s reload

b
NGINX must be configured to require SSL sessions to reauthenticate no longer than 15 minutes.
IA-11 - Medium - CCI-002038 - V-278399 - SV-278399r1172775_rule
RMF Control
IA-11
Severity
Medium
CCI
CCI-002038
Version
NGNX-APP-001640
Vuln IDs
  • V-278399
Rule IDs
  • SV-278399r1172775_rule
Without reauthentication, users may access resources or perform tasks for which they do not have authorization. When applications provide the capability to change security roles or escalate the functional capability of the application, it is critical the user reauthenticate. In addition to the reauthentication requirements associated with session locks, organizations may require reauthentication of individuals and/or devices in other situations, including (but not limited to) the following circumstances. (i) When authenticators change; (ii) When roles change; (iii) When security categories of information systems change; (iv) When the execution of privileged functions occurs; (v) After a fixed period of time; or (vi) Periodically. Within the DOD, the minimum circumstances requiring reauthentication are privilege escalation and role changes.
Checks: C-82933r1172775_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Examine the SSL configuration settings: grep -R 'ssl_' /etc/nginx/nginx.conf Verify that "ssl_session_timeout" is not set to greater than 15. If "ssl_session_timeout" directive is missing or set to greater than 15, this is a finding.

Fix: F-82838r1171948_fix

Set the ssl_session_timeout directive to 15 or less. Note: The default setting is five minutes and meets the control, but this STIG explicitly sets the variable to not rely on a default which may change in future versions.

b
NGINX must accept Personal Identity Verification (PIV) credentials.
IA-2 - Medium - CCI-001953 - V-278400 - SV-278400r1172752_rule
RMF Control
IA-2
Severity
Medium
CCI
CCI-001953
Version
NGNX-APP-001650
Vuln IDs
  • V-278400
Rule IDs
  • SV-278400r1172752_rule
Using PIV credentials facilitates standardization and reduces the risk of unauthorized access. DOD has mandated using the CAC to support identity management and personal authentication for systems covered under HSPD 12, as well as a primary component of layered protection for national security systems. Satisfies: SRG-APP-000391, SRG-APP-000392, SRG-APP-000402, SRG-APP-000403
Checks: C-82934r1171950_chk

Determine path to NGINX config file: # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Check that the nginx.conf file has the SSL Certificate/Key installed, the SSL Client Certificate is present, and SSL Verify is configured. server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/server_cert.pem; ssl_certificate_key /etc/nginx/ssl/server_key.pem; # Enable client certificate verification ssl_client_certificate /etc/nginx/ca_cert.pem; ssl_verify_client on; # Optional: Set verification depth for client certificates ssl_verify_depth 2; location / { proxy_pass http://backend_service; # Restrict access to valid PIV credentials if ($ssl_client_verify != SUCCESS) { return 403; } } } If the certificates are not configured and ssl_verify is not enabled, this is a finding.

Fix: F-82839r1172751_fix

NGINX installs OpenSSL by default. If not installed, follow the OS documentation. Include the following lines in the server {} block of nginx.conf: ssl_certificate /etc/nginx/ssl/server_cert.pem; ssl_certificate_key /etc/nginx/ssl/server_key.pem; # Enable client certificate verification ssl_client_certificate /etc/nginx/ca_cert.pem; ssl_verify_client on; # Optional: Set verification depth for client certificates ssl_verify_depth 2; location / { proxy_pass http://backend_service; # Restrict access to valid PIV credentials if ($ssl_client_verify != SUCCESS) { return 403; } } Save and exit. Restart NGINX after modifying the configuration: # nginx -s reload

b
NGINX must be configured to expire cached authenticators after an organization-defined time period.
IA-5 - Medium - CCI-002007 - V-278401 - SV-278401r1171955_rule
RMF Control
IA-5
Severity
Medium
CCI
CCI-002007
Version
NGNX-APP-001690
Vuln IDs
  • V-278401
Rule IDs
  • SV-278401r1171955_rule
If cached authentication information is out of date, the validity of the authentication information may be questionable.
Checks: C-82935r1171953_chk

If a keyval store is not used to store tokens, this is not applicable. Determine path to NGINX config file: # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Determine if a keyval store is used and no timeout is specified: grep keyval &lt;location of config&gt; Example: keyval_zone zone=oidc_access_tokens:1M state=/var/lib/nginx/state/oidc_access_tokens.json timeout=1h; If a timeout is not specified to an organization defined timeout value, this is a finding.

Fix: F-82840r1171954_fix

Determine path to NGINX config file: # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Edit the config and set a timeout on any keyval storing credentials: keyval_zone zone=oidc_access_tokens:1M state=/var/lib/nginx/state/oidc_access_tokens.json timeout=1h; Restart NGINX: nginx -s reload

b
NGINX must be configured to pass security attributes to proxies.
SC-16 - Medium - CCI-002455 - V-278402 - SV-278402r1171958_rule
RMF Control
SC-16
Severity
Medium
CCI
CCI-002455
Version
NGNX-APP-001840
Vuln IDs
  • V-278402
Rule IDs
  • SV-278402r1171958_rule
If security attributes are not associated with the information being transmitted between components, then access control policies and information flows that depend on these security attributes will not function and unauthorized access may result. Security attributes are values associated with data content/structure and source/destination objects. These attributes are bound to the user and data objects and may include information about the data's purpose, creator, origin, access restrictions, access permissions, or classification. Specific security attributes used depend on the application or technology context. However, these attributes are used in information systems to implement security policy for access control and flow control for users, data, and traffic. Security attributes may be explicitly or implicitly associated with the information contained within the information system. This requirement applies to those applications that transmit or receive data between components. Information system components include, for example, mainframes, workstations, servers (e.g., database, email, authentication, web, proxy, file, domain name), input/output devices (e.g., scanners, copiers, printers), network components (e.g., firewalls, routers, gateways, voice and data switches, process controllers, wireless access points, network appliances, sensors), operating systems, virtual machines, middleware, and applications.
Checks: C-82936r1171956_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Verify the embedded security attributes are present as HTTP Headers: server { listen 443 ssl; server_name secure-api.example.com; location /data { proxy_pass http://backend_service; proxy_set_header X-Security-Classification "Confidential"; proxy_set_header X-Data-Origin "Internal-System"; proxy_set_header X-Access-Permissions "Read,Write"; } } If the "proxy_pass" variable is not set nor the "proxy_set_header" is not set for the required headers, this is a finding.

Fix: F-82841r1171957_fix

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Include the "proxy_pass" service as well as the "proxy_set_header" values as required: proxy_pass http://backend_service; proxy_set_header X-Security-Classification "Confidential"; proxy_set_header X-Data-Origin "Internal-System"; proxy_set_header X-Access-Permissions "Read,Write"; After saving the configuration, reload NGINX: # nginx -s reload

b
NGINX must only allow using DOD approved certificate authorities for PKI.
SC-23 - Medium - CCI-002470 - V-278403 - SV-278403r1171961_rule
RMF Control
SC-23
Severity
Medium
CCI
CCI-002470
Version
NGNX-APP-001900
Vuln IDs
  • V-278403
Rule IDs
  • SV-278403r1171961_rule
Untrusted Certificate Authorities (CA) can issue certificates, but they may be issued by organizations or individuals that seek to compromise DOD systems or by organizations with insufficient security controls. If the CA used for verifying the certificate is not a DOD-approved CA, trust of this CA has not been established. The DOD will only accept PKI certificates obtained from a DOD-approved internal or external certificate authority. Reliance on CAs for the establishment of secure sessions includes, for example, using TLS certificates. This requirement focuses on communications protection for the application session rather than for the network packet. This requirement applies to applications that use communications sessions. This includes, but is not limited to, web-based applications and service-oriented architectures (SOAs). Satisfies: SRG-APP-000427, SRG-APP-000177, SRG-APP-000910
Checks: C-82937r1171959_chk

Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Find any "ssl_certificate" ssl_client_certificate" directives and verify they are DOD approved. If the certificates are not DOD approved, this is a finding.

Fix: F-82842r1171960_fix

Replace any non-DOD issued certificates with DOD-issued certificates. After replacing the certificates, reload NGINX: # nginx -s reload

b
NGINX must protect against denial-of-service (DoS) attacks.
SC-5 - Medium - CCI-002385 - V-278404 - SV-278404r1171964_rule
RMF Control
SC-5
Severity
Medium
CCI
CCI-002385
Version
NGNX-APP-001940
Vuln IDs
  • V-278404
Rule IDs
  • SV-278404r1171964_rule
DoS is a condition when a resource is not available for legitimate users. When this occurs, the organization either cannot accomplish its mission or must operate at degraded capacity. This requirement addresses the configuration of applications to mitigate the impact of DoS attacks that have occurred or are ongoing on application availability. For each application, known and potential DoS attacks must be identified and solutions for each type implemented. A variety of technologies exist to limit or, in some cases, eliminate the effects of DoS attacks (e.g., limiting processes or restricting the number of sessions the application opens at one time). Employing increased capacity and bandwidth, combined with service redundancy, may reduce the susceptibility to some DoS attacks. Satisfies: SRG-APP-000435, SRG-APP-000247
Checks: C-82938r1171962_chk

Check for the "limit_req" or "limit_conn" directives in the NGINX configuration files: grep -R "limit_req\|limit_conn" /etc/nginx/ Determine if NGINX App Protect is enabled: grep -R "app_protect_enable on" /etc/nginx/ If the "lmit_req" or "limit connections" are not present, this is a finding.

Fix: F-82843r1171963_fix

Define a connection limiting zone. Open the NGINX configuration file in a text editor: sudo nano /etc/nginx/nginx.conf Establish a shared memory zone to track and limit connections from each client. Add this directive above the server block in the nginx.conf: limit_conn_zone $binary_remote_addr zone=conn_limit_zone:10m; $binary_remote_addr: Uses the client's IP address for limiting. zone=conn_limit_zone:10m: Allocates 10MB of memory for tracking connections. Adjust size based on your needs. Apply connection limiting in the server block. Now, apply connection limiting to the desired location block. Inside the location block, add the connection limiting directive: nginx Copy code server { location / { limit_req zone=one burst=20 nodelay; limit_conn conn_limit_zone 10; proxy_pass http://backend; } } limit_conn conn_limit_zone 10: Limits the client to 10 concurrent connections. Save and exit the file. Restart NGINX: # nginx -s reload

b
NGINX must be configured to use FIPS-approved algorithms to protect the confidentiality and integrity of transmitted information.
SC-8 - Medium - CCI-002418 - V-278405 - SV-278405r1171967_rule
RMF Control
SC-8
Severity
Medium
CCI
CCI-002418
Version
NGNX-APP-001960
Vuln IDs
  • V-278405
Rule IDs
  • SV-278405r1171967_rule
Without protection of the transmitted information, confidentiality and integrity may be compromised since unprotected communications can be intercepted and either read or altered. This requirement applies only to those applications that are either distributed or can allow access to data nonlocally. Use of this requirement will be limited to situations where the data owner has a strict requirement for ensuring data integrity and confidentiality is maintained at every step of the data transfer and handling process. When transmitting data, applications need to leverage transmission protection mechanisms, such as TLS, TLS VPNs, or IPsec. Communication paths outside the physical protection of a controlled boundary are exposed to the possibility of interception and modification. Protecting the confidentiality and integrity of organizational information can be accomplished by physical means (e.g., employing physical distribution systems) or by logical means (e.g., employing cryptographic techniques). If physical means of protection are employed, then logical means (cryptography) do not have to be employed, and vice versa. Satisfies: SRG-APP-000439, SRG-APP-000156, SRG-APP-000219, SRG-APP-000231, SRG-APP-000395, SRG-APP-000440, SRG-APP-000441, SRG-APP-000442, SRG-APP-000514, SRG-APP-000555, SRG-APP-000620
Checks: C-82939r1171965_chk

Determine the path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Examine the SSL configuration settings: grep -R 'ssl_' /etc/nginx/nginx.conf Verify TLS versions: ssl_protocols TLSv1.2 TLSv1.3; Verify cipher suites: ssl_ciphers 'TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256'; ssl_prefer_server_ciphers on; Note: The cipher list can be more restrictive if defined by the organization. If non-FIPS ciphers or weak protocols (e.g., TLSv1.0/1.1, RC4, MD5, 3DES) are present, this is a finding.

Fix: F-82844r1171966_fix

Restrict TLS versions to FIPS-approved protocols: ssl_protocols TLSv1.2 TLSv1.3; Configure only FIPS compliant ciphers: ssl_ciphers 'TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256'; Do not allow clients to select the ciphers: ssl_prefer_server_ciphers on; Restart NGINX to apply changes: sudo nginx -t && sudo systemctl reload nginx

b
NGINX must be configured to use Online Certificate Status Protocol (OCSP) for certificate path validation and revocation. (OCSP is the preferred configuration.)
IA-5 - Medium - CCI-000185 - V-278406 - SV-278406r1171970_rule
RMF Control
IA-5
Severity
Medium
CCI
CCI-000185
Version
NGNX-APP-002620
Vuln IDs
  • V-278406
Rule IDs
  • SV-278406r1171970_rule
A certificate's certification path is the path from the end entity certificate to a trusted root certification authority (CA). Certification path validation is necessary for a relying party to make an informed decision regarding acceptance of an end entity certificate. Certification path validation includes checks such as certificate issuer trust, time validity, and revocation status for each certificate in the certification path. Revocation status information for CA and subject certificates in a certification path is commonly provided via certificate revocation lists (CRLs) or OCSP responses. Satisfies: SRG-APP-000605, SRG-APP-000875
Checks: C-82940r1171968_chk

If using CRL for certificate revocation, this requirement is Not Applicable. Determine the path to NGINX config file(s): # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. # cat &lt;path to config&gt; Check the http { blocks for the following example: http { server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/server.crt; ssl_certificate_key /etc/nginx/ssl/server.key; ssl_client_certificate /etc/nginx/ssl/ca.crt; ssl_verify_client on; ssl_crl /etc/nginx/ssl/crl.pem; ssl_ocsp on; ssl_ocsp_responder http://ocsp.disa.mil; ssl_stapling on; ssl_stapling_verify on; ssl_stapling_file /etc/nginx/ssl/ocsp_cache.pem; ssl_stapling_responder_timeout 3s; # Timeout for OCSP responder queries ssl_stapling_responder_error_cache_time 300s; # Cache time for responder errors location / { proxy_pass http://backend; } } } Check for certificate path validation. If "ssl_verify_client on" is not in the configuration, this is a finding. Check if OCSP is enabled. If "ssl_ocsp on" is not in the configuration, this is a finding. Check if OCSP Stapling is configured. If "ssl_stapling on" or "ssl_stapling_verify on" is not in the configuration, this is a finding. If "ssl_stapling_file &lt;file&gt;" is not present in the configuration, this is a finding.

Fix: F-82845r1171969_fix

Edit the NGINX configuration file. Set "ssl_verify_client on", "ssl_ocsp on", ssl_stapling_verify on", and "ssl_stapling on" as shown in the example below. Create a local cache for OCSP responses: touch /etc/nginx/ssl/ocsp_cache.pem chmod 600 /etc/nginx/ssl/ocsp_cache.pem Set the "ssl_stapling_file" directive with the file created as shown in the example below. http { server { listen 443 ssl; server_name example.com; ssl_certificate /etc/nginx/ssl/server.crt; ssl_certificate_key /etc/nginx/ssl/server.key; ssl_client_certificate /etc/nginx/ssl/ca.crt; ssl_verify_client on; ssl_crl /etc/nginx/ssl/crl.pem; ssl_ocsp on; ssl_ocsp_responder https://ocsp.disa.mil; ssl_stapling on; ssl_stapling_verify on; ssl_stapling_file /etc/nginx/ssl/ocsp_cache.pem; ssl_stapling_responder_timeout 3s; # Timeout for OCSP responder queries ssl_stapling_responder_error_cache_time 300s; # Cache time for responder errors location / { proxy_pass http://backend; } } }

b
NGINX must be configured to use a FIPS-validated cryptographic module for confidentiality and integrity.
SC-13 - Medium - CCI-002450 - V-278407 - SV-278407r1172754_rule
RMF Control
SC-13
Severity
Medium
CCI
CCI-002450
Version
NGNX-APP-002660
Vuln IDs
  • V-278407
Rule IDs
  • SV-278407r1172754_rule
FIPS 140-2/140-3 precludes using invalidated cryptography for the cryptographic protection of sensitive or valuable data within federal systems. Unvalidated cryptography is viewed by NIST as providing no protection to the information or data. In effect, the data would be considered unprotected plaintext. If the agency specifies that the information or data be cryptographically protected, then FIPS 140-2/140-3 is applicable. In essence, if cryptography is required, it must be validated. Cryptographic modules that have been approved for classified use may be used in lieu of modules that have been validated against the FIPS 140-2/140-3 standard. The cryptographic module used must have at least one validated digital signature function. This validated hash algorithm must be used to generate digital signatures for all cryptographic security function within the product being evaluated. Satisfies: SRG-APP-000630, SRG-APP-000635
Checks: C-82941r1171971_chk

Verify NGINX is using OpenSSL with FIPS enabled. For version 1.x: # nginx -V nginx version: nginx/1.15.2 (nginx-plus-r16) built by gcc 4.8.5 20150623 (Red Hat 4.8.5-16) (GCC) built with OpenSSL 1.0.2k-fips 26 Jan 2017" If the response does not include "fips" in the OpenSSL version, this is a finding. For version 3.x: # openssl list -providers Providers: base name: OpenSSL Base Provider version: 3.2.2 status: active default name: OpenSSL Default Provider version: 3.2.2 status: active fips name: Red Hat Enterprise Linux 9 - OpenSSL FIPS Provider version: 3.2.2-622cc79c634cbbef status: active If the response does not list a FIPS provider with a status of "active", this is a finding.

Fix: F-82846r1172753_fix

FIPS must be enabled on the operating system. Follow the OS guidelines for installing FIPS mode. After installation, confirm that FIPS is enabled: # sudo sysctl –a | grep fips crypto.fips_enabled = 1 Install the FIPS-validated version of OpenSSL to the operating system.

b
The NGINX service account must be configured to lock changes to the password.
- Medium - CCI-004066 - V-278408 - SV-278408r1171976_rule
RMF Control
Severity
Medium
CCI
CCI-004066
Version
NGNX-APP-003040
Vuln IDs
  • V-278408
Rule IDs
  • SV-278408r1171976_rule
Password-based authentication applies to passwords regardless of whether they are used in single-factor or multifactor authentication. Long passwords or passphrases are preferable over shorter passwords. Enforced composition rules provide marginal security benefits while decreasing usability. However, organizations may choose to establish certain rules for password generation (e.g., minimum character length for long passwords) under certain circumstances and can enforce this requirement in IA-5(1)(h). Account recovery can occur, for example, in situations when a password is forgotten. Cryptographically protected passwords include salted one-way cryptographic hashes of passwords. The list of commonly used, compromised, or expected passwords includes passwords obtained from previous breach corpuses, dictionary words, and repetitive or sequential characters. The list includes context-specific words, such as the name of the service, username, and derivatives thereof.
Checks: C-82942r1171974_chk

Determine path to NGINX config file(s): nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Identify the NGINX runtime user: grep -E '^\s*user\s+' /etc/nginx/nginx.conf Expected output (example): user nginx; Confirm the password is locked: passwd -S nginx Expected output (example): nginx LK 2025-05-21 -1 -1 -1 -1 (Password locked.) If the NGINX runtime user account is not locked for password changes, this is a finding.

Fix: F-82847r1171975_fix

Lock the password for the NGINX user (if not already locked): sudo passwd -l nginx

b
NGINX must separate API maintenance sessions from other network sessions within the system by logically separated communications paths.
- Medium - CCI-004192 - V-278409 - SV-278409r1171979_rule
RMF Control
Severity
Medium
CCI
CCI-004192
Version
NGNX-APP-003060
Vuln IDs
  • V-278409
Rule IDs
  • SV-278409r1171979_rule
Nonlocal maintenance and diagnostic activities are conducted by individuals who communicate through either an external or internal network. Communications paths can be logically separated using encryption. Satisfies: SRG-APP-000880, SRG-APP-000039
Checks: C-82943r1171977_chk

If not using the NGINX API, this is Not Applicable. Determine path to NGINX config file: # nginx -qT | grep "# configuration" # configuration file /etc/nginx/nginx.conf: Note: The default NGINX configuration is "/etc/nginx/nginx.conf", though various files may also be included. Check that the nginx.conf file contains the API directive and a separate listen address: http { server { listen 192.168.0.1:80; location / { proxy_pass http://backend; } location /api { api write=on; } } } If the API is running on the same network as production traffic, this is a finding.

Fix: F-82848r1171978_fix

Configure the API directive to use a separate listen address from production traffic: http { server { listen 192.168.0.1:80; location / { proxy_pass http://backend; } } server { listen 10.0.0.1:80; location /api { api write=on; } } } After saving the updated config, restart NGINX: nginx -s reload.

b
NGINX must generate, manage, and protect from disclosure and misuse the cryptographic keys that protect access tokens.
- Medium - CCI-005156 - V-278410 - SV-278410r1172694_rule
RMF Control
Severity
Medium
CCI
CCI-005156
Version
NGNX-APP-003220
Vuln IDs
  • V-278410
Rule IDs
  • SV-278410r1172694_rule
Identity assertions and access tokens are typically digitally signed. The private keys used to sign these assertions and tokens are protected commensurate with the impact of the system and information resources that can be accessed. Satisfies: SRG-APP-000965, SRG-APP-000970
Checks: C-82944r1172693_chk

Check SSL/TLS certificate and private key file permissions: # ls -la /home/ubuntu/nginx.com.crt # ls -la /home/ubuntu/nginx.com.key Verify: - Certificate file permissions are 644 or more restrictive. - Private key file permissions are 600 or more restrictive. - Files are owned by nginx user or root. - Files are not world-readable or group-writable. If these permissions are not set, this is a finding. Verify certificate validity and strength: # openssl x509 -in /home/ubuntu/nginx.com.crt -text -noout Verify: - Certificate is not expired. - Uses RSA key length of 2048 bits minimum or ECDSA P-256 minimum. - Signature algorithm is SHA-256 or stronger (not SHA-1 or MD5). - Certificate chain is complete and valid. If these values are not met, this is a finding. Verify private key strength and protection: # openssl rsa -in /home/ubuntu/nginx.com.key -text -noout -check Verify: - Key length is 2048 bits minimum. - Key is not encrypted with weak algorithms. - Key passes integrity check. If these key values are not set, this is a finding.

Fix: F-82849r1171981_fix

Set proper file permissions for SSL certificate and private key: # chmod 644 /home/ubuntu/nginx.com.crt # chmod 600 /home/ubuntu/nginx.com.key # chown nginx:nginx /home/ubuntu/nginx.com.crt # chown nginx:nginx /home/ubuntu/nginx.com.key Move certificates to secure location: # mkdir -p /etc/nginx/ssl # mv /home/ubuntu/dev.sports.com.* /etc/nginx/ssl/ # chmod 700 /etc/nginx/ssl Update NGINX configuration to use secure certificate location: server { listen 443 ssl; ssl_certificate /etc/nginx/ssl/nginx.com.crt; ssl_certificate_key /etc/nginx/ssl/nginx.com.key; ssl_session_cache shared:SSL:10m; ssl_dhparam /etc/nginx/ssl/dhparam.pem; } Generate strong DH parameters if not present: # openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048 # chmod 644 /etc/nginx/ssl/dhparam.pem

b
NGINX must revoke access tokens in accordance with organization-defined identification and authentication policy.
- Medium - CCI-005167 - V-278411 - SV-278411r1172756_rule
RMF Control
Severity
Medium
CCI
CCI-005167
Version
NGNX-APP-003330
Vuln IDs
  • V-278411
Rule IDs
  • SV-278411r1172756_rule
An access token is a piece of data that represents the authorization granted to a user or NPE to access specific systems or information resources. Access tokens enable controlled access to services and resources. Properly managing the lifecycle of access tokens, including their issuance, validation, and revocation, is crucial to maintaining confidentiality of data and systems. Restricting token validity to a specific audience, e.g., an application or security domain, and restricting token validity lifetimes are important practices. Access tokens are revoked or invalidated if they are compromised, lost, or are no longer needed to mitigate the risks associated with stolen or misused tokens. Satisfies: SRG-APP-001020, SRG-APP-001025
Checks: C-82945r1172755_chk

Verify NGINX Plus revokes or invalidates access tokens: Check support for token revocation enforcement: # grep -i "introspect\|revok\|blacklist\|logout" /etc/nginx/conf.d/*.conf Confirm token validation includes checking revocation status using: - OAuth2 introspection endpoint. - Token revocation list. - Allowlist or deny-list implementation. - Explicit session logout propagation. Inspect logout and session termination handling: # grep -i "session_timeout\|logout\|revoke" /etc/nginx/conf.d/*.conf Ensure sessions are invalidated upon: - User logout. - Token expiration. - Authentication source change (e.g., password reset). Token revocation events (manual or automatic) must be logged with user ID, reason, and timestamp. If NGINX Plus does not support access token revocation or fails to enforce revocation upon compromise or logout, this is a finding.

Fix: F-82850r1171984_fix

Configure NGINX Plus to enforce access token revocation mechanisms. Enable token revocation via introspection endpoint (OIDC/OAuth2): location = /token/introspect { internal; proxy_pass https://auth.example.mil/oauth2/introspect; proxy_set_header Content-Type "application/x-www-form-urlencoded"; proxy_pass_request_body on; proxy_set_body "token=$http_authorization"; } Fail-closed on invalid or revoked token: location /secure/ { auth_request /token/introspect; error_page 401 = @error_revoke; } location @error_revoke { return 401 "Access token revoked or invalid."; } Revoke tokens during logout flows: Redirect logout requests to IdP to invalidate tokens: location = /logout { return 302 https://auth.example.mil/logout?token=$http_authorization; } Log all token revocation events: log_format token_revocation '$remote_addr - $remote_user [$time_local] ' '"$request" status=$status ' 'token_id="$jwt_jti" revoked="true" '; access_log /var/log/nginx/token_revocation.log token_revocation;