diff --git a/data_sources/java_hotspot_exceptions.yml b/data_sources/java_hotspot_exceptions.yml new file mode 100644 index 0000000000..c9b63dd687 --- /dev/null +++ b/data_sources/java_hotspot_exceptions.yml @@ -0,0 +1,43 @@ +name: Java HotSpot Exceptions +id: ed7674d5-562b-4df8-a3d1-e1f38b973686 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: | + Custom HotSpot unified exception diagnostics, separate from application and container logs. A stock JDK does not create an exceptions.log file; its default unified logging sends warning and error messages to stdout. Tomcat writes JULI logs under ${catalina.base}/logs, Spring Boot writes application logs to the console by default, and Elasticsearch uses its configured log directory. None of those application logs supplies this HotSpot stream by default. + + Add a JVM startup option such as `-Xlog:exceptions=debug:file=/var/log/myapp/exceptions-%p.log:utctime,pid,level,tags:filecount=8,filesize=16m`. Replace the directory with one writable by the Java service account; `%p` makes the filename process-specific. For Tomcat started by its scripts, set CATALINA_OPTS in CATALINA_BASE/bin/setenv.sh or setenv.bat; for a Windows Tomcat service, set its Java options in the service configuration. For Spring Boot, add the option to the `java` command or service/container JVM arguments, not `logging.file.name`, which configures application logging. For Elasticsearch, add a .options file under config/jvm.options.d (tar/zip or Docker) or /etc/elasticsearch/jvm.options.d (Debian/RPM). Preserve the product's existing JVM logging settings. + + Forward the configured file and its rotations with a file monitor such as `[monitor:///var/log/myapp/exceptions-*.log*]`, and assign the custom sourcetype java:hotspot:exceptions. On the Splunk parsing tier, use SHOULD_LINEMERGE=false, TIME_PREFIX=^\[, TIME_FORMAT=%Y-%m-%dT%H:%M:%S.%3N%z, and MAX_TIMESTAMP_LOOKAHEAD=32. Search-time field extraction is optional for the associated detections: they can parse the decorated raw lines with SPL `rex` and use `coalesce` to accept either raw or extracted fields. If you want reusable jvm_pid, jvm_tags, and jvm_message fields outside these detections, set KV_MODE=none on the search head and use the extraction below (or a shared REPORT transform): + + EXTRACT-jvm_unified = ^\[(?[^\]]+)\]\[(?\d+)\]\[(?[^\]]+)\]\[(?[^\]]+)\]\s*(?.*)$ + + Confirm that the raw events retain the `[utctime][pid][level][tags] message` format and that the host matches endpoint telemetry. When props.conf extraction is configured, verify the fields as well. Exception logging can be high volume; size the rotation and retention accordingly. Some continuation lines lack the decorators and will not match either single-line extraction. + + JVM option reference: https://docs.oracle.com/en/java/javase/21/docs/specs/man/java.html + Tomcat logging: https://tomcat.apache.org/tomcat-11.0-doc/logging.html + Spring Boot logging: https://docs.spring.io/spring-boot/reference/features/logging.html + Elasticsearch JVM settings: https://www.elastic.co/docs/reference/elasticsearch/jvm-settings +mitre_components: + - Application Log Content + - Process Metadata +source: exceptions-*.log +sourcetype: java:hotspot:exceptions +supported_TA: [] +fields: + - _time + - host + - source + - sourcetype + - jvm_event_time + - jvm_pid + - jvm_level + - jvm_tags + - jvm_message +output_fields: + - jvm_pid + - jvm_tags + - jvm_message +example_log: |- + [2026-11-17T20:47:53.225+0000][10181][debug][exceptions] java.lang.IllegalArgumentException in java.util.Base64$Decoder diff --git a/data_sources/java_hotspot_fatal_error.yml b/data_sources/java_hotspot_fatal_error.yml new file mode 100644 index 0000000000..90420e7d00 --- /dev/null +++ b/data_sources/java_hotspot_fatal_error.yml @@ -0,0 +1,32 @@ +name: Java HotSpot Fatal Error +id: 1052f27b-1818-4dd7-98c0-a73eeeee7873 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: | + HotSpot fatal error reports are created only after a fatal JVM error. Without -XX:ErrorFile, the JDK tries to write hs_err_pid.log in the process working directory and falls back to the operating-system temporary directory if needed. On Linux this fallback is /tmp; on Windows it follows TMP or TEMP. Tomcat and Spring Boot do not supply one universal working directory, so inspect the service configuration. Elasticsearch sets its own JVM fatal-error path in its logging directory: /var/log/elasticsearch for Debian/RPM packages or the installation's logs directory for tar/zip distributions. + + To make collection predictable, set a writable absolute path such as `-XX:ErrorFile=/var/log/myapp/hs_err_pid%p.log` in the JVM startup options. For Tomcat scripts use CATALINA_OPTS in setenv.sh or setenv.bat; for a Windows Tomcat service use its Java options. For Spring Boot set the Java service/container arguments. For Elasticsearch inspect its existing -XX:ErrorFile setting in jvm.options before changing it. Monitor the chosen path as java:hotspot:fatal. Extract jvm_pid from the hs_err_pid filename if needed; these reports do not share the unified-log `[time][pid][level][tags]` format or guarantee a jvm_message field. A fatal report is not a required result of exploitation. + + JDK fatal-error location: https://docs.oracle.com/en/java/javase/24/troubleshoot/location-fatal-error-log.html + Elasticsearch JVM settings: https://www.elastic.co/docs/reference/elasticsearch/jvm-settings +mitre_components: + - Application Log Content + - Process Termination +source: hs_err_pid*.log +sourcetype: java:hotspot:fatal +supported_TA: [] +fields: + - _time + - host + - source + - sourcetype + - jvm_pid + - _raw +output_fields: + - jvm_pid + - source + - _raw +example_log: |- + A fatal error has been detected by the Java Runtime Environment: SIGSEGV diff --git a/data_sources/java_hotspot_jit.yml b/data_sources/java_hotspot_jit.yml new file mode 100644 index 0000000000..56b5ff0a66 --- /dev/null +++ b/data_sources/java_hotspot_jit.yml @@ -0,0 +1,37 @@ +name: Java HotSpot JIT +id: 2b9c9f97-1e72-4be6-9e3e-0f8681bb86ad +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: | + Custom HotSpot JIT compilation diagnostics, separate from Tomcat, Spring Boot, and Elasticsearch application logs. A stock JDK does not create a jit.log file or emit JIT compilation details at its default warning/error unified logging level. The file path is chosen by the JVM startup configuration, regardless of the application framework. + + Add a JVM startup option such as `-Xlog:jit+compilation=debug:file=/var/log/myapp/jit-%p.log:utctime,pid,level,tags:filecount=8,filesize=16m`. Create a directory writable by the Java service account and preserve existing JVM options. For Tomcat started by its scripts, set CATALINA_OPTS in CATALINA_BASE/bin/setenv.sh or setenv.bat; for a Windows Tomcat service, use its Java options. For Spring Boot, add the option to the `java` command or service/container JVM arguments. For Elasticsearch, use config/jvm.options.d for tar/zip or Docker and /etc/elasticsearch/jvm.options.d for Debian/RPM. + + Forward the configured file and rotations with a file monitor such as `[monitor:///var/log/myapp/jit-*.log*]`, and assign the custom sourcetype java:hotspot:jit. On the Splunk parsing tier, use SHOULD_LINEMERGE=false, TIME_PREFIX=^\[, TIME_FORMAT=%Y-%m-%dT%H:%M:%S.%3N%z, and MAX_TIMESTAMP_LOOKAHEAD=32. The associated detection can parse `[utctime][pid][level][tags] message` directly from _raw with SPL `rex`, so props.conf search-time field extraction is optional. If you want reusable fields outside the detection, set KV_MODE=none on the search head and extract jvm_pid, jvm_tags, and jvm_message with the same EXTRACT regex or REPORT transform described in Java HotSpot Exceptions. Verify the raw format, optional fields, and host naming before using the detection. A JIT message shows compilation activity, not that a particular intrinsic executed. + + JVM option reference: https://docs.oracle.com/en/java/javase/21/docs/specs/man/java.html + Elasticsearch JVM settings: https://www.elastic.co/docs/reference/elasticsearch/jvm-settings +mitre_components: + - Application Log Content + - Process Metadata +source: jit-*.log +sourcetype: java:hotspot:jit +supported_TA: [] +fields: + - _time + - host + - source + - sourcetype + - jvm_event_time + - jvm_pid + - jvm_level + - jvm_tags + - jvm_message +output_fields: + - jvm_pid + - jvm_tags + - jvm_message +example_log: |- + [2026-11-17T20:47:52.225+0000][10181][debug][jit,compilation] java.util.Base64$Decoder::decode0 diff --git a/data_sources/sysmon_for_linux_eventid_5.yml b/data_sources/sysmon_for_linux_eventid_5.yml new file mode 100644 index 0000000000..95dd93db70 --- /dev/null +++ b/data_sources/sysmon_for_linux_eventid_5.yml @@ -0,0 +1,45 @@ +name: Sysmon for Linux EventID 5 +id: 90e933ac-a4f8-451a-9bd5-16fd61c40910 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Logs process termination on Linux, including the image and PID of the process that exited. +mitre_components: + - Process Termination + - Process Metadata +source: Syslog:Linux-Sysmon/Operational +sourcetype: sysmon:linux +separator: EventID +separator_value: '5' +supported_TA: + - name: Splunk Add-on for Sysmon for Linux + url: https://splunkbase.splunk.com/app/6652 + version: 1.0.0 +fields: + - _time + - Computer + - EventID + - Image + - ProcessGuid + - ProcessId + - RuleName + - UtcTime + - User + - dest + - host + - index + - process_guid + - process_id + - process_name + - process_path + - source + - sourcetype +output_fields: + - dest + - process_guid + - process_id + - process_name + - process_path + - user +example_log: 5Linux-Sysmon/Operationalar-linux-2026-11-17 20:48:00.000{ec23eae3-3a27-62f2-085e-16549b550000}10181/usr/bin/javaubuntu diff --git a/data_sources/zeek_http_post_body.yml b/data_sources/zeek_http_post_body.yml new file mode 100644 index 0000000000..ce71b1b0fd --- /dev/null +++ b/data_sources/zeek_http_post_body.yml @@ -0,0 +1,60 @@ +name: Zeek HTTP POST Body +id: 6e1fbb4c-d568-43b4-910d-3a3fdef03ae0 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: | + Custom HTTP/1.1 POST-body log. The TA for Zeek does not produce or parse this stream. + + The Zeek logger writes one JSON record per completed POST request to http_post_body.log. Include uid, the connection tuple, method, uri, body, body_bytes, logged_bytes, and truncated. Limit the captured body to 64 KiB. + + Download the custom http-post-body.zeek script from https://gist.github.com/nasbench/4cd18a938056cbfbc8a9832edb26f4c4 and place it in /opt/zeek/share/zeek/site/. This script is not included with ESCU or the TA for Zeek. Add `redef LogAscii::use_json = T;` and `@load ./http-post-body` to + /opt/zeek/share/zeek/site/local.zeek, then run `sudo /opt/zeek/bin/zeekctl deploy`. The sensor must see HTTP request plaintext. + + On the Zeek forwarder, add this inputs.conf stanza (replace zeek with your index): + + [monitor:///opt/zeek/logs/current/http_post_body.log] + disabled = 0 + index = zeek + sourcetype = zeek:http_post_body:json + + Add this props.conf stanza on the parsing tier for line handling and on the search head for JSON extraction: + + [zeek:http_post_body:json] + SHOULD_LINEMERGE = false + TRUNCATE = 524288 + KV_MODE = json + + Restart or reload the affected components and configure the zeek_http_post_body macro to select the indexed events. + Confirm that uid, id.orig_h, id.resp_h, uri, body, and truncated are extracted, and use only truncated=false events for complete bodies. +mitre_components: + - Network Traffic Content + - Application Log Content +source: http_post_body.log +sourcetype: zeek:http_post_body:json # Custom sourcetype +configuration: https://gist.github.com/nasbench/4cd18a938056cbfbc8a9832edb26f4c4 +supported_TA: [] +fields: + - ts + - uid + - id.orig_h + - id.orig_p + - id.resp_h + - id.resp_p + - method + - uri + - host + - body + - body_bytes + - logged_bytes + - truncated +output_fields: + - uid + - id.orig_h + - id.resp_h + - uri + - body + - truncated +example_log: |- + {"ts":1794948473.225,"uid":"Cexample123","id.orig_h":"10.0.2.1","id.resp_h":"10.0.2.13","method":"POST","uri":"/test","body":"{}","body_bytes":2,"logged_bytes":2,"truncated":false} diff --git a/data_sources/zeek_http_request_headers.yml b/data_sources/zeek_http_request_headers.yml new file mode 100644 index 0000000000..bc43b17672 --- /dev/null +++ b/data_sources/zeek_http_request_headers.yml @@ -0,0 +1,64 @@ +name: Zeek HTTP Request Headers +id: 8b70371a-f613-48d2-80af-48d5be32e745 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: | + Custom HTTP/1.1 request-header log. The TA for Zeek does not produce or parse this stream. + The Zeek logger writes one JSON record per selected header to http_request_headers.log. + + Capture Authorization, HTTP2-Settings, Content-Type, Content-Disposition, Priority, X-ConsoleAnnotator, X-Connect-Authorization, and X-CSRF-Token. + + Limit each header value to 8 KiB and include uid, the connection tuple, header_name, header_value, value_bytes, logged_bytes, and truncated. + + Download the custom http-request-headers.zeek script from https://gist.github.com/nasbench/8581572459af92b7c30599f1068c791f and place it in /opt/zeek/share/zeek/site/. This script is not included with ESCU or the TA for Zeek. Add `redef LogAscii::use_json = T;` and `@load ./http-request-headers` to /opt/zeek/share/zeek/site/local.zeek, then run `sudo /opt/zeek/bin/zeekctl deploy`. The sensor must see HTTP request plaintext. + + On the Zeek forwarder, add this inputs.conf stanza (replace zeek with your index): + + [monitor:///opt/zeek/logs/current/http_request_headers.log] + disabled = 0 + index = zeek + sourcetype = zeek:http_request_header:json + + Add this props.conf stanza on the parsing tier for line handling and on the search head for JSON extraction: + + [zeek:http_request_header:json] + SHOULD_LINEMERGE = false + TRUNCATE = 32768 + KV_MODE = json + + Restart or reload the affected components and configure the zeek_http_request_headers macro to select the indexed events. + Confirm that uid, id.orig_h, id.resp_h, header_name, header_value, and truncated are extracted, and use only truncated=false events for complete values. +mitre_components: + - Network Traffic Content + - Application Log Content +source: http_request_headers.log +sourcetype: zeek:http_request_header:json # Custom sourcetype +configuration: https://gist.github.com/nasbench/8581572459af92b7c30599f1068c791f +supported_TA: [] +fields: + - ts + - uid + - id.orig_h + - id.orig_p + - id.resp_h + - id.resp_p + - method + - uri + - host + - header_name + - header_value + - value_bytes + - logged_bytes + - truncated +output_fields: + - uid + - id.orig_h + - id.resp_h + - uri + - header_name + - header_value + - truncated +example_log: |- + {"ts":1794948473.225,"uid":"Cexample123","id.orig_h":"10.0.2.1","id.resp_h":"10.0.2.13","method":"GET","uri":"/","header_name":"AUTHORIZATION","header_value":"Basic YYYY","value_bytes":10,"logged_bytes":10,"truncated":false} diff --git a/detections/application/http_base64_activity_with_jvm_errors.yml b/detections/application/http_base64_activity_with_jvm_errors.yml new file mode 100644 index 0000000000..114b197037 --- /dev/null +++ b/detections/application/http_base64_activity_with_jvm_errors.yml @@ -0,0 +1,323 @@ +name: HTTP Base64 Activity With JVM Errors +id: 26f87d5e-671f-402c-9cb7-7e57816ef22e +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +status: production +type: Anomaly +description: | + The analytic associates each Zeek request containing a malformed Base64 value or a scripted decoder trigger with a nearby Base64-related HotSpot argument exception on the same server and Java PID. + Sysmon child process, file creation, or process termination events from that PID add context and can raise confidence. +data_source: + - Zeek HTTP + - Zeek HTTP Request Headers + - Zeek HTTP POST Body + - Java HotSpot Exceptions + - Sysmon for Linux EventID 1 + - Sysmon for Linux EventID 5 + - Sysmon for Linux EventID 11 +search: | + ( + `zeek_http_request_headers` + header_name IN ( + "AUTHORIZATION", + "HTTP2-SETTINGS", + "CONTENT-TYPE", + "CONTENT-DISPOSITION", + "PRIORITY", + "X-CONSOLEANNOTATOR", + "X-CONNECT-AUTHORIZATION", + "X-CSRF-TOKEN" + ) + header_value="*=*" + truncated=false + ) + OR + ( + `zeek_http_post_body` + body="*=*" + truncated=false + ) + OR + ( + `zeek_http_uri` + uri IN ("*=*","*%3D*","*%3d*") + ) + OR + ( + `java_hotspot_exceptions` + ( + "*Input byte array has wrong*" + OR + "*IllegalArgumentException*" + OR + "*Base64$Decoder*" + OR + "*java/util/Base64*" + ) + ) + OR + ( + `sysmon_linux` + ( + (EventID=1 ParentImage="*/java") + OR + (EventID=5 Image="*/java") + OR + ( + EventID=11 + Image="*/java" + NOT TargetFilename IN ("*/_state/*","*/indices/*") + ) + ) + ) + + | rex field=_raw "^\[(?[^\]]+)\]\[(?\d+)\]\[(?[^\]]+)\]\[(?[^\]]+)\]\s*(?.*)" + + | eval jvm_pid=coalesce(jvm_pid_raw,jvm_pid), + jvm_tags=coalesce(jvm_tags_raw,jvm_tags), + jvm_message=coalesce(jvm_message_raw,jvm_message) + + + | eval event_time=_time, + is_network=if(isnotnull('id.resp_h'),1,0) + + | eval observed_target=if(is_network=1,'id.resp_h',coalesce(dest,host,dest_ip)) + + | eval request_value=case( + isnotnull(header_name),header_value, + isnotnull(body),body, + is_network=1,urldecode(uri) + ), + carrier=case( + isnotnull(header_name),header_name, + isnotnull(body),"POST body", + is_network=1,"URI" + ) + + | where is_network=0 OR len(request_value)>=65 + + | eval malformed_b64=if( + is_network=1 + AND match(request_value,"(?=request_time-3 + AND first_seen<=request_time+15) + OR + (event_kind="sysmon" + AND last_seen>=request_time-3 + AND first_seen<=request_time+30) + + | stats min(request_time) AS request_time + min(eval(if(argument_error=1,first_seen,null()))) AS exception_time + max(last_seen) AS last_seen + max(argument_error) AS argument_error + max(decoder_evidence) AS decoder_evidence + max(shell_child) AS shell_child + max(child_process) AS child_process + max(file_created) AS file_created + max(java_terminated) AS java_terminated + max(suspicious_file) AS suspicious_file + values(src) AS src + values(request_dest) AS dest_ips + values(uri) AS uri + values(method) AS method + values(carrier) AS carrier + values(request_marker) AS request_markers + values(child_images) AS child_images + values(created_files) AS created_files + BY target request_uid java_pid + + | where argument_error=1 AND decoder_evidence=1 + + | eval dest=mvindex(dest_ips,0), + exception_delay=round(exception_time-request_time,3), + confidence=case( + shell_child>0 OR suspicious_file>0,"high", + child_process>0 OR file_created>0 OR java_terminated>0,"medium", + true(),"low" + ), + asset_id=target, + firstTime=request_time, + lastTime=last_seen + + | fields - argument_error decoder_evidence shell_child child_process file_created java_terminated suspicious_file dest_ips + + | sort 0 - firstTime + + | `security_content_ctime(firstTime)` + | `security_content_ctime(lastTime)` + | `http_base64_activity_with_jvm_errors_filter` +how_to_implement: | + Configure zeek_http_uri, zeek_http_request_headers, zeek_http_post_body, and java_hotspot_exceptions for the indexes and sourcetypes in your environment. Configure sysmon_linux if you collect that optional source. + Install the TA for Zeek for standard HTTP logs. To collect the optional header and POST-body streams, install the custom scripts from https://gist.github.com/nasbench/8581572459af92b7c30599f1068c791f (request headers) and https://gist.github.com/nasbench/4cd18a938056cbfbc8a9832edb26f4c4 (POST bodies), following the corresponding data source instructions. These scripts are not included with ESCU or the TA for Zeek. Ensure uid, uri, id.orig_h, id.resp_h, header_name, header_value, body, and truncated are extracted as applicable. The sensor must see request plaintext. + + HotSpot exception diagnostics are not written to a standard file by default. Tomcat normally writes JULI logs under CATALINA_BASE/logs (and, on Unix with its startup scripts, console output to catalina.out); Spring Boot writes application logs to the console by default; and Elasticsearch application logs use /var/log/elasticsearch for Debian/RPM packages, ES_HOME/logs for tar/zip installs, or container stdout. Elasticsearch enables GC logs by default, but these are separate from the exception stream required here. + Add this JVM startup option with a writable path chosen for the deployment: + -Xlog:exceptions=debug:file=/var/log/myapp/exceptions-%p.log:utctime,pid,level,tags:filecount=8,filesize=16m + For Tomcat scripts, place it in CATALINA_OPTS via CATALINA_BASE/bin/setenv.sh or setenv.bat; for a Windows Tomcat service, configure its Java options. For Spring Boot, add it to the Java service or container launch command. For Elasticsearch, add a .options file in config/jvm.options.d or /etc/elasticsearch/jvm.options.d, according to the installation method, and preserve existing JVM logging settings. Spring Boot logging.file.name and Tomcat logging.properties control application or container logs, not HotSpot unified logging. + Forward the configured file and rotations as java:hotspot:exceptions. On the Splunk parsing tier, configure single-line event breaking and timestamps for utctime. Search-time extraction in props.conf is optional: use EXTRACT-jvm_unified (or a shared REPORT transform) for reusable jvm_pid, jvm_tags, and jvm_message fields, or leave those fields unconfigured and let this search parse the decorated _raw line with `rex`. The search coalesces raw and pre-extracted values, including jvm_tags, before correlating the Java PID. The Java HotSpot Exceptions data source gives the input and optional extraction pattern. Verify the raw format, host identity, file permissions, and retention before enabling the search. Exception logging can be high volume, and an exception event is not guaranteed during exploitation. + + Optionally ingest Sysmon for Linux EventID 1, 5, and 11 with ParentImage, ParentProcessId, Image, ProcessId, and TargetFilename. Process creation joins on ParentProcessId; file creation and process termination join on ProcessId. + + Configure Enterprise Security Assets and Identities so the Zeek destination IP and the JVM or Sysmon hostname resolve to the same dest_asset_id through `get_asset(dest)`. Synchronize the sensor and server clocks. The search permits JVM events from 3 seconds before to 15 seconds after each request marker, and optional Sysmon events up to 30 seconds after it. Tune these windows to measured collection delays. +known_false_positives: | + One JVM can handle concurrent requests, so an exception may fall within 15 seconds of more than one malformed request. HotSpot logs do not carry the Zeek uid, and this search establishes time proximity rather than causation. + Ordinary Java child processes and file writes can coincide with the request. Review the URI, Zeek uid, exception delay, Java PID, child image, and created path. + Clock skew, PID reuse, and incorrect host/IP mapping can misassociate events. Sysmon evidence is supporting context and is not required for a result. +references: + - https://calif.io/java4shell/ + - https://openjdk.org/groups/vulnerability/advisories/2026-11-17 +intermediate_findings: + entities: + - field: dest + type: system + score: 20 + message: 'HTTP Base64 marker in request [$request_uid$] from [$src$] to [$dest$] aligned with a Base64-related argument exception in Java PID [$java_pid$] at a [$exception_delay$]-second offset. Confidence: [$confidence$]' +threat_objects: [] +analytic_story: + - Java4Shell - CVE-2026-114938 +asset_type: Endpoint +cve: + - CVE-2026-114938 +mitre_attack_id: + - T1190 +product: + - Splunk Enterprise + - Splunk Enterprise Security + - Splunk Cloud +category: application +security_domain: endpoint +tests: + - name: True Positive Test + attack_data: + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_bro_http.log + sourcetype: bro:http:json + source: http.log + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_zeek_body.log + sourcetype: zeek:http_post_body:json + source: http_post_body.log + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_exception.log + sourcetype: java:hotspot:exceptions + source: exceptions.log + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_sysmon.log + sourcetype: sysmon:linux + source: Syslog:Linux-Sysmon/Operational + description: MANUAL TEST - This detection uses the A&I get_asset macro from Enterprise Security to resolve dest. + test_type: experimental diff --git a/detections/application/java_base64_decoder_argument_exceptions.yml b/detections/application/java_base64_decoder_argument_exceptions.yml new file mode 100644 index 0000000000..12c56fde5f --- /dev/null +++ b/detections/application/java_base64_decoder_argument_exceptions.yml @@ -0,0 +1,107 @@ +name: Java Base64 Decoder Argument Exceptions +id: 7b56e29e-c7c9-4b22-8fce-f22bf0f1db67 +version: 1 +creation_date: '2026-11-18' +modification_date: '2026-11-18' +author: Onur Mustafa Erdogan, Nasreddine Bencherchali, Splunk +status: production +type: Anomaly +description: | + The analytic finds Java Base64 decoder references and argument exceptions on the same JVM process within one minute. JIT messages add context when present. These logs indicate decoder activity and errors, but do not prove that a native overwrite or code execution occurred. +data_source: + - Java HotSpot Exceptions + - Java HotSpot JIT +search: | + (`java_hotspot_jit` OR `java_hotspot_exceptions`) + ( + "*Input byte array has wrong*" + OR "*IllegalArgumentException*" + OR "*Base64$Decoder*" + OR "*java/util/Base64*" + OR "*OSR invalidation of lower level*" + ) + + | rex field=_raw "^\[(?[^\]]+)\]\[(?\d+)\]\[(?[^\]]+)\]\[(?[^\]]+)\]\s*(?.*)" + + | eval process_id=coalesce(jvm_pid_raw,jvm_pid,process_id), + jvm_message=coalesce(jvm_message_raw,jvm_message), + event_time=_time + + | where isnotnull(process_id) + + | rex mode=sed field=jvm_message "s/0x[0-9A-Fa-f]{8,16}/0xXXXXXXXXXXXXXXXX/g" + | rex mode=sed field=jvm_message "s/\s+bci\s+\d+\s+/ bci XXX /g" + | rex mode=sed field=jvm_message "s/^\d+\s+/XXXX /g" + + | eval has_argument=if(match(jvm_message,"(?i)Input byte array has wrong|IllegalArgumentException"),1,0), + has_decoder=if(match(jvm_message,"Base64[$]Decoder|java/util/Base64|Input byte array has wrong 4-byte ending unit"),1,0) + + | eval reason=case( + match(jvm_message,"(?i)Input byte array has wrong"),"Tailing byte exception", + match(jvm_message,"(?i)OSR invalidation of lower level"),"JIT activity", + has_decoder==1,"Base64 decoder reference", + has_argument==1,"Argument exception" + ) + + | bin _time span=1m + + | stats count + min(event_time) AS firstTime + max(event_time) AS lastTime + max(has_argument) AS has_argument + max(has_decoder) AS has_decoder + values(sourcetype) AS sourcetype + dc(sourcetype) AS dc_sourcetype + values(source) AS source + dc(source) AS dc_source + values(reason) AS reason + values(jvm_message) AS jvm_message + BY _time host process_id + + | where has_argument==1 AND has_decoder==1 + + | rename host AS dest + + | fields - has_argument has_decoder + + | `security_content_ctime(firstTime)` + | `security_content_ctime(lastTime)` + | `java_base64_decoder_argument_exceptions_filter` +how_to_implement: | + Configure java_hotspot_exceptions and java_hotspot_jit for the indexes and sourcetypes in your environment. A stock HotSpot JVM does not create exception or JIT log files; its default unified logging sends warning and error messages to stdout. Tomcat JULI logs under CATALINA_BASE/logs, Spring Boot's default console logs, and Elasticsearch application logs are separate from these JVM diagnostics. + Add `-Xlog:exceptions=debug:file=/var/log/myapp/exceptions-%p.log:utctime,pid,level,tags:filecount=8,filesize=16m` to the Java startup options. To collect JIT context, also add `-Xlog:jit+compilation=debug:file=/var/log/myapp/jit-%p.log:utctime,pid,level,tags:filecount=8,filesize=16m`. Use a writable directory and monitor both files and rotations. Tomcat scripts accept CATALINA_OPTS in setenv.sh or setenv.bat; a Windows Tomcat service uses its Java options; Spring Boot uses the Java service or container launch command; and Elasticsearch uses jvm.options.d under its config directory or /etc/elasticsearch/jvm.options.d for Debian/RPM packages. The Java HotSpot Exceptions and Java HotSpot JIT data source descriptions give the Splunk input and field-extraction settings. + Search-time extraction in props.conf is optional. Configure EXTRACT-jvm_unified or a shared REPORT transform if you want reusable jvm_pid and jvm_message fields; otherwise this search parses the decorated _raw lines with `rex` and coalesces the raw fields with any pre-extracted values. Keep the same host value for all logs from one JVM and verify the raw format or extracted fields with representative events. The JIT source adds context; an exception source alone can satisfy both required terms when it contains the exact Base64 decoder message `Input byte array has wrong 4-byte ending unit`. Decoder references on separate continuation lines may lack the PID decorator and cannot be joined reliably with single-line event breaking. Neither log proves that the intrinsic overwrite occurred. +known_false_positives: | + Applications that routinely decode malformed Base64 can produce these events. The decoder and exception may come from separate requests within the same minute; review the surrounding application and network events. +references: + - https://calif.io/java4shell/ +intermediate_findings: + entities: + - field: dest + type: system + score: 20 + message: Java Base64 decoder argument exceptions observed on $dest$ in PID $process_id$. +threat_objects: [] +analytic_story: + - Java4Shell - CVE-2026-114938 +asset_type: Endpoint +cve: + - CVE-2026-114938 +mitre_attack_id: + - T1190 +product: + - Splunk Enterprise + - Splunk Enterprise Security + - Splunk Cloud +category: application +security_domain: endpoint +tests: + - name: True Positive Test + attack_data: + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_exception.log + sourcetype: java:hotspot:exceptions + source: exceptions.log + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_jit.log + sourcetype: java:hotspot:jit + source: jit.log + test_type: unit diff --git a/detections/application/java_base64_exception_with_process_or_file_activity.yml b/detections/application/java_base64_exception_with_process_or_file_activity.yml new file mode 100644 index 0000000000..b38c5ef52d --- /dev/null +++ b/detections/application/java_base64_exception_with_process_or_file_activity.yml @@ -0,0 +1,135 @@ +name: Java Base64 Exception With Process or File Activity +id: 33e08fbd-82b6-4344-a379-1f188562d4ac +version: 1 +creation_date: '2026-11-18' +modification_date: '2026-11-18' +author: Onur Mustafa Erdogan, Nasreddine Bencherchali, Splunk +status: production +type: Anomaly +description: | + The analytic finds Base64-related Java argument exceptions near a process spawned by Java or a file created by Java on the same host and JVM PID. +data_source: + - Java HotSpot Exceptions + - Sysmon for Linux EventID 1 + - Sysmon for Linux EventID 11 +search: | + ( + `java_hotspot_exceptions` + ( + "*Input byte array has wrong*" + OR + "*IllegalArgumentException*" + OR + "*Base64$Decoder*" + OR + "*java/util/Base64*" + ) + ) + OR + ( + `sysmon_linux` + ( + (EventID=1 ParentImage="*/java") + OR + ( + EventID=11 + Image="*/java" + NOT TargetFilename IN ("*/_state/*","*/indices/*") + ) + ) + ) + | rex field=_raw "^\[(?[^\]]+)\]\[(?\d+)\]\[(?[^\]]+)\]\[(?[^\]]+)\]\s*(?.*)" + + | eval event_time=_time, + jvm_message=coalesce(jvm_message_raw,jvm_message), + observed_host=coalesce(host,Computer,dest), + process_id=case( + isnotnull(jvm_pid_raw),tostring(jvm_pid_raw), + isnotnull(jvm_pid),tostring(jvm_pid), + EventID==1,tostring(ParentProcessId), + EventID==11,tostring(ProcessId) + ) + | where isnotnull(observed_host) AND isnotnull(process_id) + + | rex mode=sed field=jvm_message "s/0x[0-9A-Fa-f]{8,16}/0xXXXXXXXXXXXXXXXX/g" + | rex mode=sed field=jvm_message "s/\s+bci\s+\d+\s+/ bci XXX /g" + | rex mode=sed field=jvm_message "s/^\d+\s+/XXXX /g" + + | eval has_argument=if(match(jvm_message,"(?i)Input byte array has wrong|IllegalArgumentException"),1,0), + has_decoder=if(match(jvm_message,"Base64[$]Decoder|java/util/Base64|Input byte array has wrong 4-byte ending unit"),1,0), + has_activity=if(EventID==1 OR EventID==11,1,0) + + | eval activity=case( + EventID==1,"Java spawned a process", + EventID==11,"Java created a file" + ), + process_name=if(EventID==1,Image,null()), + process=if(EventID==1,CommandLine,null()), + file_path=if(EventID==11,TargetFilename,null()), + file_name=if(EventID==11,mvindex(split(TargetFilename,"/"),-1),null()) + + | bin _time span=1m + + | stats count + min(event_time) AS firstTime + max(event_time) AS lastTime + max(has_argument) AS has_argument + max(has_decoder) AS has_decoder + max(has_activity) AS has_activity + values(sourcetype) AS sourcetype + dc(sourcetype) AS dc_sourcetype + values(activity) AS activity + values(jvm_message) AS jvm_message + values(process_name) AS process_name + values(process) AS process + values(file_name) AS file_name + values(file_path) AS file_path + BY _time observed_host process_id + + | where has_argument==1 AND has_decoder==1 AND has_activity==1 + + | rename observed_host AS dest + + | eval reason="Java Base64 exception observed with ".mvjoin(activity," and ") + + | fields - has_argument has_decoder has_activity activity + + | `security_content_ctime(firstTime)` + | `security_content_ctime(lastTime)` + | `java_base64_exception_with_process_or_file_activity_filter` +how_to_implement: | + Configure java_hotspot_exceptions and sysmon_linux for the indexes and sourcetypes in your environment. HotSpot exception diagnostics have no default file location. Tomcat's CATALINA_BASE/logs, Spring Boot's default console output, and Elasticsearch's application log directory do not supply this JVM stream. Add `-Xlog:exceptions=debug:file=/var/log/myapp/exceptions-%p.log:utctime,pid,level,tags:filecount=8,filesize=16m` to the Java startup options, using a writable path. Set it through Tomcat CATALINA_OPTS or Windows service Java options, the Spring Boot Java service/container command, or Elasticsearch jvm.options.d. Forward the chosen file and rotations as java:hotspot:exceptions. Configure single-line event breaking and utctime parsing on the Splunk parsing tier. Search-time extraction in props.conf is optional: use EXTRACT-jvm_unified or a shared REPORT transform for reusable jvm_pid and jvm_message fields, or let this search extract them from decorated _raw lines with `rex`. The search coalesces raw and pre-extracted values before joining to Sysmon. The Java HotSpot Exceptions data source provides the optional extraction pattern. + The exact HotSpot message `Input byte array has wrong 4-byte ending unit` is treated as Base64 decoder evidence because decoder references on separate continuation lines may lack the PID decorator and cannot be joined reliably with single-line event breaking. Install Sysmon for Linux and ingest EventID 1 and 11 with ParentImage, ParentProcessId, Image, ProcessId, TargetFilename, and CommandLine. Normalize the host field so JVM and Sysmon events from the same machine use the same value. The search joins a process creation on ParentProcessId and a file creation on ProcessId; both must identify the Java PID. Verify that exception log volume and rotation are acceptable before deploying this correlation. +known_false_positives: | + Java applications may decode malformed inputs while independently creating files or child processes. One-minute bins can also miss events at a minute boundary or associate unrelated activity on a busy JVM. Review the process command line, file path, and nearby request logs. +references: + - https://calif.io/java4shell/ +intermediate_findings: + entities: + - field: dest + type: system + score: 30 + message: Java Base64 argument exceptions and process or file activity observed on $dest$ in PID $process_id$. +analytic_story: + - Java4Shell - CVE-2026-114938 +asset_type: Endpoint +cve: + - CVE-2026-114938 +mitre_attack_id: + - T1190 +product: + - Splunk Enterprise + - Splunk Enterprise Security + - Splunk Cloud +category: application +security_domain: endpoint +tests: + - name: True Positive Test + attack_data: + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_exception.log + sourcetype: java:hotspot:exceptions + source: exceptions.log + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_sysmon.log + sourcetype: sysmon:linux + source: Syslog:Linux-Sysmon/Operational + test_type: unit diff --git a/detections/endpoint/linux_compiled_c_source_to_tmp.yml b/detections/endpoint/linux_compiled_c_source_to_tmp.yml index 18943a993c..391f1e85c2 100644 --- a/detections/endpoint/linux_compiled_c_source_to_tmp.yml +++ b/detections/endpoint/linux_compiled_c_source_to_tmp.yml @@ -1,8 +1,8 @@ name: Linux Compiled C Source To Tmp id: e873b93d-7f7e-4376-99f0-edb7856ce199 -version: 1 +version: 2 creation_date: '2026-10-19' -modification_date: '2026-10-19' +modification_date: '2026-11-17' author: Raven Tait, Splunk status: production type: Anomaly @@ -14,7 +14,7 @@ description: |- data_source: - Sysmon for Linux EventID 1 search: |- - `sysmon` + `sysmon_linux` EventID=1 process_name IN ( "*clang*", diff --git a/detections/endpoint/linux_suspicious_namespace_creation.yml b/detections/endpoint/linux_suspicious_namespace_creation.yml index 86c010c4fe..e6728ce9f5 100644 --- a/detections/endpoint/linux_suspicious_namespace_creation.yml +++ b/detections/endpoint/linux_suspicious_namespace_creation.yml @@ -1,8 +1,8 @@ name: Linux Suspicious Namespace Creation id: 039dbee4-39d8-4ad0-a43a-df4db3a41990 -version: 1 +version: 2 creation_date: '2026-05-12' -modification_date: '2026-05-12' +modification_date: '2026-11-18' author: Raven Tait, Splunk status: production type: TTP @@ -25,7 +25,7 @@ search: | | table host, unshare_time, comm, syscall, unshare_pid, unshare_ppid, trigger_uid, trigger_auid, trigger_exe, ns_flags | join type=inner host unshare_ppid [ - search `sysmon` EventID=1 User=root + search `sysmon_linux` EventID=1 User=root | where match(Image, "/(su|sudo|pkexec|passwd|chsh|newgrp|doas|run0|sg|dash|sh|bash|zsh|fish|ksh|csh|tcsh|ash|mksh|busybox|tmux|screen|node|python[^/]*|perl[^/]*|ruby[^/]*|php[^/]*|lua[^/]*)$") | eval root_spawn_time=_time, root_pid=ProcessId, root_exe=Image, root_cmdline=CommandLine, root_parent=ParentProcessId diff --git a/detections/network/zeek_http_malformed_base64_padding.yml b/detections/network/zeek_http_malformed_base64_padding.yml new file mode 100644 index 0000000000..74ce82ccda --- /dev/null +++ b/detections/network/zeek_http_malformed_base64_padding.yml @@ -0,0 +1,94 @@ +name: Zeek HTTP Malformed Base64 Padding +id: 012f4434-be93-44cd-9677-4d3d1be41d59 +version: 1 +creation_date: '2026-11-18' +modification_date: '2026-11-18' +author: Onur Mustafa Erdogan, Nasreddine Bencherchali, Splunk +status: production +type: Anomaly +description: | + The analytic hunts for an HTTP header, POST body, or URI containing at least one 64-character Base64 block followed by a short padded fragment. This malformed shape can reach a vulnerable Java Base64 decoder, but its presence in traffic alone does not prove that the server decoded it. +data_source: + - Zeek HTTP + - Zeek HTTP Request Headers + - Zeek HTTP POST Body +search: | + ( + `zeek_http_request_headers` + header_value="*=*" + truncated=false + ) + OR + ( + `zeek_http_post_body` + body="*=*" + truncated=false + ) + OR + ( + `zeek_http_uri` + uri IN ("*=*","*%3D*","*%3d*") + ) + | eval request_value=case( + isnotnull(header_value),header_value, + isnotnull(body),body, + isnotnull(uri),urldecode(uri) + ), + carrier=case( + isnotnull(header_value),header_name, + isnotnull(body),"POST body", + isnotnull(uri),"URI" + ), + dest_port=coalesce(dest_port,'id.resp_p'), + dest=coalesce(dest,dest_ip,'id.resp_h'), + src=coalesce(src,src_ip,'id.orig_h') + + | rex field=request_value "(?(?:(?:[A-Za-z0-9+/]{64})+(?:[A-Za-z0-9+/]{0,2}=|[A-Za-z0-9+/]?==)|(?:[A-Za-z0-9_-]{64})+(?:[A-Za-z0-9_-]{0,2}=|[A-Za-z0-9_-]?==)))(?![A-Za-z0-9+/_=-])" + + | where isnotnull(malformed_base64) + + | stats count + min(_time) AS firstTime + max(_time) AS lastTime + values(carrier) AS carrier + values(uid) AS zeek_uid + values(uri) AS uri + values(body) AS body + BY src dest dest_port method malformed_base64 + | `security_content_ctime(firstTime)` + | `security_content_ctime(lastTime)` + | `zeek_http_malformed_base64_padding_filter` +how_to_implement: | + Install the TA for Zeek to parse standard HTTP logs. Configure zeek_http_uri for their index and sourcetype, and confirm that uri, method, uid, id.orig_h, id.resp_h, and id.resp_p are extracted. + To collect the optional request-header and POST-body streams, install the custom scripts from https://gist.github.com/nasbench/8581572459af92b7c30599f1068c791f (request headers) and https://gist.github.com/nasbench/4cd18a938056cbfbc8a9832edb26f4c4 (POST bodies), following the corresponding data source instructions. These scripts are not included with ESCU or the TA for Zeek. Configure zeek_http_request_headers and zeek_http_post_body to select their JSON events, and confirm that header_name, header_value, body, and truncated are extracted as applicable. + The sensor must see HTTP request plaintext. Capture enough of each header or body for the Base64 value to be complete, and use only truncated=false custom events. +known_false_positives: | + Legitimate but malformed Base64, binary structured fields, or unrelated encoded values can match. Confirm that the application actually decodes the field before treating this as an exploit attempt. Scripts that construct the trigger after receiving the request may not put a literal Base64 value on the wire. +references: + - https://calif.io/java4shell/ +intermediate_findings: + entities: + - field: dest + type: system + score: 20 + message: Malformed Base64 padding was observed in [$carrier$] on HTTP traffic from $src$ to [$dest$:$dest_port$] [$method$; $count$ events]. +analytic_story: + - Java4Shell - CVE-2026-114938 +asset_type: Network +cve: + - CVE-2026-114938 +mitre_attack_id: + - T1190 +product: + - Splunk Enterprise + - Splunk Enterprise Security + - Splunk Cloud +category: network +security_domain: network +tests: + - name: True Positive Test + attack_data: + - data: https://media.githubusercontent.com/media/splunk/attack_data/master/datasets/emerging_threats/java4shell/java4shell_zeek_body.log + sourcetype: zeek:http_post_body:json + source: http_post_body.log + test_type: unit diff --git a/macros/java_hotspot_exceptions.yml b/macros/java_hotspot_exceptions.yml new file mode 100644 index 0000000000..669a97551b --- /dev/null +++ b/macros/java_hotspot_exceptions.yml @@ -0,0 +1,8 @@ +name: java_hotspot_exceptions +id: f63f6cef-3a3c-47d3-b7d8-21f4a93fd5fe +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk configuration for Java JVM HotSpot unified exception. Update the sourcetype to match your environment. +definition: sourcetype="java:hotspot:exceptions" diff --git a/macros/java_hotspot_fatal.yml b/macros/java_hotspot_fatal.yml new file mode 100644 index 0000000000..917a1f900a --- /dev/null +++ b/macros/java_hotspot_fatal.yml @@ -0,0 +1,8 @@ +name: java_hotspot_fatal +id: e7b20438-7304-4a18-9511-ed53d987bb7f +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk configuration for Java JVM fatal error logs. Update the sourcetype to match your environment. +definition: sourcetype="java:hotspot:fatal" diff --git a/macros/java_hotspot_jit.yml b/macros/java_hotspot_jit.yml new file mode 100644 index 0000000000..b25d61b018 --- /dev/null +++ b/macros/java_hotspot_jit.yml @@ -0,0 +1,8 @@ +name: java_hotspot_jit +id: 13d446a8-70ff-40d9-851c-450a5731ab8b +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk configuration for Java JVM hotspot JIT. Update the sourcetype to match your environment. +definition: sourcetype="java:hotspot:jit" diff --git a/macros/sysmon.yml b/macros/sysmon.yml index be1a2932ac..9bdf5c29be 100644 --- a/macros/sysmon.yml +++ b/macros/sysmon.yml @@ -1,8 +1,8 @@ name: sysmon id: 5d3fac2b-637d-412d-9308-a13f37c9ea97 -version: 1 +version: 2 creation_date: '2019-12-17' -modification_date: '2026-05-13' +modification_date: '2026-11-17' author: Splunk Threat Research Team description: customer specific splunk configurations(eg- index, source, sourcetype). Replace the macro definition with configurations for your Splunk Environment. -definition: (source=WinEventLog:Microsoft-Windows-Sysmon/Operational OR source=XmlWinEventLog:Microsoft-Windows-Sysmon/Operational OR source=Syslog:Linux-Sysmon/Operational) +definition: (source=WinEventLog:Microsoft-Windows-Sysmon/Operational OR source=XmlWinEventLog:Microsoft-Windows-Sysmon/Operational) diff --git a/macros/sysmon_linux.yml b/macros/sysmon_linux.yml new file mode 100644 index 0000000000..cf82720d0c --- /dev/null +++ b/macros/sysmon_linux.yml @@ -0,0 +1,8 @@ +name: sysmon_linux +id: 49c1ca77-3424-4699-aa09-d77c2087866e +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk source configuration for Sysmon for Linux events. +definition: (sourcetype="sysmon:linux" OR source=Syslog:Linux-Sysmon/Operational) diff --git a/macros/zeek_http_post_body.yml b/macros/zeek_http_post_body.yml new file mode 100644 index 0000000000..6928ca4805 --- /dev/null +++ b/macros/zeek_http_post_body.yml @@ -0,0 +1,8 @@ +name: zeek_http_post_body +id: 2b3d4ea4-87c5-47bc-be91-f6d22b04b720 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk configuration for Zeek HTTP post body logs. Update the sourcetype to match your environment. +definition: sourcetype="zeek:http_post_body:json" diff --git a/macros/zeek_http_request_headers.yml b/macros/zeek_http_request_headers.yml new file mode 100644 index 0000000000..94548ca86b --- /dev/null +++ b/macros/zeek_http_request_headers.yml @@ -0,0 +1,8 @@ +name: zeek_http_request_headers +id: e4afffd9-b84d-46aa-ae9a-6bdee7d915da +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk configuration for Zeek HTTP request header logs. Update the sourcetype to match your environment. +definition: sourcetype="zeek:http_request_header:json" diff --git a/macros/zeek_http_uri.yml b/macros/zeek_http_uri.yml new file mode 100644 index 0000000000..87512242ba --- /dev/null +++ b/macros/zeek_http_uri.yml @@ -0,0 +1,8 @@ +name: zeek_http_uri +id: f8b15806-1f9b-4366-8839-7a91093fed65 +version: 2 +creation_date: '2026-11-17' +modification_date: '2026-11-17' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +description: Customer specific Splunk configuration for Zeek HTTP URI logs. Update the sourcetype to match your environment. +definition: sourcetype="bro:http:json" diff --git a/stories/java4shell___cve_2026_114938.yml b/stories/java4shell___cve_2026_114938.yml new file mode 100644 index 0000000000..1b1265e814 --- /dev/null +++ b/stories/java4shell___cve_2026_114938.yml @@ -0,0 +1,24 @@ +name: Java4Shell - CVE-2026-114938 +id: c47bc409-53a8-4dae-ab1a-312c82a0a078 +version: 1 +creation_date: '2026-11-17' +modification_date: '2026-11-18' +author: Nasreddine Bencherchali, Onur Mustafa Erdogan, Splunk +status: production +description: | + CVE-2026-114938 is an out-of-bounds write in the x86-64 HotSpot Base64 decoder intrinsic. This story brings together HTTP requests carrying a malformed Base64 value or a scripted decoder trigger, Java decoder and exception telemetry, and optional process or file activity from the same JVM. These signals help investigate possible exploitation but do not independently establish that the native overwrite or code execution occurred. +narrative: | + The affected path requires an x86-64 HotSpot JVM that compiles the Base64 decoder with the intrinsic enabled on a CPU supporting AVX-512 VBMI/BW and BMI2. After at least one complete 64-byte Base64 block, a malformed final fragment of one to three bytes with trailing padding can make the intrinsic compute a negative output count. The resulting masked store writes beyond the Java result array. A later IllegalArgumentException may occur after the overwrite, but an application does not need to log that exception. + A remote request is relevant only when attacker-controlled data reaches a Java Base64 decoder. The entry point varies by application: an HTTP header, URI, request body, or server-side script can supply the value. A script may construct the malformed bytes inside the JVM, leaving no literal Base64 token in the network request. TLS encryption and incomplete HTTP capture can also hide the request content from Zeek. + The network analytic identifies a candidate malformed value without proving that the server decoded it. The JVM analytic groups Base64 decoder references and argument exceptions by host and Java PID; JIT messages can show compilation activity but do not identify the overwrite. The combined analytic associates a candidate HTTP request with nearby JVM evidence on the destination host and uses the Java PID to add Sysmon process or file events when available. Shared hosts and busy JVMs require review of the request, process, and timing before attribution. + Code execution can remain entirely inside the Java process. A child shell, newly created file, fatal JVM error, or garbage collection anomaly is not a required result. Conversely, a Java child process or file created near a decoder exception can be unrelated. Investigate those events as supporting behavior, not as a prerequisite for this vulnerability. +references: + - https://calif.io/java4shell/ + - https://openjdk.org/groups/vulnerability/advisories/2026-11-17 +category: + - Adversary Tactics +product: + - Splunk Enterprise + - Splunk Enterprise Security + - Splunk Cloud +usecase: Application Security