suricata
detect-engine-content-inspection.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2023 Open Information Security Foundation
2  *
3  * You can copy, redistribute or modify this Program under the terms of
4  * the GNU General Public License version 2 as published by the Free
5  * Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * version 2 along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15  * 02110-1301, USA.
16  */
17 
18 /**
19  * \file
20  *
21  * \author Anoop Saldanha <anoopsaldanha@gmail.com>
22  *
23  * Performs content inspection on any buffer supplied.
24  */
25 
26 #include "suricata-common.h"
27 #include "suricata.h"
28 #include "decode.h"
29 
30 #include "detect.h"
31 #include "detect-engine.h"
32 #include "detect-parse.h"
33 
34 #include "rust.h"
35 
36 #include "detect-asn1.h"
37 #include "detect-content.h"
38 #include "detect-pcre.h"
39 #include "detect-isdataat.h"
40 #include "detect-bytetest.h"
41 #include "detect-bytemath.h"
42 #include "detect-bytejump.h"
43 #include "detect-byte-extract.h"
44 #include "detect-entropy.h"
45 #include "detect-replace.h"
47 #include "detect-uricontent.h"
48 #include "detect-urilen.h"
49 #include "detect-engine-uint.h"
50 #include "detect-bsize.h"
51 #include "detect-lua.h"
52 #include "detect-base64-decode.h"
53 #include "detect-base64-data.h"
54 #include "detect-dataset.h"
55 #include "detect-datarep.h"
56 
57 #include "util-spm.h"
58 #include "util-debug.h"
59 #include "util-print.h"
60 #include "util-validate.h"
61 
62 #include "util-unittest-helper.h"
63 #include "util-profiling.h"
64 
65 #include "util-lua.h"
66 
67 #ifdef UNITTESTS
68 thread_local uint32_t ut_inspection_recursion_counter = 0;
69 #endif
70 
72  struct {
73  uint32_t count;
74  const uint32_t limit;
76 };
77 
78 /**
79  * \brief Run the actual payload match functions
80  *
81  * All keywords are evaluated against the buffer with buffer_len.
82  *
83  * For accounting the last match in relative matching the
84  * det_ctx->buffer_offset int is used.
85  *
86  * \param det_ctx Detection engine thread context
87  * \param s Signature to inspect
88  * \param sm SigMatch to inspect
89  * \param p Packet. Can be NULL.
90  * \param f Flow (for pcre flowvar storage)
91  * \param buffer Ptr to the buffer to inspect
92  * \param buffer_len Length of the payload
93  * \param stream_start_offset Indicates the start of the current buffer in
94  * the whole buffer stream inspected. This
95  * applies if the current buffer is inspected
96  * in chunks.
97  * \param inspection_mode Refers to the engine inspection mode we are currently
98  * inspecting. Can be payload, stream, one of the http
99  * buffer inspection modes or dce inspection mode.
100  * \param flags DETECT_CI_FLAG_*
101  *
102  * \retval -1 no match and give up (discontinue matching)
103  * \retval 0 no match
104  * \retval 1 match
105  */
106 static int DetectEngineContentInspectionInternal(DetectEngineThreadCtx *det_ctx,
107  struct DetectEngineContentInspectionCtx *ctx, const Signature *s, const SigMatchData *smd,
108  Packet *p, Flow *f, const uint8_t *buffer, const uint32_t buffer_len,
109  const uint64_t stream_start_offset, const uint8_t flags,
110  const enum DetectContentInspectionType inspection_mode)
111 {
112  SCEnter();
114 
115  ctx->recursion.count++;
116  if (unlikely(ctx->recursion.count == ctx->recursion.limit)) {
117  KEYWORD_PROFILING_END(det_ctx, smd->type, 0);
118  SCReturnInt(-1);
119  }
120 
121  // we want the ability to match on bsize: 0
122  if (smd == NULL || buffer == NULL) {
123  KEYWORD_PROFILING_END(det_ctx, smd->type, 0);
124  SCReturnInt(0);
125  }
126 
127  if (smd->type == DETECT_CONTENT) {
128  const DetectContentData *cd = (const DetectContentData *)smd->ctx;
129  SCLogDebug("inspecting content %"PRIu32" buffer_len %"PRIu32, cd->id, buffer_len);
130 
131  /* we might have already have this content matched by the mpm.
132  * (if there is any other reason why we'd want to avoid checking
133  * it here, please fill it in) */
134  //if (cd->flags & DETECT_CONTENT_NO_DOUBLE_INSPECTION_REQUIRED) {
135  // goto match;
136  //}
137 
138  /* rule parsers should take care of this */
139 #ifdef DEBUG
140  BUG_ON(cd->depth != 0 && cd->depth <= cd->offset);
141 #endif
142 
143  /* search for our pattern, checking the matches recursively.
144  * if we match we look for the next SigMatch as well */
145  uint32_t prev_offset = 0; /**< used in recursive searching */
146  uint32_t prev_buffer_offset = det_ctx->buffer_offset;
147 
148  do {
149  uint32_t depth = buffer_len;
150  uint32_t offset = 0;
151  if ((cd->flags & DETECT_CONTENT_DISTANCE) ||
152  (cd->flags & DETECT_CONTENT_WITHIN)) {
153  SCLogDebug("det_ctx->buffer_offset %" PRIu32, det_ctx->buffer_offset);
154  offset = prev_buffer_offset;
155 
156  int distance = cd->distance;
157  if (cd->flags & DETECT_CONTENT_DISTANCE) {
159  // This cast is wrong if a 64-bit value was extracted
160  distance = (uint32_t)det_ctx->byte_values[cd->distance].value;
161  }
162  if (distance < 0 && (uint32_t)(abs(distance)) > offset)
163  offset = 0;
164  else
165  offset += distance;
166 
167  SCLogDebug("cd->distance %"PRIi32", offset %"PRIu32", depth %"PRIu32,
168  distance, offset, depth);
169  }
170 
171  if (cd->flags & DETECT_CONTENT_WITHIN) {
172  if (cd->flags & DETECT_CONTENT_WITHIN_VAR) {
173  // This cast is wrong if a 64-bit value was extracted for within
174  if ((int32_t)depth >
175  (int32_t)(prev_buffer_offset +
176  det_ctx->byte_values[cd->within].value + distance)) {
177  depth = prev_buffer_offset +
178  (uint32_t)det_ctx->byte_values[cd->within].value + distance;
179  }
180  } else {
181  if ((int32_t)depth > (int32_t)(prev_buffer_offset + cd->within + distance)) {
182  depth = prev_buffer_offset + cd->within + distance;
183  }
184 
185  SCLogDebug("cd->within %"PRIi32", det_ctx->buffer_offset %"PRIu32", depth %"PRIu32,
186  cd->within, prev_buffer_offset, depth);
187  }
188 
189  if (stream_start_offset != 0 && prev_buffer_offset == 0) {
190  if (depth <= stream_start_offset) {
191  goto no_match;
192  } else if (depth >= (stream_start_offset + buffer_len)) {
193  ;
194  } else {
195  depth = depth - (uint32_t)stream_start_offset;
196  }
197  }
198  }
199 
200  if (cd->flags & DETECT_CONTENT_DEPTH_VAR) {
201  if ((det_ctx->byte_values[cd->depth].value + prev_buffer_offset) < depth) {
202  // ok to cast as we checked the byte value fits in a u32
203  depth = prev_buffer_offset +
204  (uint32_t)det_ctx->byte_values[cd->depth].value;
205  }
206  } else {
207  if (cd->depth != 0) {
208  if ((cd->depth + prev_buffer_offset) < depth) {
209  depth = prev_buffer_offset + cd->depth;
210  }
211 
212  SCLogDebug("cd->depth %"PRIu32", depth %"PRIu32, cd->depth, depth);
213  }
214  }
215 
216  if (cd->flags & DETECT_CONTENT_OFFSET_VAR) {
217  if (det_ctx->byte_values[cd->offset].value > offset) {
218  // This cast is wrong if a 64-bit value was extracted
219  offset = (uint32_t)det_ctx->byte_values[cd->offset].value;
220  }
221  } else {
222  if (cd->offset > offset) {
223  offset = cd->offset;
224  SCLogDebug("setting offset %"PRIu32, offset);
225  }
226  }
227  } else { /* implied no relative matches */
228  /* set depth */
229  if (cd->flags & DETECT_CONTENT_DEPTH_VAR) {
230  // This cast is wrong if a 64-bit value was extracted
231  depth = (uint32_t)det_ctx->byte_values[cd->depth].value;
232  } else {
233  if (cd->depth != 0) {
234  depth = cd->depth;
235  }
236  }
237 
238  if (stream_start_offset != 0 && cd->flags & DETECT_CONTENT_DEPTH) {
239  if (depth <= stream_start_offset) {
240  goto no_match;
241  } else if (depth >= (stream_start_offset + buffer_len)) {
242  ;
243  } else {
244  depth = (uint32_t)(depth - stream_start_offset);
245  }
246  }
247 
248  /* set offset */
249  if (cd->flags & DETECT_CONTENT_OFFSET_VAR) {
250  // This cast is wrong if a 64-bit value was extracted
251  offset = (uint32_t)det_ctx->byte_values[cd->offset].value;
252  } else {
253  offset = cd->offset;
254  }
255  prev_buffer_offset = 0;
256  }
257 
258  /* If the value came from a variable, make sure to adjust the depth so it's relative
259  * to the offset value.
260  */
262  depth += offset;
263  }
264 
265  /* update offset with prev_offset if we're searching for
266  * matches after the first occurrence. */
267  SCLogDebug("offset %"PRIu32", prev_offset %"PRIu32, offset, prev_offset);
268  if (prev_offset != 0)
269  offset = prev_offset;
270 
271  SCLogDebug("offset %"PRIu32", depth %"PRIu32, offset, depth);
272 
273  if (depth > buffer_len)
274  depth = buffer_len;
275 
276  /* if offset is bigger than depth we can never match on a pattern.
277  * We can however, "match" on a negated pattern. */
278  if (offset > depth || depth == 0) {
279  if (cd->flags & DETECT_CONTENT_NEGATED) {
280  goto match;
281  } else {
282  goto no_match;
283  }
284  }
285 
286  const uint8_t *sbuffer = buffer + offset;
287  uint32_t sbuffer_len = depth - offset;
288  SCLogDebug("sbuffer_len %" PRIu32 " depth: %" PRIu32 ", buffer_len: %" PRIu32,
289  sbuffer_len, depth, buffer_len);
290 #ifdef DEBUG
291  BUG_ON(sbuffer_len > buffer_len);
292 #endif
293  const uint8_t *found;
294  if (cd->flags & DETECT_CONTENT_ENDS_WITH && depth < buffer_len) {
295  SCLogDebug("depth < buffer_len while DETECT_CONTENT_ENDS_WITH is set. Can't possibly match.");
296  found = NULL;
297  } else if (cd->content_len > sbuffer_len) {
298  found = NULL;
299  } else {
300  /* do the actual search */
301  found = SpmScan(cd->spm_ctx, det_ctx->spm_thread_ctx, sbuffer,
302  sbuffer_len);
303  }
304 
305  /* next we evaluate the result in combination with the
306  * negation flag. */
307  SCLogDebug("found %p cd negated %s", found, cd->flags & DETECT_CONTENT_NEGATED ? "true" : "false");
308 
309  if (found == NULL) {
310  if (!(cd->flags & DETECT_CONTENT_NEGATED)) {
311  if ((cd->flags & (DETECT_CONTENT_DISTANCE | DETECT_CONTENT_WITHIN)) == 0) {
312  /* independent match from previous matches, so failure is fatal */
313  goto no_match_discontinue;
314  }
315 
316  goto no_match;
317  } else {
318  goto match;
319  }
320  }
321 
322  uint32_t match_offset = (uint32_t)((found - buffer) + cd->content_len);
323  if (cd->flags & DETECT_CONTENT_NEGATED) {
324  SCLogDebug("content %" PRIu32 " matched at offset %" PRIu32
325  ", but negated so no match",
326  cd->id, match_offset);
327  /* don't bother carrying recursive matches now, for preceding
328  * relative keywords */
329 
330  /* found a match but not at the end of the buffer */
331  if (cd->flags & DETECT_CONTENT_ENDS_WITH) {
332  if (sbuffer_len != match_offset) {
333  SCLogDebug("content \"%s\" %" PRIu32 " matched at offset %" PRIu32
334  ", but not at end of buffer so match",
335  cd->content, cd->id, match_offset);
336  goto match;
337  }
338  }
339  if (DETECT_CONTENT_IS_SINGLE(cd)) {
340  goto no_match_discontinue;
341  }
342  goto no_match;
343  }
344 
345  SCLogDebug("content %" PRIu32 " matched at offset %" PRIu32 "", cd->id, match_offset);
346  det_ctx->buffer_offset = match_offset;
347 
348  if ((cd->flags & DETECT_CONTENT_ENDS_WITH) == 0 || match_offset == buffer_len) {
349  /* Match branch, add replace to the list if needed */
351  if (inspection_mode == DETECT_ENGINE_CONTENT_INSPECTION_MODE_PAYLOAD) {
352  /* we will need to replace content if match is confirmed
353  * cast to non-const as replace writes to it. */
354  det_ctx->replist =
355  DetectReplaceAddToList(det_ctx->replist, (uint8_t *)found, cd);
356  } else {
357  SCLogWarning("Can't modify payload without packet");
358  }
359  }
360 
361  /* if this is the last match we're done */
362  if (smd->is_last) {
363  goto match;
364  }
365 
366  SCLogDebug("content %" PRIu32, cd->id);
367  KEYWORD_PROFILING_END(det_ctx, smd->type, 1);
368 
369  /* see if the next buffer keywords match. If not, we will
370  * search for another occurrence of this content and see
371  * if the others match then until we run out of matches */
372  int r = DetectEngineContentInspectionInternal(det_ctx, ctx, s, smd + 1, p, f,
373  buffer, buffer_len, stream_start_offset, flags, inspection_mode);
374  if (r == 1) {
375  SCReturnInt(1);
376  } else if (r == -1) {
377  SCLogDebug("'next sm' said to discontinue this right now");
378  SCReturnInt(-1);
379  }
380  SCLogDebug("no match for 'next sm'");
381 
382  /* no match and no reason to look for another instance */
383  if ((cd->flags & DETECT_CONTENT_WITHIN_NEXT) == 0) {
384  SCLogDebug("'next sm' does not depend on me, so we can give up");
385  SCReturnInt(-1);
386  }
387 
388  SCLogDebug("'next sm' depends on me %p, lets see what we can do (flags %u)", cd,
389  cd->flags);
390  }
391  /* set the previous match offset to the start of this match + 1 */
392  prev_offset = (match_offset - (cd->content_len - 1));
393  SCLogDebug("trying to see if there is another match after prev_offset %" PRIu32,
394  prev_offset);
395  } while(1);
396 
397  } else if (smd->type == DETECT_ABSENT) {
398  const DetectAbsentData *id = (DetectAbsentData *)smd->ctx;
399  if (!id->or_else) {
400  // we match only on absent buffer
401  goto no_match;
402  }
403  goto match;
404  } else if (smd->type == DETECT_ISDATAAT) {
405  SCLogDebug("inspecting isdataat");
406 
407  const DetectIsdataatData *id = (DetectIsdataatData *)smd->ctx;
408  uint32_t dataat = id->dataat;
409  if (id->flags & ISDATAAT_OFFSET_VAR) {
410  uint64_t be_value = det_ctx->byte_values[dataat].value;
411  if (be_value >= 100000000) {
412  if ((id->flags & ISDATAAT_NEGATED) == 0) {
413  SCLogDebug("extracted value %"PRIu64" very big: no match", be_value);
414  goto no_match;
415  }
416  SCLogDebug("extracted value way %"PRIu64" very big: match", be_value);
417  goto match;
418  }
419  dataat = (uint32_t)be_value;
420  SCLogDebug("isdataat: using value %u from byte_extract local_id %u", dataat, id->dataat);
421  }
422 
423  if (id->flags & ISDATAAT_RELATIVE) {
424  if (det_ctx->buffer_offset + dataat > buffer_len) {
425  SCLogDebug("det_ctx->buffer_offset + dataat %"PRIu32" > %"PRIu32, det_ctx->buffer_offset + dataat, buffer_len);
426  if (id->flags & ISDATAAT_NEGATED)
427  goto match;
428  if ((id->flags & ISDATAAT_OFFSET_VAR) == 0) {
429  goto no_match_discontinue;
430  }
431  goto no_match;
432  } else {
433  SCLogDebug("relative isdataat match");
434  if (id->flags & ISDATAAT_NEGATED) {
435  goto no_match;
436  }
437  goto match;
438  }
439  } else {
440  if (dataat < buffer_len) {
441  SCLogDebug("absolute isdataat match");
442  if (id->flags & ISDATAAT_NEGATED) {
443  if ((id->flags & ISDATAAT_OFFSET_VAR) == 0) {
444  goto no_match_discontinue;
445  }
446  goto no_match;
447  }
448  goto match;
449  } else {
450  SCLogDebug("absolute isdataat mismatch, id->isdataat %"PRIu32", buffer_len %"PRIu32"", dataat, buffer_len);
451  if (id->flags & ISDATAAT_NEGATED)
452  goto match;
453  if ((id->flags & ISDATAAT_OFFSET_VAR) == 0) {
454  goto no_match_discontinue;
455  }
456  goto no_match;
457  }
458  }
459 
460  } else if (smd->type == DETECT_PCRE) {
461  SCLogDebug("inspecting pcre");
462  const DetectPcreData *pe = (const DetectPcreData *)smd->ctx;
463  uint32_t prev_buffer_offset = det_ctx->buffer_offset;
464  uint32_t prev_offset = 0;
465 
466  det_ctx->pcre_match_start_offset = 0;
467  do {
468  int r = DetectPcrePayloadMatch(det_ctx, s, smd, p, f, buffer, buffer_len);
469  if (r == 0) {
470  goto no_match;
471  }
472  if (!(pe->flags & DETECT_PCRE_RELATIVE_NEXT)) {
473  SCLogDebug("no relative match coming up, so this is a match");
474  goto match;
475  }
476  KEYWORD_PROFILING_END(det_ctx, smd->type, 1);
477 
478  /* save it, in case we need to do a pcre match once again */
479  prev_offset = det_ctx->pcre_match_start_offset;
480 
481  /* see if the next payload keywords match. If not, we will
482  * search for another occurrence of this pcre and see
483  * if the others match, until we run out of matches */
484  r = DetectEngineContentInspectionInternal(det_ctx, ctx, s, smd + 1, p, f, buffer,
485  buffer_len, stream_start_offset, flags, inspection_mode);
486  if (r == 1) {
487  SCReturnInt(1);
488  } else if (r == -1) {
489  SCReturnInt(-1);
490  }
491 
492  if (prev_offset == 0) {
493  // This happens for negated PCRE
494  // We do not search for another occurrence of this pcre
495  SCReturnInt(0);
496  }
497  det_ctx->buffer_offset = prev_buffer_offset;
498  det_ctx->pcre_match_start_offset = prev_offset;
499  } while (1);
500 
501  } else if (smd->type == DETECT_ENTROPY) {
502  if (!DetectEntropyDoMatch(det_ctx, s, smd->ctx, f, buffer, buffer_len)) {
503  goto no_match;
504  }
505  goto match;
506  } else if (smd->type == DETECT_BYTETEST) {
507  const DetectBytetestData *btd = (const DetectBytetestData *)smd->ctx;
508  uint16_t btflags = btd->flags;
509  int32_t offset = btd->offset;
510  uint64_t value = btd->value;
511  int32_t nbytes = btd->nbytes;
512  if (btflags & DETECT_BYTETEST_OFFSET_VAR) {
513  // This cast is wrong if a 64-bit value was extracted
514  offset = (int32_t)det_ctx->byte_values[offset].value;
515  }
516  if (btflags & DETECT_BYTETEST_VALUE_VAR) {
517  value = det_ctx->byte_values[value].value;
518  }
519  if (btflags & DETECT_BYTETEST_NBYTES_VAR) {
520  // This cast is wrong if a 64-bit value was extracted
521  nbytes = (int32_t)det_ctx->byte_values[nbytes].value;
522  }
523 
524  /* if we have dce enabled we will have to use the endianness
525  * specified by the dce header */
526  if (btflags & DETECT_BYTETEST_DCE) {
527  /* enable the endianness flag temporarily. once we are done
528  * processing we reset the flags to the original value*/
529  btflags |= ((flags & DETECT_CI_FLAGS_DCE_LE) ?
531  }
532 
533  if (DetectBytetestDoMatch(det_ctx, s, smd->ctx, buffer, buffer_len, btflags, offset, nbytes,
534  value) != 1) {
535  goto no_match;
536  }
537 
538  goto match;
539 
540  } else if (smd->type == DETECT_BYTEJUMP) {
541  const DetectBytejumpData *bjd = (const DetectBytejumpData *)smd->ctx;
542  uint16_t bjflags = bjd->flags;
543  int32_t offset = bjd->offset;
544  int32_t nbytes;
545 
546  if (bjflags & DETECT_BYTEJUMP_OFFSET_VAR) {
547  // This cast is wrong if a 64-bit value was extracted
548  offset = (int32_t)det_ctx->byte_values[offset].value;
549  SCLogDebug("[BJ] using offset value %d", offset);
550  }
551 
552  if (bjflags & DETECT_BYTEJUMP_NBYTES_VAR) {
553  // This cast is wrong if a 64-bit value was extracted
554  nbytes = (int32_t)det_ctx->byte_values[bjd->nbytes].value;
555  SCLogDebug("[BJ] using nbytes value %d [index %d]", nbytes, bjd->nbytes);
556  } else {
557  nbytes = bjd->nbytes;
558  SCLogDebug("[BJ] using nbytes value %d [index n/a]", nbytes);
559  }
560 
561  /* if we have dce enabled we will have to use the endianness
562  * specified by the dce header */
563  if (bjflags & DETECT_BYTEJUMP_DCE) {
564  /* enable the endianness flag temporarily. once we are done
565  * processing we reset the flags to the original value*/
566  bjflags |= ((flags & DETECT_CI_FLAGS_DCE_LE) ?
568  }
569 
571  det_ctx, s, smd->ctx, buffer, buffer_len, bjflags, nbytes, offset)) {
572  goto no_match;
573  }
574 
575  goto match;
576 
577  } else if (smd->type == DETECT_BYTE_EXTRACT) {
578 
579  const SCDetectByteExtractData *bed = (const SCDetectByteExtractData *)smd->ctx;
580  uint8_t endian = bed->endian;
581 
582  /* if we have dce enabled we will have to use the endianness
583  * specified by the dce header */
584  if ((bed->flags & DETECT_BYTE_EXTRACT_FLAG_ENDIAN) && endian == EndianDCE &&
585  flags & (DETECT_CI_FLAGS_DCE_LE | DETECT_CI_FLAGS_DCE_BE)) {
586 
587  /* enable the endianness flag temporarily. once we are done
588  * processing we reset the flags to the original value*/
589  endian |= ((flags & DETECT_CI_FLAGS_DCE_LE) ? LittleEndian : BigEndian);
590  }
591 
592  if (DetectByteExtractDoMatch(det_ctx, smd, s, buffer, buffer_len,
593  &det_ctx->byte_values[bed->local_id].value, endian) != 1) {
594  goto no_match;
595  }
596 
597  det_ctx->byte_values[bed->local_id].set = 1;
598  det_ctx->byte_values[bed->local_id].writer = s;
599  if (bed->local_id > det_ctx->byte_values_max)
600  det_ctx->byte_values_max = bed->local_id;
601  SCLogDebug("[BE] Fetched value for index %d: %" PRIu64, bed->local_id,
602  det_ctx->byte_values[bed->local_id].value);
603  goto match;
604 
605  } else if (smd->type == DETECT_BYTEMATH) {
606 
607  const DetectByteMathData *bmd = (const DetectByteMathData *)smd->ctx;
608  uint8_t endian = bmd->endian;
609 
610  /* if we have dce enabled we will have to use the endianness
611  * specified by the dce header */
612  if ((bmd->flags & DETECT_BYTEMATH_FLAG_ENDIAN) && endian == (int)EndianDCE &&
613  flags & (DETECT_CI_FLAGS_DCE_LE | DETECT_CI_FLAGS_DCE_BE)) {
614  /* enable the endianness flag temporarily. once we are done
615  * processing we reset the flags to the original value*/
616  endian = (uint8_t)((flags & DETECT_CI_FLAGS_DCE_LE) ? LittleEndian : BigEndian);
617  }
618  uint64_t rvalue;
619  if (bmd->flags & DETECT_BYTEMATH_FLAG_RVALUE_VAR) {
620  rvalue = det_ctx->byte_values[bmd->rvalue].value;
621  } else {
622  rvalue = bmd->rvalue;
623  }
624 
625  uint8_t nbytes;
626  if (bmd->flags & DETECT_BYTEMATH_FLAG_NBYTES_VAR) {
627  nbytes = (uint8_t)det_ctx->byte_values[bmd->nbytes].value;
628  } else {
629  nbytes = bmd->nbytes;
630  }
631 
632  if (DetectByteMathDoMatch(det_ctx, bmd, s, buffer, buffer_len, nbytes, rvalue,
633  &det_ctx->byte_values[bmd->local_id].value, endian) != 1) {
634  goto no_match;
635  }
636 
637  det_ctx->byte_values[bmd->local_id].set = 1;
638  det_ctx->byte_values[bmd->local_id].writer = s;
639  if (bmd->local_id > det_ctx->byte_values_max)
640  det_ctx->byte_values_max = bmd->local_id;
641  SCLogDebug("[BM] Fetched value for index %d: %" PRIu64, bmd->local_id,
642  det_ctx->byte_values[bmd->local_id].value);
643  goto match;
644 
645  } else if (smd->type == DETECT_BSIZE) {
646 
647  const bool eof = (flags & DETECT_CI_FLAGS_END);
648  const uint64_t data_size = buffer_len + stream_start_offset;
649  int r = DetectBsizeMatch(smd->ctx, data_size, eof);
650  if (r < 0) {
651  goto no_match_discontinue;
652  } else if (r == 0) {
653  goto no_match;
654  }
655  goto match;
656 
657  } else if (smd->type == DETECT_DATASET) {
658 
659  //PrintRawDataFp(stdout, buffer, buffer_len);
660  const DetectDatasetData *sd = (const DetectDatasetData *) smd->ctx;
661  int r = DetectDatasetBufferMatch(det_ctx, sd, buffer, buffer_len); //TODO buffer offset?
662  if (r == 1) {
663  goto match;
664  }
665  goto no_match_discontinue;
666 
667  } else if (smd->type == DETECT_DATAREP) {
668 
669  //PrintRawDataFp(stdout, buffer, buffer_len);
670  const DetectDatarepData *sd = (const DetectDatarepData *) smd->ctx;
671  int r = DetectDatarepBufferMatch(det_ctx, sd, buffer, buffer_len); //TODO buffer offset?
672  if (r == 1) {
673  goto match;
674  }
675  goto no_match_discontinue;
676 
677  } else if (smd->type == DETECT_URILEN) {
678  SCLogDebug("inspecting uri len");
679 
680  int r;
681  const DetectUrilenData *urilend = (const DetectUrilenData *)smd->ctx;
682  if (buffer_len > UINT16_MAX) {
683  r = DetectU16Match(UINT16_MAX, &urilend->du16);
684  } else {
685  r = DetectU16Match((uint16_t)buffer_len, &urilend->du16);
686  }
687 
688  if (r == 1) {
689  goto match;
690  }
691  goto no_match_discontinue;
692  } else if (smd->type == DETECT_LUA) {
693  SCLogDebug("lua starting");
694 
695  if (DetectLuaMatchBuffer(det_ctx, s, smd, buffer, buffer_len,
696  det_ctx->buffer_offset, f) != 1)
697  {
698  SCLogDebug("lua no_match");
699  goto no_match;
700  }
701  SCLogDebug("lua match");
702  goto match;
703  } else if (smd->type == DETECT_BASE64_DECODE) {
704  if (DetectBase64DecodeDoMatch(det_ctx, s, smd, buffer, buffer_len)) {
705  if (s->sm_arrays[DETECT_SM_LIST_BASE64_DATA] != NULL) {
706  if (det_ctx->base64_decoded_len) {
707  /* reset buffer offset, as we treat this like a new buffer */
708  det_ctx->buffer_offset = 0;
709  KEYWORD_PROFILING_END(det_ctx, smd->type, 1);
710  int r = DetectEngineContentInspectionInternal(det_ctx, ctx, s,
712  det_ctx->base64_decoded, det_ctx->base64_decoded_len, 0,
714  if (r == 1) {
715  /* Base64 is a terminal list. */
716  goto final_match;
717  }
718  }
719  }
720  }
721  } else if (smd->type == DETECT_ASN1) {
722  if (!DetectAsn1Match(smd, buffer, buffer_len, det_ctx->buffer_offset)) {
723  SCLogDebug("asn1 no_match");
724  goto no_match;
725  }
726  SCLogDebug("asn1 match");
727  goto match;
728  } else {
729  SCLogDebug("sm->type %u", smd->type);
730 #ifdef DEBUG
731  BUG_ON(1);
732 #endif
733  }
734 
735 no_match:
736  KEYWORD_PROFILING_END(det_ctx, smd->type, 0);
737  SCReturnInt(0);
738 
739 no_match_discontinue:
740  KEYWORD_PROFILING_END(det_ctx, smd->type, 0);
741  SCReturnInt(-1);
742 
743 match:
744  /* this sigmatch matched, inspect the next one. If it was the last,
745  * the buffer portion of the signature matched. */
746  if (!smd->is_last) {
747  KEYWORD_PROFILING_END(det_ctx, smd->type, 1);
748  int r = DetectEngineContentInspectionInternal(det_ctx, ctx, s, smd + 1, p, f, buffer,
749  buffer_len, stream_start_offset, flags, inspection_mode);
750  SCReturnInt(r);
751  }
752 final_match:
753  KEYWORD_PROFILING_END(det_ctx, smd->type, 1);
754  SCReturnInt(1);
755 }
756 
757 /** \brief wrapper around DetectEngineContentInspectionInternal to return true/false only
758  *
759  * \param smd sigmatches to evaluate
760  */
762  const Signature *s, const SigMatchData *smd, Packet *p, Flow *f, const uint8_t *buffer,
763  const uint32_t buffer_len, const uint64_t stream_start_offset, const uint8_t flags,
764  const enum DetectContentInspectionType inspection_mode)
765 {
766  struct DetectEngineContentInspectionCtx ctx = { .recursion.count = 0,
767  .recursion.limit = de_ctx->inspection_recursion_limit };
768  det_ctx->buffer_offset = 0;
769 
770  int r = DetectEngineContentInspectionInternal(det_ctx, &ctx, s, smd, p, f, buffer, buffer_len,
771  stream_start_offset, flags, inspection_mode);
772 #ifdef UNITTESTS
773  ut_inspection_recursion_counter = ctx.recursion.count;
774 #endif
775  return (r == 1);
776 }
777 
778 /** \brief wrapper around DetectEngineContentInspectionInternal to return true/false only
779  *
780  * \param smd sigmatches to evaluate
781  */
783  const Signature *s, const SigMatchData *smd, Packet *p, Flow *f, const InspectionBuffer *b,
784  const enum DetectContentInspectionType inspection_mode)
785 {
786  struct DetectEngineContentInspectionCtx ctx = { .recursion.count = 0,
787  .recursion.limit = de_ctx->inspection_recursion_limit };
788 
789  det_ctx->buffer_offset = 0;
790 
791  int r = DetectEngineContentInspectionInternal(det_ctx, &ctx, s, smd, p, f, b->inspect,
792  b->inspect_len, b->inspect_offset, b->flags, inspection_mode);
793 #ifdef UNITTESTS
794  ut_inspection_recursion_counter = ctx.recursion.count;
795 #endif
796  return (r == 1);
797 }
798 
800 {
801  // we will match on NULL buffers there is one absent
802  bool absent_data = false;
803  while (1) {
804  if (smd->type == DETECT_ABSENT) {
805  absent_data = true;
806  break;
807  }
808  if (smd->is_last) {
809  break;
810  }
811  // smd does not get reused after this loop
812  smd++;
813  }
814  return absent_data;
815 }
816 
817 #ifdef UNITTESTS
819 #endif
DetectEngineContentInspectionCtx
Definition: detect-engine-content-inspection.c:71
DetectAsn1Match
bool DetectAsn1Match(const SigMatchData *smd, const uint8_t *buffer, const uint32_t buffer_len, const uint32_t offset)
Definition: detect-asn1.c:57
DetectContentData_::offset
uint16_t offset
Definition: detect-content.h:107
DetectBytetestData_::flags
uint16_t flags
Definition: detect-bytetest.h:58
DetectDatasetData_
Definition: detect-dataset.h:30
detect-engine-uint.h
DETECT_BYTETEST_VALUE_VAR
#define DETECT_BYTETEST_VALUE_VAR
Definition: detect-bytetest.h:49
detect-content.h
DetectEngineThreadCtx_::buffer_offset
uint32_t buffer_offset
Definition: detect.h:1319
detect-engine.h
DetectEngineThreadCtx_::byte_values
ByteVarSlot * byte_values
Definition: detect.h:1332
offset
uint64_t offset
Definition: util-streaming-buffer.h:0
detect-entropy.h
DETECT_CONTENT_DISTANCE_VAR
#define DETECT_CONTENT_DISTANCE_VAR
Definition: detect-content.h:47
DetectPcrePayloadMatch
int DetectPcrePayloadMatch(DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchData *smd, Packet *p, Flow *f, const uint8_t *payload, uint32_t payload_len)
Match a regex on a single payload.
Definition: detect-pcre.c:222
DETECT_BYTEJUMP
@ DETECT_BYTEJUMP
Definition: detect-engine-register.h:92
ISDATAAT_OFFSET_VAR
#define ISDATAAT_OFFSET_VAR
Definition: detect-isdataat.h:30
DETECT_ABSENT
@ DETECT_ABSENT
Definition: detect-engine-register.h:104
unlikely
#define unlikely(expr)
Definition: util-optimize.h:35
DetectContentData_::within
int32_t within
Definition: detect-content.h:109
DetectBase64DecodeDoMatch
int DetectBase64DecodeDoMatch(DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchData *smd, const uint8_t *payload, uint32_t payload_len)
Definition: detect-base64-decode.c:66
DetectBytetestDoMatch
int DetectBytetestDoMatch(DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchCtx *ctx, const uint8_t *payload, uint32_t payload_len, uint16_t flags, int32_t offset, int32_t nbytes, uint64_t value)
Bytetest detection code.
Definition: detect-bytetest.c:155
DetectIsdataatData_::flags
uint8_t flags
Definition: detect-isdataat.h:34
DETECT_BYTEJUMP_LITTLE
#define DETECT_BYTEJUMP_LITTLE
Definition: detect-bytejump.h:35
DETECT_CONTENT
@ DETECT_CONTENT
Definition: detect-engine-register.h:78
SCLogDebug
#define SCLogDebug(...)
Definition: util-debug.h:282
detect-isdataat.h
DETECT_BYTEJUMP_NBYTES_VAR
#define DETECT_BYTEJUMP_NBYTES_VAR
Definition: detect-bytejump.h:43
SigMatchData_::is_last
bool is_last
Definition: detect.h:342
util-lua.h
DetectDatarepData_
Definition: detect-datarep.h:36
SigMatchData_::ctx
SigMatchCtx * ctx
Definition: detect.h:343
detect-bsize.h
InspectionBuffer
Definition: detect-engine-inspect-buffer.h:34
Flow_
Flow data structure.
Definition: flow.h:360
ByteVarSlot_::writer
const Signature * writer
Definition: detect.h:1289
ctx
struct Thresholds ctx
DetectEngineCtx_::inspection_recursion_limit
int inspection_recursion_limit
Definition: detect.h:1011
DetectEngineCtx_
main detection engine ctx
Definition: detect.h:966
DETECT_DATAREP
@ DETECT_DATAREP
Definition: detect-engine-register.h:96
DETECT_ENTROPY
@ DETECT_ENTROPY
Definition: detect-engine-register.h:105
DETECT_BYTETEST_DCE
#define DETECT_BYTETEST_DCE
Definition: detect-bytetest.h:47
DETECT_CONTENT_DEPTH_VAR
#define DETECT_CONTENT_DEPTH_VAR
Definition: detect-content.h:46
detect-lua.h
rust.h
DetectContentInspectionMatchOnAbsentBuffer
bool DetectContentInspectionMatchOnAbsentBuffer(const SigMatchData *smd)
tells if we should match on absent buffer, because there is an absent keyword being used
Definition: detect-engine-content-inspection.c:799
DETECT_BYTEJUMP_DCE
#define DETECT_BYTEJUMP_DCE
Definition: detect-bytejump.h:40
DetectEngineThreadCtx_::spm_thread_ctx
SpmThreadCtx * spm_thread_ctx
Definition: detect.h:1327
InspectionBuffer::flags
uint8_t flags
Definition: detect-engine-inspect-buffer.h:39
DetectContentInspectionType
DetectContentInspectionType
Definition: detect-engine-content-inspection.h:31
p
Packet * p
Definition: fuzz_dataset.c:30
Signature_::sm_arrays
SigMatchData * sm_arrays[DETECT_SM_LIST_MAX]
Definition: detect.h:730
DetectIsdataatData_
Definition: detect-isdataat.h:32
DetectContentData_
Definition: detect-content.h:93
DetectPcreData_::flags
uint16_t flags
Definition: detect-pcre.h:52
DetectBytetestData_::nbytes
uint8_t nbytes
Definition: detect-bytetest.h:54
DetectBytetestData_
Definition: detect-bytetest.h:53
DETECT_SM_LIST_BASE64_DATA
@ DETECT_SM_LIST_BASE64_DATA
Definition: detect-engine-register.h:313
SigMatchData_
Data needed for Match()
Definition: detect.h:340
detect-pcre.h
KEYWORD_PROFILING_START
#define KEYWORD_PROFILING_START
Definition: util-profiling.h:50
SigMatchData_::type
uint16_t type
Definition: detect.h:341
DetectBytejumpData_
Definition: detect-bytejump.h:47
DetectEngineContentInspectionCtx::recursion
struct DetectEngineContentInspectionCtx::@50 recursion
DETECT_ENGINE_CONTENT_INSPECTION_MODE_PAYLOAD
@ DETECT_ENGINE_CONTENT_INSPECTION_MODE_PAYLOAD
Definition: detect-engine-content-inspection.h:32
DETECT_ASN1
@ DETECT_ASN1
Definition: detect-engine-register.h:100
DetectBytejumpData_::offset
int32_t offset
Definition: detect-bytejump.h:51
util-unittest-helper.h
detect-asn1.h
KEYWORD_PROFILING_END
#define KEYWORD_PROFILING_END(ctx, type, m)
Definition: util-profiling.h:64
detect-base64-data.h
DetectByteExtractDoMatch
int DetectByteExtractDoMatch(DetectEngineThreadCtx *det_ctx, const SigMatchData *smd, const Signature *s, const uint8_t *payload, uint32_t payload_len, uint64_t *value, uint8_t endian)
Definition: detect-byte-extract.c:81
DetectReplaceAddToList
DetectReplaceList * DetectReplaceAddToList(DetectReplaceList *replist, uint8_t *found, const DetectContentData *cd)
Definition: detect-replace.c:170
decode.h
util-debug.h
DETECT_CONTENT_ENDS_WITH
#define DETECT_CONTENT_ENDS_WITH
Definition: detect-content.h:42
DETECT_CONTENT_DISTANCE
#define DETECT_CONTENT_DISTANCE
Definition: detect-content.h:30
de_ctx
DetectEngineCtx * de_ctx
Definition: fuzz_siginit.c:22
DetectEntropyDoMatch
bool DetectEntropyDoMatch(DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchCtx *ctx, Flow *flow, const uint8_t *buffer, const uint32_t buffer_len)
Definition: detect-entropy.c:86
DetectBsizeMatch
int DetectBsizeMatch(const SigMatchCtx *ctx, const uint64_t buffer_size, bool eof)
bsize match function
Definition: detect-bsize.c:121
DetectEngineThreadCtx_
Definition: detect.h:1295
DETECT_BSIZE
@ DETECT_BSIZE
Definition: detect-engine-register.h:99
DETECT_LUA
@ DETECT_LUA
Definition: detect-engine-register.h:101
DETECT_CONTENT_DEPTH
#define DETECT_CONTENT_DEPTH
Definition: detect-content.h:33
util-print.h
SCEnter
#define SCEnter(...)
Definition: util-debug.h:284
ByteVarSlot_::value
uint64_t value
Definition: detect.h:1287
detect.h
DETECT_CONTENT_IS_SINGLE
#define DETECT_CONTENT_IS_SINGLE(c)
Definition: detect-content.h:68
DETECT_CONTENT_NEGATED
#define DETECT_CONTENT_NEGATED
Definition: detect-content.h:40
InspectionBuffer::inspect_offset
uint64_t inspect_offset
Definition: detect-engine-inspect-buffer.h:36
DETECT_ENGINE_CONTENT_INSPECTION_MODE_STATE
@ DETECT_ENGINE_CONTENT_INSPECTION_MODE_STATE
Definition: detect-engine-content-inspection.h:36
SCLogWarning
#define SCLogWarning(...)
Macro used to log WARNING messages.
Definition: util-debug.h:262
DetectContentData_::id
PatIntId id
Definition: detect-content.h:105
DetectLuaMatchBuffer
int DetectLuaMatchBuffer(DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchData *smd, const uint8_t *buffer, uint32_t buffer_len, uint32_t offset, Flow *f)
Definition: detect-lua.c:230
DetectEngineContentInspection
bool DetectEngineContentInspection(DetectEngineCtx *de_ctx, DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchData *smd, Packet *p, Flow *f, const uint8_t *buffer, const uint32_t buffer_len, const uint64_t stream_start_offset, const uint8_t flags, const enum DetectContentInspectionType inspection_mode)
wrapper around DetectEngineContentInspectionInternal to return true/false only
Definition: detect-engine-content-inspection.c:761
DetectBytejumpDoMatch
bool DetectBytejumpDoMatch(DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchCtx *ctx, const uint8_t *payload, uint32_t payload_len, uint16_t flags, int32_t nbytes, int32_t offset)
Byte jump match function.
Definition: detect-bytejump.c:138
BUG_ON
#define BUG_ON(x)
Definition: suricata-common.h:322
DetectEngineThreadCtx_::base64_decoded_len
int base64_decoded_len
Definition: detect.h:1387
util-profiling.h
DETECT_BYTETEST_OFFSET_VAR
#define DETECT_BYTETEST_OFFSET_VAR
Definition: detect-bytetest.h:50
DetectContentData_::depth
uint16_t depth
Definition: detect-content.h:106
SpmScan
uint8_t * SpmScan(const SpmCtx *ctx, SpmThreadCtx *thread_ctx, const uint8_t *haystack, uint32_t haystack_len)
Definition: util-spm.c:202
Packet_
Definition: decode.h:528
ByteVarSlot_::set
uint8_t set
Definition: detect.h:1288
ISDATAAT_RELATIVE
#define ISDATAAT_RELATIVE
Definition: detect-isdataat.h:27
detect-bytejump.h
DETECT_BYTETEST_NBYTES_VAR
#define DETECT_BYTETEST_NBYTES_VAR
Definition: detect-bytetest.h:51
DETECT_CI_FLAGS_END
#define DETECT_CI_FLAGS_END
Definition: detect-engine-content-inspection.h:42
DetectContentData_::flags
uint32_t flags
Definition: detect-content.h:104
DETECT_URILEN
@ DETECT_URILEN
Definition: detect-engine-register.h:103
detect-replace.h
DETECT_PCRE
@ DETECT_PCRE
Definition: detect-engine-register.h:80
detect-engine-content-inspection.h
DETECT_CONTENT_WITHIN_VAR
#define DETECT_CONTENT_WITHIN_VAR
Definition: detect-content.h:48
DetectDatasetBufferMatch
int DetectDatasetBufferMatch(DetectEngineThreadCtx *det_ctx, const DetectDatasetData *sd, const uint8_t *data, const uint32_t data_len)
Definition: detect-dataset.c:165
DetectDatarepBufferMatch
int DetectDatarepBufferMatch(DetectEngineThreadCtx *det_ctx, const DetectDatarepData *sd, const uint8_t *data, const uint32_t data_len)
Definition: detect-datarep.c:70
DETECT_BYTETEST
@ DETECT_BYTETEST
Definition: detect-engine-register.h:91
DetectByteMathDoMatch
int DetectByteMathDoMatch(DetectEngineThreadCtx *det_ctx, const DetectByteMathData *data, const Signature *s, const uint8_t *payload, const uint32_t payload_len, uint8_t nbytes, uint64_t rvalue, uint64_t *value, uint8_t endian)
Definition: detect-bytemath.c:89
DETECT_CI_FLAGS_SINGLE
#define DETECT_CI_FLAGS_SINGLE
Definition: detect-engine-content-inspection.h:50
DetectU16Match
int DetectU16Match(const uint16_t parg, const DetectUintData_u16 *du16)
Definition: detect-engine-uint.c:105
flags
uint8_t flags
Definition: decode-gre.h:0
suricata-common.h
DetectAbsentData_
Definition: detect-isdataat.h:37
detect-byte-extract.h
DetectContentData_::distance
int32_t distance
Definition: detect-content.h:108
DetectBytejumpData_::nbytes
uint8_t nbytes
Definition: detect-bytejump.h:48
ut_inspection_recursion_counter
thread_local uint32_t ut_inspection_recursion_counter
Definition: detect-engine-content-inspection.c:68
DETECT_CONTENT_WITHIN_NEXT
#define DETECT_CONTENT_WITHIN_NEXT
Definition: detect-content.h:57
util-spm.h
DetectContentData_::content
uint8_t * content
Definition: detect-content.h:94
detect-dataset.h
DetectEngineContentInspectionCtx::limit
const uint32_t limit
Definition: detect-engine-content-inspection.c:74
util-validate.h
detect-base64-decode.h
ISDATAAT_NEGATED
#define ISDATAAT_NEGATED
Definition: detect-isdataat.h:29
DetectContentData_::spm_ctx
SpmCtx * spm_ctx
Definition: detect-content.h:111
InspectionBuffer::inspect_len
uint32_t inspect_len
Definition: detect-engine-inspect-buffer.h:37
DetectEngineThreadCtx_::pcre_match_start_offset
uint32_t pcre_match_start_offset
Definition: detect.h:1323
InspectionBuffer::inspect
const uint8_t * inspect
Definition: detect-engine-inspect-buffer.h:35
DetectEngineThreadCtx_::byte_values_max
int32_t byte_values_max
Definition: detect.h:1409
detect-datarep.h
DETECT_BYTE_EXTRACT
@ DETECT_BYTE_EXTRACT
Definition: detect-engine-register.h:94
detect-parse.h
Signature_
Signature container.
Definition: detect.h:663
DETECT_ISDATAAT
@ DETECT_ISDATAAT
Definition: detect-engine-register.h:102
DetectBytetestData_::offset
int32_t offset
Definition: detect-bytetest.h:60
DetectIsdataatData_::dataat
uint16_t dataat
Definition: detect-isdataat.h:33
DetectEngineThreadCtx_::base64_decoded
uint8_t * base64_decoded
Definition: detect.h:1386
DETECT_PCRE_RELATIVE_NEXT
#define DETECT_PCRE_RELATIVE_NEXT
Definition: detect-pcre.h:34
detect-urilen.h
suricata.h
DetectPcreData_
Definition: detect-pcre.h:48
DetectContentData_::content_len
uint16_t content_len
Definition: detect-content.h:95
DETECT_BYTEMATH
@ DETECT_BYTEMATH
Definition: detect-engine-register.h:93
DETECT_BASE64_DECODE
@ DETECT_BASE64_DECODE
Definition: detect-engine-register.h:97
detect-uricontent.h
DetectEngineContentInspectionBuffer
bool DetectEngineContentInspectionBuffer(DetectEngineCtx *de_ctx, DetectEngineThreadCtx *det_ctx, const Signature *s, const SigMatchData *smd, Packet *p, Flow *f, const InspectionBuffer *b, const enum DetectContentInspectionType inspection_mode)
wrapper around DetectEngineContentInspectionInternal to return true/false only
Definition: detect-engine-content-inspection.c:782
DetectEngineThreadCtx_::replist
DetectReplaceList * replist
Definition: detect.h:1423
DetectEngineContentInspectionCtx::count
uint32_t count
Definition: detect-engine-content-inspection.c:73
DETECT_CONTENT_REPLACE
#define DETECT_CONTENT_REPLACE
Definition: detect-content.h:51
DetectAbsentData_::or_else
bool or_else
Definition: detect-isdataat.h:39
detect-engine-content-inspection.c
SCReturnInt
#define SCReturnInt(x)
Definition: util-debug.h:288
DETECT_BYTETEST_LITTLE
#define DETECT_BYTETEST_LITTLE
Definition: detect-bytetest.h:43
DETECT_DATASET
@ DETECT_DATASET
Definition: detect-engine-register.h:95
DetectBytetestData_::value
uint64_t value
Definition: detect-bytetest.h:62
DETECT_CONTENT_WITHIN
#define DETECT_CONTENT_WITHIN
Definition: detect-content.h:31
DETECT_BYTEJUMP_OFFSET_VAR
#define DETECT_BYTEJUMP_OFFSET_VAR
Definition: detect-bytejump.h:44
DetectBytejumpData_::flags
uint16_t flags
Definition: detect-bytejump.h:50
detect-bytemath.h
DETECT_CONTENT_OFFSET_VAR
#define DETECT_CONTENT_OFFSET_VAR
Definition: detect-content.h:45
detect-bytetest.h
f
Flow f
Definition: fuzz_dataset.c:32