detect/analyzer: disable automatic json output

EngineAnalysisRules2 was in a strange location where it did not respect
the --engine-analysis flag. It has been moved to the same call location
as EngineAnalysisRules.

detect/analyzer: add notes (and warnings)

http: implement min size stream logic

Update HTTP parser to set the min inspect depth per transaction. This
allows for signatures to have their fast_pattern in the HTTP body,
while still being able to inspect the raw stream reliably with it.

The inspect depth is set per transaction as it:
- depends on the per personality config for min inspect size
- is set to the size of the actual body if it is smaller

After the initial inspection is done, it is set to 0 which disables
the feature for the rest of the transaction.

This removes the rescanning flush logic in commit
7e004f52c60c5e4d7cd8f5ed09491291d18f42d2 and provides an alternative
fix for bug #2522. The old approach caused too much rescanning of
HTTP body data leading to a performance degradation.

Bug #2522

stream: introduce min inspect depth logic

Some rules need to inspect both raw stream data and higher level
buffers together. When this higher level buffer is a streaming
buffer itself, the risk of mismatch exists.

This patch allows an app-layer parser to set a 'min inspect depth'.
The value is used by the stream engine to keep at least this
depth worth of data, so that the detection engine can request
all of it for inspection.

For rules that have the SIG_FLAG_FLUSH flag set, data is inspected
not from offset raw_progress, but from raw_progress minus
min_inspect_depth.

At this time this is only used for sigs that have their fast_pattern
in a HTTP body and have raw stream match as well.

defrag: break out of loop in linux profile when able to

defrag: remove fragments that have complete overlap

Instead of just marking fragments that have been completely
overlapped and won't be part of the assembled packet, remove
them from the fragment tree when detected.

defrag: use rb tree to store fragments

unittests: fix format-truncation warning

stream/segments: change packing to reduce size

Change the way fields are ordered to reduce TcpSegment structure
with 8 bytes.

stream/segments: keep track of tree right edge

Use this in places where we need to use the outer right
edge of our sequence space.

This way we can avoid walking the tree to find this, which
is a potentially expensive operation.

streaming/sbb: convert RB_MIN to 'head'

streaming: keep track of tree 'head'

streaming: use rbtree for stream blocks

Switch StreamBufferBlocks implementation to use RBTREE instead of
a list. This makes inserts/removals and lookups a lot cheaper if
the number of data gaps is large.

Use separate compare functions for inserts and regular lookups.
Inserts care about the offset, while lookups care about the blocks
right edge as well.

stream/sack: optimize SACK size handling

Optimize by keeping count during insert/remove instead of
walking the tree per check.

stream/sack: turn SACK record list into rbtree

Convert to rbtree from linked list. These ranges, of which there can
be multiple per packet, are fully controlled by an attacked. The
attacker could craft a stream of packet in such a way that the list
would grow very large. This would make inserts/removals very expensive,
as well as the list walk that is done and size calculation and pruning
operations.

The RBTREE makes inserts/removals much cheaper, at a slight overhead
for 'normal' operations and slightly higher per record memory use.

stream/segments: speed up inserts

Don't try to do a 'fast path' by checking RB_MAX. RB_MAX walks the
tree which means it can be quite expensive. This cost would be paid
for virtually every data segment. The actual insert that follows would
walk the tree again.

Instead, simply insert it. There is a slight cost of the unnecessary
overlap check, but this is much less than the tree walk in a full
tree.

stream/segments: remove RB_MIN/RB_MAX

stream/segments: optimize overlap tree operations

Now that with the RBTREE we have a properly sorted Segment tree,
where with exact SEQ matches the tree is sorted by payload_len
smallest to largest, we can avoid walking backwards when checking
for overlaps. Our direct RB_PREV either overlaps or not and that
is a reliable verdict for the rest of the tree.

stream/segments: turn linked list into rbtree

To improve worst case performance turn the segments list into a rbtree.
This greatly improves inserts, lookups and removals if the number of
segments gets very large.

The tree is sorted by the segment sequence number as its primary key.
If 2 segments have the same seq, the payload_len (segment length) is
used. Then the larger segment will be places after the smaller segment.
Exact matches are not added to the tree.

tree: add scan-build assertions to suppress FPs

tree: add 2-clause BSD licensed tree.h

stream: expand GAP detection

detect/mpm: minor code cleanup

detect/file: fix minor scan-build warnings

stream/tcp: be more liberal in last_ack

Don't set even if seq is before next_seq, as this could still be
a valid packet that was sent before the state was reached.

stream/tcp: add debug statements to state dispatcher

app-layer-ssl: don't decode empty extensions

doc: add documentation for Lua function 'TlsGetVersion'

lua: add function 'TlsGetVersion'

Add another function to get TLS version, since 'TlsGetCertInfo' only
works when a TLS session contains a clear text certificate, which is
not the case in TLSv1.3 or when a session is resumed.

doc: update tls.version documentation

detect-tls-version: add support for 'raw' matching

Add support for matching a 'raw' TLS version using a hex string, e.g:

  tls.version:0x7f12;

The above example matches TLSv1.3 draft 16.

detect-tls-version: add support for TLSv1.3

detect-ssl-version: add support for TLSv1.3

lua: use 'SSLVersionToString' in TlsGetCertInfo()

tlslog: add support for TLSv1.3

output-json-tls: add support for TLSv1.3

app-layer-ssl: add function to get string from version

Add 'SSLVersionToString' to get string from version.

app-layer-ssl: add support for earlier TLSv1.3 drafts

Add support for TLSv1.3 draft 1 to draft 21.

app-layer-ssl: add support for TLSv1.3 from draft 22

Add support for draft 22 to draft 28 and for the final
version (RFC8446) of TLSv1.3.

app-layer-ssl: add support for session tickets

Add support for logging a session as 'resumed' when using a non-empty
session ticket extension in the client hello record.

app-layer-ssl: add better session id support

Verify that the session id from both the client hello record and the
server hello record matches before marking the session as 'resumed'.

app-layer-ssl: decode server hello record

Decoding server hello is needed to do a better implementation of
session resumption.

doc: README.md minor fixes

- Capitalization update
- Typo fix
- Spacing update

Signed-off-by: jason taylor <jtfas90@gmail.com>

flow/timeout: code simplification and cleanup

stream: minor code cleanup

rules: hide 'template' from --list-keywords

rules: hide internal keywords from --list-keywords

flow-manager: fix unittest initialization

app-layer-ssl: make sure that JA3 stuff is only initialized once

Avoid possible memory leaks by making sure that JA3 buffer and
string is only initialized once.

app-layer-ssl: fix memleak/coredump (Bug #2603)

af-packet: close the socket in case of early fail

log-filestore: fix file descriptor leak

In the case we exceed the number of simultaneously open
file we can reach a state were we will not close the file
after writing.

Thanks to Steve Grubb <sgrubb@redhat.com> for the analysis.

profiling/app-layer: fix TCP parsers showing UDP stats

profiling: add missing logger labels

detect: clean up sgh flags and add cocci check

stream: minor code cleanups

detect/mpm: clean up setup code

dhcp: check length of option before accessing

Prevent Rust index out of bounds panic.

Redmine issue:
https://redmine.openinfosecfoundation.org/issues/2571

dhcp: remove println!() that got committed

detect: fix file_data detect issue with alert ip

Fix mpm progress being updated by irrelevant engines. Esp in the
case of file_data engines, signature can contain multiple versions
of the same engine, registered for different 'progress' values.

This would lead to signatures being considered 'can't match' even
in cases where they clearly could still match.

Only consider those progress values that apply to the protocol in
use.

detect/parse: try to set flow direction for sigs w/o explict app proto as well

configure: added rust install notes

Signed-off-by: jason taylor <jtfas90@gmail.com>

configure: updated fedora/centos references

* updated fedora yum references to dnf
* updated/added centos/rhel references

Signed-off-by: jason taylor <jtfas90@gmail.com>

eve/http: add tx->request_port_number as http_port

Add the port specified in the hostname (if any) to the http object in
eve. The port may be different from the dest_port used by the TCP flow.

yaml: add var for DC_SERVERS (Domain Controller)

yaml: add note for dns v1 not available with rust

yaml: add note for dns.log with Rust

It is not availbale when rust is enabled.

doc: iprep supports CIDR networks

util-unittest: fix typo

detect/files: fix inspection issues with 'alert ip'

Don't track the 'skipped' engines as matches.

detect/filehash: try to open data file from rulefile dir

If the data file can't be found in the default location, which
normally is 'default-rule-path', try to see if it can be found
in the path of the rule file that references it.

This makes QA much easier.

files: only prune in own direction

Only prune files in own direction. The opposite direction may still
require inspection.

cocci: add more flag checks

detect: use BIT_* macros

Also add notes that when adding flags they should be added to the
analyzer as well.

stream: use BIT_U8 for stream flags

detect/prefilter: speed up setup

If the global detect.prefilter.default setting is not "auto", it is
wasteful to run each prefilter setup routine. This patch tracks which
of the engines have been explicitly enabled in the rules and only
runs those.

detect/prefilter: fix prefilter when setting is 'mpm'

When prefilter is not enabled globally, it is still possible to
enable it per signature. This was broken however, as the setup
code would never be called.

This commit always call the setup code and lets that sort out
which signatures (if any) to enable prefiltering for.

detect: include keyword types in detect.h

detect/analyzer: show pattern that is used by mpm

Set a new DETECT_CONTENT_MPM flag on the pattern that is selected
during setup.

detect/prefilter: fix alias for fast_pattern

If prefilter is used on a content keyword, it acts as a simple
fast_pattern statement. This was broken because the SIG_FLAG_PREFILTER
flag bypasses MPM for a sig. This commits fixes this by not setting
the flag when it should act as fast_pattern.

detect: limit flush logic to sigs that need it

Limit the early 'flush' logic to sigs that actually need to match
on both stream and http bodies.

detect/analyzer: add built-in lists

detect: don't setup PMATCH if it will be unused

Safes a bit of memory and makes it easier to debug.

detect/analyzer: add Signature::flags

detect: remove STATE_MATCH flag use at runtime

Instead, use it only at init time and use Signature::app_inspect
directly at runtime.

detect: cleanup direct SIG_FLAG_STATE_MATCH use

This flag should normally not be set manually. It will be set by the
code registering the app engines in a signature.

detect/dnp3: cleanup list and proto registration

detect: remove SIG_FLAG_STATE_MATCH flag check

It could not fail as before it the flag was already checked as a bail
out condition.

detect: minor formatting fixups

flow: reduce structure size by removing gap

detect/http: flush bodies when inspecting stream

The HTTP bodies (http_client_body and http_server_body/file_data) use
settings to control how much data we have before doing first inspection:

    request-body-minimal-inspect-size
    response-body-minimal-inspect-size

These settings default to 32k as quite some existing rules need this.

At the same time, the 'raw stream' inspection uses its own limits. By
default it inspects the data in blocks of about 2.5k. This could lead
to a situation where rules would not match.

For example, with 2 rules like this:

    content:"abc"; content:"data="; http_client_body; depth:5; sid:1;
    content:"xyz"; sid:2;

Sid 1 would only be inspected when the POST body reached the 32k limit
or when it was complete. Observed case shows the POST body to be 18k.
Sid 2 is inspected as soon as the 2.5k limit is reached, and then again
for each 2.5k increment. This moves the raw stream tracker forward.

So by the time sid 1 is inspected, some 18/19k into the stream, the
raw stream tracker is actually already moved forward for approximately
17.5k, this leads to the stream match of sid 1 possibly not matching.
Since the body match is at the start of the buffer, it makes sense
that the body and stream are inspected together.

The body inspection uses a tracker 'body_inspected', that keeps track
of how far into the body both MPM and per signature inspection has
moved.

This patch updates the logic in 2 ways:

1. it triggers earlier HTTP body inspection, which is matched to the
   stream inspection. When the detection engine finds it has stream
   data available for inspection, it passes the new 'STREAM_FLUSH'
   flag to the HTTP body inspection code. Which will then do an
   early inspection, even if still before the min inspect size.

2. to still somewhat adhere to the min inspect size, the body
   tracker is not updated until the min inspect size is reached.
   This will lead to some re-evaluation of the same body data.

If raw stream reassembly is disabled, this 'STREAM_FLUSH' flag is
never set, and the old behavior is used.

Bug #2522.

stream: improve TCP CLOSED handling

Trigger app layer reassembly in both directions as soon as we've set
the TCP state to closed.

In IDS mode, if a toserver packet would close the state, the app layer
would not get updated until the next toclient packet. However, in
detection, the raw stream inspection would already use all available
stream data in detection and move the 'raw stream progress' tracker
forward. When in later (a) packet(s) the app layer was updated and
inspection ran on the app layer, the stream progress was already
moved too far forward. This would lead to signatures that matched
on both stream and app layer to not match.

By triggering the app layer reassembly as soon as the TCP state is
set to closed, the inspection as both the stream and app layer data
available at the same time so these rules can match.

Bug: #2570
Bug: #2554

detect: add debug statements to stream inspect

proto/detect: add debug info

flow: flag packets as established for async

If a stream is async we see only on side of the traffic. This would
lead to the flow engine not flagging packets as 'established' even
if the flow state was in fact established. The flow was tagged as
such by the TCP engine.

This patch considers the flow state for setting the packet flag.

Bug #2491.

rust/smb: implement stream-depth, unlimited by default

stream-tcp: fix typo in debug message

app-layer-htp: close file with TRUNCATE state

When a file in TOSERVER direction is being stored and
libhtp or stream depth limit is reached,
it will be closed by HTPCallbackRequest without setting
any flags so the file state will be set to CLOSED
instead of TRUNCATED.

app-layer-parser: split registration flags

app-layer-parser: don't overwrite stream_depth value

When an app-layer parser is enabled, it could set its
own stream_depth value calling the API AppLayerParserSetStreamDepth.

Then, the function AppLayerParserPostStreamSetup will replace
the stream_depth value already set with stream_config.reassembly_depth.

To avoid overwriting, in AppLayerParserSetStreamDepth API a flag
will be set internally to specify that a value is already set.