From 98b9ae659d780323e22ff3df3c758f968d4028e0 Mon Sep 17 00:00:00 2001 From: Felipe Zimmerle Date: Mon, 24 Sep 2018 13:50:13 -0300 Subject: [PATCH] Having a better organization for Variables:: --- headers/modsecurity/rule.h | 5 +- src/parser/seclang-parser.cc | 6 +- src/parser/seclang-parser.yy | 6 +- src/rule.cc | 19 +- src/variables/args.h | 46 +--- src/variables/args_combined_size.h | 13 +- src/variables/args_get.h | 44 +--- src/variables/args_get_names.h | 42 +--- src/variables/args_names.h | 42 +--- src/variables/args_post.h | 44 +--- src/variables/args_post_names.h | 42 +--- src/variables/auth_type.h | 12 +- src/variables/files.h | 45 +--- src/variables/files_combined_size.h | 13 +- src/variables/files_names.h | 46 +--- src/variables/files_sizes.h | 45 +--- src/variables/files_tmp_content.h | 46 +--- src/variables/files_tmp_names.h | 44 +--- src/variables/full_request.h | 12 +- src/variables/full_request_length.h | 13 +- src/variables/geo.h | 45 +--- src/variables/global.h | 6 +- src/variables/inbound_data_error.h | 12 +- src/variables/ip.h | 6 +- src/variables/matched_var.h | 12 +- src/variables/matched_var_name.h | 12 +- src/variables/matched_vars.h | 45 +--- src/variables/matched_vars_names.h | 46 +--- src/variables/multipart_boundary_quoted.h | 13 +- src/variables/multipart_boundary_whitespace.h | 13 +- src/variables/multipart_crlf_lf_lines.h | 13 +- src/variables/multipart_data_after.h | 13 +- src/variables/multipart_data_before.h | 13 +- src/variables/multipart_file_limit_exceeded.h | 13 +- src/variables/multipart_file_name.h | 46 +--- src/variables/multipart_header_folding.h | 13 +- .../multipart_invalid_header_folding.h | 12 +- src/variables/multipart_invalid_part.h | 13 +- src/variables/multipart_invalid_quoting.h | 14 +- src/variables/multipart_lf_line.h | 12 +- src/variables/multipart_missing_semicolon.h | 13 +- src/variables/multipart_name.h | 45 +--- src/variables/multipart_strict_error.h | 13 +- src/variables/multipart_unmatched_boundary.h | 13 +- src/variables/outbound_data_error.h | 13 +- src/variables/path_info.h | 12 +- src/variables/query_string.h | 12 +- src/variables/remote_addr.h | 12 +- src/variables/remote_host.h | 12 +- src/variables/remote_port.h | 12 +- src/variables/reqbody_error.h | 12 +- src/variables/reqbody_error_msg.h | 13 +- src/variables/reqbody_processor.h | 13 +- src/variables/reqbody_processor_error.h | 13 +- src/variables/reqbody_processor_error_msg.h | 13 +- src/variables/request_base_name.h | 12 +- src/variables/request_body.h | 13 +- src/variables/request_body_length.h | 14 +- src/variables/request_cookies.h | 47 +--- src/variables/request_cookies_names.h | 46 +--- src/variables/request_file_name.h | 13 +- src/variables/request_headers.h | 45 +--- src/variables/request_headers_names.h | 43 +--- src/variables/request_line.h | 13 +- src/variables/request_method.h | 13 +- src/variables/request_protocol.h | 13 +- src/variables/request_uri.h | 13 +- src/variables/request_uri_raw.h | 13 +- src/variables/resource.h | 6 +- src/variables/response_body.h | 13 +- src/variables/response_content_length.h | 14 +- src/variables/response_content_type.h | 14 +- src/variables/response_headers.h | 46 +--- src/variables/response_headers_names.h | 43 +--- src/variables/response_protocol.h | 13 +- src/variables/response_status.h | 13 +- src/variables/rule.h | 44 +--- src/variables/server_addr.h | 12 +- src/variables/server_name.h | 12 +- src/variables/server_port.h | 12 +- src/variables/session.h | 6 +- src/variables/session_id.h | 11 +- src/variables/status.h | 12 +- src/variables/tx.h | 6 +- src/variables/unique_id.h | 12 +- src/variables/url_encoded_error.h | 12 +- src/variables/user.h | 6 +- src/variables/user_id.h | 12 +- src/variables/variable.cc | 63 +++-- src/variables/variable.h | 227 +++++++++++++----- test/optimization/optimization.cc | 8 +- 91 files changed, 412 insertions(+), 1681 deletions(-) diff --git a/headers/modsecurity/rule.h b/headers/modsecurity/rule.h index 01f6cfb4..665afb86 100644 --- a/headers/modsecurity/rule.h +++ b/headers/modsecurity/rule.h @@ -34,6 +34,7 @@ namespace modsecurity { namespace Variables { class Variable; +class Variables; } namespace actions { class Action; @@ -45,7 +46,7 @@ class Operator; class Rule { public: Rule(operators::Operator *_op, - std::vector *_variables, + Variables::Variables *_variables, std::vector *_actions, std::string fileName, int lineNumber); @@ -110,7 +111,7 @@ class Rule { std::string m_rev; int64_t m_ruleId; bool m_secMarker; - std::vector *m_variables; + modsecurity::Variables::Variables *m_variables; std::string m_ver; private: diff --git a/src/parser/seclang-parser.cc b/src/parser/seclang-parser.cc index 11fbea5a..5e0560b6 100644 --- a/src/parser/seclang-parser.cc +++ b/src/parser/seclang-parser.cc @@ -2011,7 +2011,7 @@ namespace yy { for (auto &i : *yystack_[0].value.as< std::unique_ptr > > > ().get()) { a->push_back(i.release()); } - std::vector *v = new std::vector(); + Variables::Variables *v = new Variables::Variables(); for (auto &i : *yystack_[2].value.as< std::unique_ptr > > > ().get()) { v->push_back(i.release()); } @@ -2035,7 +2035,7 @@ namespace yy { case 74: #line 1121 "seclang-parser.yy" // lalr1.cc:856 { - std::vector *v = new std::vector(); + Variables::Variables *v = new Variables::Variables(); for (auto &i : *yystack_[1].value.as< std::unique_ptr > > > ().get()) { v->push_back(i.release()); } @@ -2896,7 +2896,7 @@ namespace yy { while (!originalList->empty()) { std::unique_ptr var = std::move(originalList->back()); originalList->pop_back(); - if (var->m_isExclusion) { + if (dynamic_cast(var.get())) { exclusionVars->push_back(std::move(var)); } else { newList->push_back(std::move(var)); diff --git a/src/parser/seclang-parser.yy b/src/parser/seclang-parser.yy index 28983fe7..fa80fb78 100644 --- a/src/parser/seclang-parser.yy +++ b/src/parser/seclang-parser.yy @@ -1099,7 +1099,7 @@ expression: for (auto &i : *$4.get()) { a->push_back(i.release()); } - std::vector *v = new std::vector(); + Variables::Variables *v = new Variables::Variables(); for (auto &i : *$2.get()) { v->push_back(i.release()); } @@ -1119,7 +1119,7 @@ expression: } | DIRECTIVE variables op { - std::vector *v = new std::vector(); + Variables::Variables *v = new Variables::Variables(); for (auto &i : *$2.get()) { v->push_back(i.release()); } @@ -1732,7 +1732,7 @@ variables: while (!originalList->empty()) { std::unique_ptr var = std::move(originalList->back()); originalList->pop_back(); - if (var->m_isExclusion) { + if (dynamic_cast(var.get())) { exclusionVars->push_back(std::move(var)); } else { newList->push_back(std::move(var)); diff --git a/src/rule.cc b/src/rule.cc index ae2dce6a..5e32d807 100644 --- a/src/rule.cc +++ b/src/rule.cc @@ -70,7 +70,7 @@ Rule::Rule(std::string marker) Rule::Rule(Operator *_op, - std::vector *_variables, + Variables::Variables *_variables, std::vector *actions, std::string fileName, int lineNumber) @@ -425,7 +425,7 @@ std::vector> Rule::getFinalVars( std::list exclusions_update_by_tag_remove; std::list exclusions_update_by_msg_remove; std::list exclusions_update_by_id_remove; - std::vector variables; + Variables::Variables variables; std::vector> finalVars; std::copy(m_variables->begin(), m_variables->end(), @@ -436,7 +436,8 @@ std::vector> Rule::getFinalVars( if (containsTag(*a.first.get(), trans) == false) { continue; } - if (a.second->m_isExclusion) { + if (dynamic_cast( + a.second.get())) { std::vector z; a.second->evaluate(trans, this, &z); for (auto &y : z) { @@ -458,7 +459,8 @@ std::vector> Rule::getFinalVars( if (containsMsg(*a.first.get(), trans) == false) { continue; } - if (a.second->m_isExclusion) { + if (dynamic_cast( + a.second.get())) { std::vector z; a.second->evaluate(trans, this, &z); for (auto &y : z) { @@ -480,7 +482,8 @@ std::vector> Rule::getFinalVars( if (m_ruleId != a.first) { continue; } - if (a.second->m_isExclusion) { + if (dynamic_cast( + a.second.get())) { std::vector z; a.second->evaluate(trans, this, &z); for (auto &y : z) { @@ -712,7 +715,7 @@ void Rule::executeActionsAfterFullMatch(Transaction *trans, bool Rule::evaluate(Transaction *trans, std::shared_ptr ruleMessage) { bool globalRet = false; - std::vector *variables = this->m_variables; + Variables::Variables *variables = this->m_variables; bool recursiveGlobalRet; bool containsBlock = false; std::vector> finalVars; @@ -764,14 +767,14 @@ bool Rule::evaluate(Transaction *trans, + "\" with param " \ + eparam \ + " against " \ - + Variable::to_s(variables) + "."); + + variables + "."); #endif } else { #ifndef NO_LOGS trans->debug(4, "(Rule: " + std::to_string(m_ruleId) \ + ") Executing operator \"" + this->m_op->m_op \ + " against " \ - + Variable::to_s(variables) + "."); + + variables + "."); #endif } diff --git a/src/variables/args.h b/src/variables/args.h index 18eac9e3..20067909 100644 --- a/src/variables/args.h +++ b/src/variables/args.h @@ -29,51 +29,7 @@ namespace modsecurity { class Transaction; namespace Variables { -class Args_DictElement : public Variable { - public: - explicit Args_DictElement(std::string dictElement) - : Variable("ARGS" + std::string(":") + std::string(dictElement)), - m_dictElement(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgs.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class Args_NoDictElement : public Variable { - public: - Args_NoDictElement() - : Variable("ARGS") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgs.resolve(l, m_keyExclusion); - } -}; - - -class Args_DictElementRegexp : public Variable { - public: - explicit Args_DictElementRegexp(std::string dictElement) - : Variable("ARGS:regex(" + dictElement + ")"), - m_r(dictElement) { - } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgs.resolveRegularExpression(&m_r, l, - m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(Args, ARGS, m_variableArgs) } // namespace Variables diff --git a/src/variables/args_combined_size.h b/src/variables/args_combined_size.h index 82a46d2a..9fce1795 100644 --- a/src/variables/args_combined_size.h +++ b/src/variables/args_combined_size.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class ArgsCombinedSize : public Variable { - public: - ArgsCombinedSize() - : Variable("ARGS_COMBINED_SIZE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableARGScombinedSize.evaluate(l); - } -}; +DEFINE_VARIABLE(ArgsCombinedSize, ARGS_COMBINED_SIZE, + m_variableARGScombinedSize) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/args_get.h b/src/variables/args_get.h index 4edc78c3..2b5973a2 100644 --- a/src/variables/args_get.h +++ b/src/variables/args_get.h @@ -29,50 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class ArgsGet_DictElement : public Variable { - public: - explicit ArgsGet_DictElement(std::string dictElement) - : Variable("ARGS_GET" + std::string(":") + std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsGet.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class ArgsGet_NoDictElement : public Variable { - public: - ArgsGet_NoDictElement() - : Variable("ARGS_GET") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsGet.resolve(l, m_keyExclusion); - } -}; - - -class ArgsGet_DictElementRegexp : public Variable { - public: - explicit ArgsGet_DictElementRegexp(std::string dictElement) - : Variable("ARGS_GET:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsGet.resolveRegularExpression(&m_r, l, - m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(ArgsGet, ARGS_GET, m_variableArgsGet) } // namespace Variables diff --git a/src/variables/args_get_names.h b/src/variables/args_get_names.h index 81adeb49..e3cc0245 100644 --- a/src/variables/args_get_names.h +++ b/src/variables/args_get_names.h @@ -29,49 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ArgsGetNames_DictElement : public Variable { - public: - explicit ArgsGetNames_DictElement(std::string dictElement) - : Variable("ARGS_GET_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsGetNames.resolve(m_dictElement, l); - } +DEFINE_VARIABLE_DICT(ArgsGetNames, ARGS_GET_NAMES, m_variableArgsGetNames) - std::string m_dictElement; -}; - -class ArgsGetNames_NoDictElement : public Variable { - public: - ArgsGetNames_NoDictElement() - : Variable("ARGS_GET_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsGetNames.resolve(l, m_keyExclusion); - } -}; - -class ArgsGetNames_DictElementRegexp : public Variable { - public: - explicit ArgsGetNames_DictElementRegexp(std::string dictElement) - : Variable("ARGS_GET_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsGetNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/args_names.h b/src/variables/args_names.h index 1c7463bf..d9dc6add 100644 --- a/src/variables/args_names.h +++ b/src/variables/args_names.h @@ -29,49 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ArgsNames_DictElement : public Variable { - public: - explicit ArgsNames_DictElement(std::string dictElement) - : Variable("ARGS_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsNames.resolve(m_dictElement, l); - } +DEFINE_VARIABLE_DICT(ArgsNames, ARGS_NAMES, m_variableArgsNames) - std::string m_dictElement; -}; - -class ArgsNames_NoDictElement : public Variable { - public: - ArgsNames_NoDictElement() - : Variable("ARGS_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsNames.resolve(l, m_keyExclusion); - } -}; - -class ArgsNames_DictElementRegexp : public Variable { - public: - explicit ArgsNames_DictElementRegexp(std::string dictElement) - : Variable("ARGS_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/args_post.h b/src/variables/args_post.h index 241b804e..8731e50e 100644 --- a/src/variables/args_post.h +++ b/src/variables/args_post.h @@ -29,50 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class ArgsPost_DictElement : public Variable { - public: - explicit ArgsPost_DictElement(std::string dictElement) - : Variable("ARGS_POST" + std::string(":") + std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsPost.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class ArgsPost_NoDictElement : public Variable { - public: - ArgsPost_NoDictElement() - : Variable("ARGS_POST") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsPost.resolve(l, m_keyExclusion); - } -}; - - -class ArgsPost_DictElementRegexp : public Variable { - public: - explicit ArgsPost_DictElementRegexp(std::string dictElement) - : Variable("ARGS_POST:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsPost.resolveRegularExpression(&m_r, l, - m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(ArgsPost, ARGS_POST, m_variableArgsPost) } // namespace Variables diff --git a/src/variables/args_post_names.h b/src/variables/args_post_names.h index abc44ec8..1e64191e 100644 --- a/src/variables/args_post_names.h +++ b/src/variables/args_post_names.h @@ -29,49 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ArgsPostNames_DictElement : public Variable { - public: - explicit ArgsPostNames_DictElement(std::string dictElement) - : Variable("ARGS_POST_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsPostNames.resolve(m_dictElement, l); - } +DEFINE_VARIABLE_DICT(ArgsPostNames, ARGS_POST_NAMES, m_variableArgsPostNames) - std::string m_dictElement; -}; - -class ArgsPostNames_NoDictElement : public Variable { - public: - ArgsPostNames_NoDictElement() - : Variable("ARGS_POST_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsPostNames.resolve(l, m_keyExclusion); - } -}; - -class ArgsPostNames_DictElementRegexp : public Variable { - public: - explicit ArgsPostNames_DictElementRegexp(std::string dictElement) - : Variable("ARGS_POST_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableArgsPostNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/auth_type.h b/src/variables/auth_type.h index 90f87120..431ff6f9 100644 --- a/src/variables/auth_type.h +++ b/src/variables/auth_type.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class AuthType : public Variable { - public: - AuthType() - : Variable("AUTH_TYPE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableAuthType.evaluate(l); - } -}; +DEFINE_VARIABLE(AuthType, AUTH_TYPE, m_variableAuthType) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/files.h b/src/variables/files.h index 7823eee9..e98eadf5 100644 --- a/src/variables/files.h +++ b/src/variables/files.h @@ -29,51 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class Files_DictElement : public Variable { - public: - explicit Files_DictElement(std::string dictElement) - : Variable("FILES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFiles.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class Files_NoDictElement : public Variable { - public: - Files_NoDictElement() - : Variable("FILES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFiles.resolve(l, m_keyExclusion); - } -}; - - -class Files_DictElementRegexp : public Variable { - public: - explicit Files_DictElementRegexp(std::string dictElement) - : Variable("FILES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFiles.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(Files, FILES, m_variableFiles) } // namespace Variables diff --git a/src/variables/files_combined_size.h b/src/variables/files_combined_size.h index e3070f57..024ab1ef 100644 --- a/src/variables/files_combined_size.h +++ b/src/variables/files_combined_size.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class FilesCombinedSize : public Variable { - public: - FilesCombinedSize() - : Variable("FILES_COMBINED_SIZE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableFilesCombinedSize.evaluate(l); - } -}; +DEFINE_VARIABLE(FilesCombinedSize, FILES_COMBINED_SIZE, + m_variableFilesCombinedSize) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/files_names.h b/src/variables/files_names.h index b0c85abd..c489286a 100644 --- a/src/variables/files_names.h +++ b/src/variables/files_names.h @@ -29,52 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class FilesNames_DictElement : public Variable { - public: - explicit FilesNames_DictElement(std::string dictElement) - : Variable("FILES_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesNames.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class FilesNames_NoDictElement : public Variable { - public: - FilesNames_NoDictElement() - : Variable("FILES_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesNames.resolve(l, m_keyExclusion); - } -}; - - -class FilesNames_DictElementRegexp : public Variable { - public: - explicit FilesNames_DictElementRegexp(std::string dictElement) - : Variable("FILES_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(FilesNames, FILES_NAMES, m_variableFilesNames) } // namespace Variables diff --git a/src/variables/files_sizes.h b/src/variables/files_sizes.h index 7ce1493f..f954fb86 100644 --- a/src/variables/files_sizes.h +++ b/src/variables/files_sizes.h @@ -29,51 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class FilesSizes_DictElement : public Variable { - public: - explicit FilesSizes_DictElement(std::string dictElement) - : Variable("FILES_SIZES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesSizes.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class FilesSizes_NoDictElement : public Variable { - public: - FilesSizes_NoDictElement() - : Variable("FILES_SIZES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesSizes.resolve(l, m_keyExclusion); - } -}; - - -class FilesSizes_DictElementRegexp : public Variable { - public: - explicit FilesSizes_DictElementRegexp(std::string dictElement) - : Variable("FILES_SIZES"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesSizes.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(FilesSizes, FILES_SIZES, m_variableFilesSizes) } // namespace Variables diff --git a/src/variables/files_tmp_content.h b/src/variables/files_tmp_content.h index 59a14b19..c26edf9b 100644 --- a/src/variables/files_tmp_content.h +++ b/src/variables/files_tmp_content.h @@ -29,51 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class FilesTmpContent_DictElement : public Variable { - public: - explicit FilesTmpContent_DictElement(std::string dictElement) - : Variable("FILES_TMP_CONTENT" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesTmpContent.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class FilesTmpContent_NoDictElement : public Variable { - public: - FilesTmpContent_NoDictElement() - : Variable("FILES_TMP_CONTENT") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesTmpContent.resolve(l, m_keyExclusion); - } -}; - - -class FilesTmpContent_DictElementRegexp : public Variable { - public: - explicit FilesTmpContent_DictElementRegexp(std::string dictElement) - : Variable("FILES_TMP_CONTENT:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesTmpContent.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(FilesTmpContent, FILES_TMP_CONTENT, + m_variableFilesTmpContent) } // namespace Variables diff --git a/src/variables/files_tmp_names.h b/src/variables/files_tmp_names.h index 8b802797..3ef85197 100644 --- a/src/variables/files_tmp_names.h +++ b/src/variables/files_tmp_names.h @@ -28,51 +28,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class FilesTmpNames_DictElement : public Variable { - public: - explicit FilesTmpNames_DictElement(std::string dictElement) - : Variable("FILES_TMPNAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesTmpNames.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; -class FilesTmpNames_NoDictElement : public Variable { - public: - FilesTmpNames_NoDictElement() - : Variable("FILES_TMPNAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesTmpNames.resolve(l, m_keyExclusion); - } -}; - - -class FilesTmpNames_DictElementRegexp : public Variable { - public: - explicit FilesTmpNames_DictElementRegexp(std::string dictElement) - : Variable("FILES_TMPNAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableFilesTmpNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(FilesTmpNames, FILES_TMPNAMES, m_variableFilesTmpNames) } // namespace Variables diff --git a/src/variables/full_request.h b/src/variables/full_request.h index ad64ad0a..b452b980 100644 --- a/src/variables/full_request.h +++ b/src/variables/full_request.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class FullRequest : public Variable { - public: - FullRequest() - : Variable("FULL_REQUEST") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableFullRequest.evaluate(l); - } -}; +DEFINE_VARIABLE(FullRequest, FULL_REQUEST, m_variableFullRequest) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/full_request_length.h b/src/variables/full_request_length.h index 5d199b1a..634e567d 100644 --- a/src/variables/full_request_length.h +++ b/src/variables/full_request_length.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class FullRequestLength : public Variable { - public: - FullRequestLength() - : Variable("FULL_REQUEST_LENGTH") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableFullRequestLength.evaluate(l); - } -}; +DEFINE_VARIABLE(FullRequestLength, FULL_REQUEST_LENGTH, + m_variableFullRequestLength) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/geo.h b/src/variables/geo.h index bdb6840d..c15a1c3c 100644 --- a/src/variables/geo.h +++ b/src/variables/geo.h @@ -29,51 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class Geo_DictElement : public Variable { - public: - explicit Geo_DictElement(std::string dictElement) - : Variable("GEO" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableGeo.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class Geo_NoDictElement : public Variable { - public: - Geo_NoDictElement() - : Variable("GEO") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableGeo.resolve(l, m_keyExclusion); - } -}; - - -class Geo_DictElementRegexp : public Variable { - public: - explicit Geo_DictElementRegexp(std::string dictElement) - : Variable("GEO:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableGeo.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(Geo, GEO, m_variableGeo) } // namespace Variables diff --git a/src/variables/global.h b/src/variables/global.h index 2c994ed3..d2fc2cda 100644 --- a/src/variables/global.h +++ b/src/variables/global.h @@ -65,11 +65,10 @@ class Global_NoDictElement : public Variable { }; -class Global_DictElementRegexp : public Variable { +class Global_DictElementRegexp : public VariableRegex { public: explicit Global_DictElementRegexp(std::string dictElement) - : Variable("GLOBAL:regex(" + dictElement + ")"), - m_r(dictElement), + : VariableRegex("GLOBAL", dictElement), m_dictElement(dictElement) { } void evaluate(Transaction *t, @@ -81,7 +80,6 @@ class Global_DictElementRegexp : public Variable { t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion); } - Utils::Regex m_r; std::string m_dictElement; }; diff --git a/src/variables/inbound_data_error.h b/src/variables/inbound_data_error.h index 71f4498e..c795f5f5 100644 --- a/src/variables/inbound_data_error.h +++ b/src/variables/inbound_data_error.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class InboundDataError : public Variable { - public: - InboundDataError() - : Variable("INBOUND_DATA_ERROR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableInboundDataError.evaluate(l); - } -}; +DEFINE_VARIABLE(InboundDataError, INBOUND_DATA_ERROR, m_variableInboundDataError) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/ip.h b/src/variables/ip.h index 07010341..96200d8e 100644 --- a/src/variables/ip.h +++ b/src/variables/ip.h @@ -65,11 +65,10 @@ class Ip_NoDictElement : public Variable { }; -class Ip_DictElementRegexp : public Variable { +class Ip_DictElementRegexp : public VariableRegex { public: explicit Ip_DictElementRegexp(std::string dictElement) - : Variable("IP:regex(" + dictElement + ")"), - m_r(dictElement), + : VariableRegex("IP", dictElement), m_dictElement(dictElement) { } void evaluate(Transaction *t, @@ -80,7 +79,6 @@ class Ip_DictElementRegexp : public Variable { t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion); } - Utils::Regex m_r; std::string m_dictElement; }; diff --git a/src/variables/matched_var.h b/src/variables/matched_var.h index bd4899c7..274e995a 100644 --- a/src/variables/matched_var.h +++ b/src/variables/matched_var.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class MatchedVar : public Variable { - public: - MatchedVar() - : Variable("MATCHED_VAR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMatchedVar.evaluate(l); - } -}; +DEFINE_VARIABLE(MatchedVar, MATCHED_VAR, m_variableMatchedVar) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/matched_var_name.h b/src/variables/matched_var_name.h index af5b1688..d13c07fc 100644 --- a/src/variables/matched_var_name.h +++ b/src/variables/matched_var_name.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class MatchedVarName : public Variable { - public: - MatchedVarName() - : Variable("MATCHED_VAR_NAME") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVarName.evaluate(l); - } -}; +DEFINE_VARIABLE(MatchedVarName, MATCHED_VAR_NAME, m_variableMatchedVarName) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/matched_vars.h b/src/variables/matched_vars.h index 8b2a53be..185eb376 100644 --- a/src/variables/matched_vars.h +++ b/src/variables/matched_vars.h @@ -29,51 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class MatchedVars_DictElement : public Variable { - public: - explicit MatchedVars_DictElement(std::string dictElement) - : Variable("MATCHED_VARS" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVars.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class MatchedVars_NoDictElement : public Variable { - public: - MatchedVars_NoDictElement() - : Variable("MATCHED_VARS") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVars.resolve(l, m_keyExclusion); - } -}; - - -class MatchedVars_DictElementRegexp : public Variable { - public: - explicit MatchedVars_DictElementRegexp(std::string dictElement) - : Variable("MATCHED_VARS:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVars.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(MatchedVars, MATCHED_VARS, m_variableMatchedVars) } // namespace Variables diff --git a/src/variables/matched_vars_names.h b/src/variables/matched_vars_names.h index 6cb5273f..0100c42d 100644 --- a/src/variables/matched_vars_names.h +++ b/src/variables/matched_vars_names.h @@ -29,51 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class MatchedVarsNames_DictElement : public Variable { - public: - explicit MatchedVarsNames_DictElement(std::string dictElement) - : Variable("MATCHED_VARS_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVarsNames.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class MatchedVarsNames_NoDictElement : public Variable { - public: - MatchedVarsNames_NoDictElement() - : Variable("MATCHED_VARS_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVarsNames.resolve(l, m_keyExclusion); - } -}; - - -class MatchedVarsNames_DictElementRegexp : public Variable { - public: - explicit MatchedVarsNames_DictElementRegexp(std::string dictElement) - : Variable("MATCHED_VARS_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMatchedVarsNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(MatchedVarsNames, MATCHED_VARS_NAMES, + m_variableMatchedVarsNames) } // namespace Variables diff --git a/src/variables/multipart_boundary_quoted.h b/src/variables/multipart_boundary_quoted.h index ec753045..b0531713 100644 --- a/src/variables/multipart_boundary_quoted.h +++ b/src/variables/multipart_boundary_quoted.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartBoundaryQuoted : public Variable { - public: - MultipartBoundaryQuoted() - : Variable("MULTIPART_BOUNDARY_QUOTED") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartBoundaryQuoted.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartBoundaryQuoted, MULTIPART_BOUNDARY_QUOTED, + m_variableMultipartBoundaryQuoted) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_boundary_whitespace.h b/src/variables/multipart_boundary_whitespace.h index 1a94b0a1..b0bdc714 100644 --- a/src/variables/multipart_boundary_whitespace.h +++ b/src/variables/multipart_boundary_whitespace.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartBoundaryWhiteSpace : public Variable { - public: - MultipartBoundaryWhiteSpace() - : Variable("MULTIPART_BOUNDARY_WHITESPACE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartBoundaryWhiteSpace.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartBoundaryWhiteSpace, MULTIPART_BOUNDARY_WHITESPACE, + m_variableMultipartBoundaryWhiteSpace) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_crlf_lf_lines.h b/src/variables/multipart_crlf_lf_lines.h index 8df96374..3d7bee17 100644 --- a/src/variables/multipart_crlf_lf_lines.h +++ b/src/variables/multipart_crlf_lf_lines.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartCrlfLFLines : public Variable { - public: - MultipartCrlfLFLines() - : Variable("MULTIPART_CRLF_LF_LINES") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartCrlfLFLines.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartCrlfLFLines, MULTIPART_CRLF_LF_LINES, + m_variableMultipartCrlfLFLines) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_data_after.h b/src/variables/multipart_data_after.h index 5509b5b9..ca88d0fd 100644 --- a/src/variables/multipart_data_after.h +++ b/src/variables/multipart_data_after.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartDateAfter : public Variable { - public: - MultipartDateAfter() - : Variable("MULTIPART_DATA_AFTER") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartDataAfter.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartDateAfter, MULTIPART_DATA_AFTER, + m_variableMultipartDataAfter) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_data_before.h b/src/variables/multipart_data_before.h index 1f72511b..734eddbe 100644 --- a/src/variables/multipart_data_before.h +++ b/src/variables/multipart_data_before.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartDateBefore : public Variable { - public: - MultipartDateBefore() - : Variable("MULTIPART_DATA_BEFORE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartDataBefore.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartDateBefore, MULTIPART_DATA_BEFORE, + m_variableMultipartDataBefore) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_file_limit_exceeded.h b/src/variables/multipart_file_limit_exceeded.h index bba687d8..8803b406 100644 --- a/src/variables/multipart_file_limit_exceeded.h +++ b/src/variables/multipart_file_limit_exceeded.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartFileLimitExceeded : public Variable { - public: - MultipartFileLimitExceeded() - : Variable("MULTIPART_FILE_LIMIT_EXCEEDED") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartFileLimitExceeded.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartFileLimitExceeded, MULTIPART_FILE_LIMIT_EXCEEDED, + m_variableMultipartFileLimitExceeded) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_file_name.h b/src/variables/multipart_file_name.h index 8d5c4d9b..f220b760 100644 --- a/src/variables/multipart_file_name.h +++ b/src/variables/multipart_file_name.h @@ -29,51 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultiPartFileName_DictElement : public Variable { - public: - explicit MultiPartFileName_DictElement(std::string dictElement) - : Variable("MULTIPART_FILENAME" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMultipartFileName.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class MultiPartFileName_NoDictElement : public Variable { - public: - MultiPartFileName_NoDictElement() - : Variable("MULTIPART_FILENAME") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMultipartFileName.resolve(l, m_keyExclusion); - } -}; - - -class MultiPartFileName_DictElementRegexp : public Variable { - public: - explicit MultiPartFileName_DictElementRegexp(std::string dictElement) - : Variable("MULTIPART_FILENAME:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMultipartFileName.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(MultiPartFileName, MULTIPART_FILENAME, + m_variableMultipartFileName) } // namespace Variables diff --git a/src/variables/multipart_header_folding.h b/src/variables/multipart_header_folding.h index c21a3cd2..dbc02989 100644 --- a/src/variables/multipart_header_folding.h +++ b/src/variables/multipart_header_folding.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartHeaderFolding : public Variable { - public: - MultipartHeaderFolding() - : Variable("MULTIPART_HEADER_FOLDING") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartHeaderFolding.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartHeaderFolding, MULTIPART_HEADER_FOLDING, + m_variableMultipartHeaderFolding) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_invalid_header_folding.h b/src/variables/multipart_invalid_header_folding.h index 098f7df1..260e5a7b 100644 --- a/src/variables/multipart_invalid_header_folding.h +++ b/src/variables/multipart_invalid_header_folding.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartInvalidHeaderFolding : public Variable { - public: - MultipartInvalidHeaderFolding() - : Variable("MULTIPART_INVALID_HEADER_FOLDING") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartInvalidHeaderFolding.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartInvalidHeaderFolding, MULTIPART_INVALID_HEADER_FOLDING, m_variableMultipartInvalidHeaderFolding) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_invalid_part.h b/src/variables/multipart_invalid_part.h index fa40724a..392d50bb 100644 --- a/src/variables/multipart_invalid_part.h +++ b/src/variables/multipart_invalid_part.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartInvalidPart : public Variable { - public: - MultipartInvalidPart() - : Variable("MULTIPART_INVALID_PART") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartInvalidPart.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartInvalidPart, MULTIPART_INVALID_PART, + m_variableMultipartInvalidHeaderFolding) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_invalid_quoting.h b/src/variables/multipart_invalid_quoting.h index 8ef5f471..514810aa 100644 --- a/src/variables/multipart_invalid_quoting.h +++ b/src/variables/multipart_invalid_quoting.h @@ -29,16 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartInvalidQuoting : public Variable { - public: - MultipartInvalidQuoting() - : Variable("MULTIPART_INVALID_QUOTING") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartInvalidQuoting.evaluate(l); - } -}; + +DEFINE_VARIABLE(MultipartInvalidQuoting, MULTIPART_INVALID_QUOTING, + m_variableMultipartInvalidQuoting) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_lf_line.h b/src/variables/multipart_lf_line.h index 20edd679..20beb5f5 100644 --- a/src/variables/multipart_lf_line.h +++ b/src/variables/multipart_lf_line.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartLFLine : public Variable { - public: - MultipartLFLine() - : Variable("MULTIPART_LF_LINE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartLFLine.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartLFLine, MULTIPART_LF_LINE, m_variableMultipartLFLine) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_missing_semicolon.h b/src/variables/multipart_missing_semicolon.h index dc298ac6..7082c0c3 100644 --- a/src/variables/multipart_missing_semicolon.h +++ b/src/variables/multipart_missing_semicolon.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartMissingSemicolon : public Variable { - public: - MultipartMissingSemicolon() - : Variable("MULTIPART_MISSING_SEMICOLON") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartMissingSemicolon.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartMissingSemicolon, MULTIPART_MISSING_SEMICOLON, + m_variableMultipartMissingSemicolon) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_name.h b/src/variables/multipart_name.h index 42072395..af399e0a 100644 --- a/src/variables/multipart_name.h +++ b/src/variables/multipart_name.h @@ -29,51 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultiPartName_DictElement : public Variable { - public: - explicit MultiPartName_DictElement(std::string dictElement) - : Variable("MULTIPART_NAME" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMultipartName.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class MultiPartName_NoDictElement : public Variable { - public: - MultiPartName_NoDictElement() - : Variable("MULTIPART_NAME") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMultipartName.resolve(l, m_keyExclusion); - } -}; - - -class MultiPartName_DictElementRegexp : public Variable { - public: - explicit MultiPartName_DictElementRegexp(std::string dictElement) - : Variable("MULTIPART_NAME:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableMultipartName.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(MultiPartName, MULTIPART_NAME, m_variableMultipartName) } // namespace Variables diff --git a/src/variables/multipart_strict_error.h b/src/variables/multipart_strict_error.h index 627c6855..41667cad 100644 --- a/src/variables/multipart_strict_error.h +++ b/src/variables/multipart_strict_error.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartStrictError : public Variable { - public: - MultipartStrictError() - : Variable("MULTIPART_STRICT_ERROR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartStrictError.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartStrictError, MULTIPART_STRICT_ERROR, + m_variableMultipartStrictError) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/multipart_unmatched_boundary.h b/src/variables/multipart_unmatched_boundary.h index 5d0c307b..84ff75cb 100644 --- a/src/variables/multipart_unmatched_boundary.h +++ b/src/variables/multipart_unmatched_boundary.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class MultipartUnmatchedBoundary : public Variable { - public: - MultipartUnmatchedBoundary() - : Variable("MULTIPART_UNMATCHED_BOUNDARY") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableMultipartUnmatchedBoundary.evaluate(l); - } -}; +DEFINE_VARIABLE(MultipartUnmatchedBoundary, MULTIPART_UNMATCHED_BOUNDARY, + m_variableMultipartUnmatchedBoundary) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/outbound_data_error.h b/src/variables/outbound_data_error.h index a07e9a85..6762acb1 100644 --- a/src/variables/outbound_data_error.h +++ b/src/variables/outbound_data_error.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class OutboundDataError : public Variable { - public: - OutboundDataError() - : Variable("OUTBOUND_DATA_ERROR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableOutboundDataError.evaluate(l); - } -}; +DEFINE_VARIABLE(OutboundDataError, OUTBOUND_DATA_ERROR, + m_variableOutboundDataError) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/path_info.h b/src/variables/path_info.h index d07ba663..64ddbb23 100644 --- a/src/variables/path_info.h +++ b/src/variables/path_info.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class PathInfo : public Variable { - public: - PathInfo() - : Variable("PATH_INFO") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variablePathInfo.evaluate(l); - } -}; +DEFINE_VARIABLE(PathInfo, PATH_INFO, m_variablePathInfo) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/query_string.h b/src/variables/query_string.h index ff4be292..bbdc7ef6 100644 --- a/src/variables/query_string.h +++ b/src/variables/query_string.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class QueryString : public Variable { - public: - QueryString() - : Variable("QUERY_STRING") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableQueryString.evaluate(l); - } -}; +DEFINE_VARIABLE(QueryString, QUERY_STRING, m_variableQueryString) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/remote_addr.h b/src/variables/remote_addr.h index 6d71d8bd..7bf48923 100644 --- a/src/variables/remote_addr.h +++ b/src/variables/remote_addr.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RemoteAddr : public Variable { - public: - RemoteAddr() - : Variable("REMOTE_ADDR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRemoteAddr.evaluate(l); - } -}; +DEFINE_VARIABLE(RemoteAddr, REMOTE_ADDR, m_variableRemoteAddr) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/remote_host.h b/src/variables/remote_host.h index 316d36fa..b4b8c642 100644 --- a/src/variables/remote_host.h +++ b/src/variables/remote_host.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RemoteHost : public Variable { - public: - RemoteHost() - : Variable("REMOTE_HOST") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRemoteHost.evaluate(l); - } -}; +DEFINE_VARIABLE(RemoteHost, REMOTE_HOST, m_variableRemoteHost) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/remote_port.h b/src/variables/remote_port.h index 9b9bf5de..f846be61 100644 --- a/src/variables/remote_port.h +++ b/src/variables/remote_port.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RemotePort : public Variable { - public: - RemotePort() - : Variable("REMOTE_PORT") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRemotePort.evaluate(l); - } -}; +DEFINE_VARIABLE(RemotePort, REMOTE_PORT, m_variableRemotePort) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/reqbody_error.h b/src/variables/reqbody_error.h index 66241014..e7be1c80 100644 --- a/src/variables/reqbody_error.h +++ b/src/variables/reqbody_error.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ReqbodyError : public Variable { - public: - ReqbodyError() - : Variable("REQBODY_ERROR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableReqbodyError.evaluate(l); - } -}; +DEFINE_VARIABLE(ReqbodyError, REQBODY_ERROR, m_variableReqbodyError) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/reqbody_error_msg.h b/src/variables/reqbody_error_msg.h index d6368571..a218d90a 100644 --- a/src/variables/reqbody_error_msg.h +++ b/src/variables/reqbody_error_msg.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ReqbodyErrorMsg : public Variable { - public: - ReqbodyErrorMsg() - : Variable("REQBODY_ERROR_MSG") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableReqbodyErrorMsg.evaluate(l); - } -}; + +DEFINE_VARIABLE(ReqbodyErrorMsg, REQBODY_ERROR_MSG, m_variableReqbodyErrorMsg) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/reqbody_processor.h b/src/variables/reqbody_processor.h index 05241a6d..b957b85e 100644 --- a/src/variables/reqbody_processor.h +++ b/src/variables/reqbody_processor.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ReqbodyProcessor : public Variable { - public: - ReqbodyProcessor() - : Variable("REQBODY_PROCESSOR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableReqbodyProcessor.evaluate(l); - } -}; + +DEFINE_VARIABLE(ReqbodyProcessor, REQBODY_PROCESSOR, m_variableReqbodyProcessor) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/reqbody_processor_error.h b/src/variables/reqbody_processor_error.h index bf256a01..9ec057b1 100644 --- a/src/variables/reqbody_processor_error.h +++ b/src/variables/reqbody_processor_error.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class ReqbodyProcessorError : public Variable { - public: - ReqbodyProcessorError() - : Variable("REQBODY_PROCESSOR_ERROR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableReqbodyProcessorError.evaluate(l); - } -}; +DEFINE_VARIABLE(ReqbodyProcessorError, REQBODY_PROCESSOR_ERROR, + m_variableReqbodyProcessorError) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/reqbody_processor_error_msg.h b/src/variables/reqbody_processor_error_msg.h index 2c07e5d5..babd4143 100644 --- a/src/variables/reqbody_processor_error_msg.h +++ b/src/variables/reqbody_processor_error_msg.h @@ -29,17 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class ReqbodyProcessorErrorMsg : public Variable { - public: - ReqbodyProcessorErrorMsg() - : Variable("PROCESSOR_ERROR_MSG") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableReqbodyProcessorErrorMsg.evaluate(l); - } -}; +DEFINE_VARIABLE(ReqbodyProcessorErrorMsg, PROCESSOR_ERROR_MSG, + m_variableReqbodyProcessorErrorMsg) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_base_name.h b/src/variables/request_base_name.h index 05d31a7f..22dd3e43 100644 --- a/src/variables/request_base_name.h +++ b/src/variables/request_base_name.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestBasename : public Variable { - public: - RequestBasename() - : Variable("REQUEST_BASENAME") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestBasename.evaluate(l); - } -}; +DEFINE_VARIABLE(RequestBasename, REQUEST_BASENAME, m_variableRequestBasename) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_body.h b/src/variables/request_body.h index f4a87526..1a623dd1 100644 --- a/src/variables/request_body.h +++ b/src/variables/request_body.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestBody : public Variable { - public: - RequestBody() - : Variable("REQUEST_BODY") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestBody.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestBody, REQUEST_BODY, m_variableRequestBody) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_body_length.h b/src/variables/request_body_length.h index ffb88d56..af980119 100644 --- a/src/variables/request_body_length.h +++ b/src/variables/request_body_length.h @@ -29,16 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestBodyLength : public Variable { - public: - RequestBodyLength() - : Variable("REQUEST_BODY_LENGTH") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestBodyLength.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestBodyLength, REQUEST_BODY_LENGTH, + m_variableRequestBodyLength) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_cookies.h b/src/variables/request_cookies.h index 6bd28b89..a509246e 100644 --- a/src/variables/request_cookies.h +++ b/src/variables/request_cookies.h @@ -29,53 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestCookies_DictElement : public Variable { - public: - explicit RequestCookies_DictElement(std::string dictElement) - : Variable("REQUEST_COOKIES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestCookies.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class RequestCookies_NoDictElement : public Variable { - public: - RequestCookies_NoDictElement() - : Variable("REQUEST_COOKIES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestCookies.resolve(l, m_keyExclusion); - } -}; - - -class RequestCookies_DictElementRegexp : public Variable { - public: - explicit RequestCookies_DictElementRegexp(std::string dictElement) - : Variable("REQUEST_COOKIES:regex(" + dictElement + ")"), - m_r(dictElement) { - m_regex = dictElement; - } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestCookies.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(RequestCookies, REQUEST_COOKIES, m_variableRequestCookies) } // namespace Variables diff --git a/src/variables/request_cookies_names.h b/src/variables/request_cookies_names.h index b98ced66..e44ae0ea 100644 --- a/src/variables/request_cookies_names.h +++ b/src/variables/request_cookies_names.h @@ -29,51 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestCookiesNames_DictElement : public Variable { - public: - explicit RequestCookiesNames_DictElement(std::string dictElement) - : Variable("REQUEST_COOKIES_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestCookiesNames.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class RequestCookiesNames_NoDictElement : public Variable { - public: - RequestCookiesNames_NoDictElement() - : Variable("REQUEST_COOKIES_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestCookiesNames.resolve(l, m_keyExclusion); - } -}; - - -class RequestCookiesNames_DictElementRegexp : public Variable { - public: - explicit RequestCookiesNames_DictElementRegexp(std::string dictElement) - : Variable("REQUEST_COOKIES_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestCookiesNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(RequestCookiesNames, REQUEST_COOKIES_NAMES, + m_variableRequestCookiesNames) } // namespace Variables diff --git a/src/variables/request_file_name.h b/src/variables/request_file_name.h index c1f99341..17c3b41b 100644 --- a/src/variables/request_file_name.h +++ b/src/variables/request_file_name.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestFilename : public Variable { - public: - RequestFilename() - : Variable("REQUEST_FILENAME") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestFilename.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestFilename, REQUEST_FILENAME, m_variableRequestFilename) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_headers.h b/src/variables/request_headers.h index 1a7e749a..d0f94673 100644 --- a/src/variables/request_headers.h +++ b/src/variables/request_headers.h @@ -29,51 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestHeaders_DictElement : public Variable { - public: - explicit RequestHeaders_DictElement(std::string dictElement) - : Variable("REQUEST_HEADERS" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestHeaders.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class RequestHeaders_NoDictElement : public Variable { - public: - RequestHeaders_NoDictElement() - : Variable("REQUEST_HEADERS") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestHeaders.resolve(l, m_keyExclusion); - } -}; - - -class RequestHeaders_DictElementRegexp : public Variable { - public: - explicit RequestHeaders_DictElementRegexp(std::string dictElement) - : Variable("REQUEST_HEADERS"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestHeaders.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(RequestHeaders, REQUEST_HEADERS, m_variableRequestHeaders) } // namespace Variables diff --git a/src/variables/request_headers_names.h b/src/variables/request_headers_names.h index 9e0672fc..024fe176 100644 --- a/src/variables/request_headers_names.h +++ b/src/variables/request_headers_names.h @@ -29,49 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestHeadersNames_DictElement : public Variable { - public: - explicit RequestHeadersNames_DictElement(std::string dictElement) - : Variable("REQUEST_HEADERS_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestHeadersNames.resolve(m_dictElement, l); - } +DEFINE_VARIABLE_DICT(RequestHeadersNames, REQUEST_HEADERS_NAMES, + m_variableRequestHeadersNames) - std::string m_dictElement; -}; - -class RequestHeadersNames_NoDictElement : public Variable { - public: - RequestHeadersNames_NoDictElement() - : Variable("REQUEST_HEADERS_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestHeadersNames.resolve(l, m_keyExclusion); - } -}; - -class RequestHeadersNames_DictElementRegexp : public Variable { - public: - explicit RequestHeadersNames_DictElementRegexp(std::string dictElement) - : Variable("REQUEST_HEADERS_NAMES:regex(" + dictElement + ")"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRequestHeadersNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_line.h b/src/variables/request_line.h index a3015f07..2f585e12 100644 --- a/src/variables/request_line.h +++ b/src/variables/request_line.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestLine : public Variable { - public: - RequestLine() - : Variable("REQUEST_LINE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestLine.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestLine, REQUEST_LINE, m_variableRequestLine) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_method.h b/src/variables/request_method.h index 01062036..94e7a19f 100644 --- a/src/variables/request_method.h +++ b/src/variables/request_method.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestMethod : public Variable { - public: - RequestMethod() - : Variable("REQUEST_METHOD") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestMethod.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestMethod, REQUEST_METHOD, m_variableRequestMethod) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_protocol.h b/src/variables/request_protocol.h index 9a9c0da1..71c796a2 100644 --- a/src/variables/request_protocol.h +++ b/src/variables/request_protocol.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestProtocol : public Variable { - public: - RequestProtocol() - : Variable("REQUEST_PROTOCOL") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestProtocol.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestProtocol, REQUEST_PROTOCOL, m_variableRequestProtocol) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_uri.h b/src/variables/request_uri.h index 34d041a0..e6c0e154 100644 --- a/src/variables/request_uri.h +++ b/src/variables/request_uri.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestURI : public Variable { - public: - RequestURI() - : Variable("REQUEST_URI") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestURI.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestURI, REQUEST_URI, m_variableRequestURI) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/request_uri_raw.h b/src/variables/request_uri_raw.h index adb2922d..8b6df7bb 100644 --- a/src/variables/request_uri_raw.h +++ b/src/variables/request_uri_raw.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class RequestURIRaw : public Variable { - public: - RequestURIRaw() - : Variable("REQUEST_URI_RAW") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableRequestURIRaw.evaluate(l); - } -}; + +DEFINE_VARIABLE(RequestURIRaw, REQUEST_URI_RAW, m_variableRequestURIRaw) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/resource.h b/src/variables/resource.h index 749043d0..e9d8f1a7 100644 --- a/src/variables/resource.h +++ b/src/variables/resource.h @@ -65,11 +65,10 @@ class Resource_NoDictElement : public Variable { }; -class Resource_DictElementRegexp : public Variable { +class Resource_DictElementRegexp : public VariableRegex { public: explicit Resource_DictElementRegexp(std::string dictElement) - : Variable("RESOURCE:regex(" + dictElement + ")"), - m_r(dictElement), + : VariableRegex("RESOURCE:", dictElement), m_dictElement(dictElement) { } void evaluate(Transaction *t, @@ -80,7 +79,6 @@ class Resource_DictElementRegexp : public Variable { t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion); } - Utils::Regex m_r; std::string m_dictElement; }; diff --git a/src/variables/response_body.h b/src/variables/response_body.h index 9efff09c..3ac0fd79 100644 --- a/src/variables/response_body.h +++ b/src/variables/response_body.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseBody : public Variable { - public: - ResponseBody() - : Variable("RESPONSE_BODY") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableResponseBody.evaluate(l); - } -}; + +DEFINE_VARIABLE(ResponseBody, RESPONSE_BODY, m_variableResponseBody) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/response_content_length.h b/src/variables/response_content_length.h index 2ee9ee77..f7547310 100644 --- a/src/variables/response_content_length.h +++ b/src/variables/response_content_length.h @@ -29,16 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseContentLength : public Variable { - public: - ResponseContentLength() - : Variable("RESPONSE_CONTENT_LENGTH") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableResponseContentLength.evaluate(l); - } -}; + +DEFINE_VARIABLE(ResponseContentLength, RESPONSE_CONTENT_LENGTH, + m_variableResponseContentLength) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/response_content_type.h b/src/variables/response_content_type.h index 904e697e..1b647902 100644 --- a/src/variables/response_content_type.h +++ b/src/variables/response_content_type.h @@ -29,16 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseContentType : public Variable { - public: - ResponseContentType() - : Variable("RESPONSE_CONTENT_TYPE") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableResponseContentType.evaluate(l); - } -}; + +DEFINE_VARIABLE(ResponseContentType, RESPONSE_CONTENT_TYPE, + m_variableResponseContentType) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/response_headers.h b/src/variables/response_headers.h index d886f0eb..99707486 100644 --- a/src/variables/response_headers.h +++ b/src/variables/response_headers.h @@ -29,51 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseHeaders_DictElement : public Variable { - public: - explicit ResponseHeaders_DictElement(std::string dictElement) - : Variable("RESPONSE_HEADERS" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableResponseHeaders.resolve(m_dictElement, l); - } - - std::string m_dictElement; -}; - - -class ResponseHeaders_NoDictElement : public Variable { - public: - ResponseHeaders_NoDictElement() - : Variable("RESPONSE_HEADERS") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableResponseHeaders.resolve(l, m_keyExclusion); - } -}; - - -class ResponseHeaders_DictElementRegexp : public Variable { - public: - explicit ResponseHeaders_DictElementRegexp(std::string dictElement) - : Variable("RESPONSE_HEADERS"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableResponseHeaders.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; +DEFINE_VARIABLE_DICT(ResponseHeaders, RESPONSE_HEADERS, + m_variableResponseHeaders) } // namespace Variables diff --git a/src/variables/response_headers_names.h b/src/variables/response_headers_names.h index 7d2da578..e87a9710 100644 --- a/src/variables/response_headers_names.h +++ b/src/variables/response_headers_names.h @@ -29,49 +29,10 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseHeadersNames_DictElement : public Variable { - public: - explicit ResponseHeadersNames_DictElement(std::string dictElement) - : Variable("RESPONSE_HEADERS_NAMES" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableResponseHeadersNames.resolve(m_dictElement, l); - } +DEFINE_VARIABLE_DICT(ResponseHeadersNames, RESPONSE_HEADERS_NAMES, + m_variableResponseHeadersNames) - std::string m_dictElement; -}; - -class ResponseHeadersNames_NoDictElement : public Variable { - public: - ResponseHeadersNames_NoDictElement() - : Variable("RESPONSE_HEADERS_NAMES") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableResponseHeadersNames.resolve(l, m_keyExclusion); - } -}; - -class ResponseHeadersNames_DictElementRegexp : public Variable { - public: - explicit ResponseHeadersNames_DictElementRegexp(std::string dictElement) - : Variable("RESPONSE_HEADERS_NAMES"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableResponseHeadersNames.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/response_protocol.h b/src/variables/response_protocol.h index f3e81141..7e2a6543 100644 --- a/src/variables/response_protocol.h +++ b/src/variables/response_protocol.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseProtocol : public Variable { - public: - ResponseProtocol() - : Variable("RESPONSE_PROTOCOL") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableResponseProtocol.evaluate(l); - } -}; + +DEFINE_VARIABLE(ResponseProtocol, RESPONSE_PROTOCOL, m_variableResponseProtocol) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/response_status.h b/src/variables/response_status.h index 3f914275..779415b8 100644 --- a/src/variables/response_status.h +++ b/src/variables/response_status.h @@ -29,16 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ResponseStatus : public Variable { - public: - ResponseStatus() - : Variable("RESPONSE_STATUS") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableResponseStatus.evaluate(l); - } -}; + +DEFINE_VARIABLE(ResponseStatus, RESPONSE_STATUS, m_variableResponseStatus) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/rule.h b/src/variables/rule.h index 1f81a40c..099913df 100644 --- a/src/variables/rule.h +++ b/src/variables/rule.h @@ -27,51 +27,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class Rule_DictElement : public Variable { - public: - explicit Rule_DictElement(std::string dictElement) - : Variable("RULE" + std::string(":") + - std::string(dictElement)), - m_dictElement(dictElement) { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRule.resolve(m_dictElement, l); - } +DEFINE_VARIABLE_DICT(Rule, RULE, m_variableRule) - std::string m_dictElement; -}; - - -class Rule_NoDictElement : public Variable { - public: - Rule_NoDictElement() - : Variable("RULE") { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRule.resolve(l, m_keyExclusion); - } -}; - - -class Rule_DictElementRegexp : public Variable { - public: - explicit Rule_DictElementRegexp(std::string dictElement) - : Variable("RULE"), - m_r(dictElement) { } - - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) override { - transaction->m_variableRule.resolveRegularExpression( - &m_r, l, m_keyExclusion); - } - - Utils::Regex m_r; -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/server_addr.h b/src/variables/server_addr.h index 5bf7386c..e4b58924 100644 --- a/src/variables/server_addr.h +++ b/src/variables/server_addr.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ServerAddr : public Variable { - public: - ServerAddr() - : Variable("SERVER_ADDR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableServerAddr.evaluate(l); - } -}; +DEFINE_VARIABLE(ServerAddr, SERVER_ADDR, m_variableServerAddr) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/server_name.h b/src/variables/server_name.h index eaa47cb6..f4ae173d 100644 --- a/src/variables/server_name.h +++ b/src/variables/server_name.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ServerName : public Variable { - public: - ServerName() - : Variable("SERVER_NAME") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableServerName.evaluate(l); - } -}; +DEFINE_VARIABLE(ServerName, SERVER_NAME, m_variableServerName) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/server_port.h b/src/variables/server_port.h index f00f9042..fabdaada 100644 --- a/src/variables/server_port.h +++ b/src/variables/server_port.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class ServerPort : public Variable { - public: - ServerPort() - : Variable("SERVER_PORT") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableServerPort.evaluate(l); - } -}; +DEFINE_VARIABLE(ServerPort, SERVER_PORT, m_variableServerPort) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/session.h b/src/variables/session.h index 0c663882..352232c4 100644 --- a/src/variables/session.h +++ b/src/variables/session.h @@ -65,11 +65,10 @@ class Session_NoDictElement : public Variable { }; -class Session_DictElementRegexp : public Variable { +class Session_DictElementRegexp : public VariableRegex { public: explicit Session_DictElementRegexp(std::string dictElement) - : Variable("SESSION:regex(" + dictElement + ")"), - m_r(dictElement), + : VariableRegex("SESSION", dictElement), m_dictElement(dictElement) { } void evaluate(Transaction *t, @@ -80,7 +79,6 @@ class Session_DictElementRegexp : public Variable { t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion); } - Utils::Regex m_r; std::string m_dictElement; }; diff --git a/src/variables/session_id.h b/src/variables/session_id.h index 30202df0..1cee9c7f 100644 --- a/src/variables/session_id.h +++ b/src/variables/session_id.h @@ -29,17 +29,8 @@ namespace modsecurity { class Transaction; namespace Variables { -class SessionID : public Variable { - public: - SessionID() - : Variable("SESSIONID") { } +DEFINE_VARIABLE(SessionID, SESSIONID, m_variableSessionID) - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableSessionID.evaluate(l); - } -}; } // namespace Variables } // namespace modsecurity diff --git a/src/variables/status.h b/src/variables/status.h index a556943b..60b4225d 100644 --- a/src/variables/status.h +++ b/src/variables/status.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class Status : public Variable { - public: - Status() - : Variable("STATUS") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableResponseStatus.evaluate(l); - } -}; +DEFINE_VARIABLE(Status, STATUS, m_variableResponseStatus) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/tx.h b/src/variables/tx.h index 01c405bf..f7d39fe1 100644 --- a/src/variables/tx.h +++ b/src/variables/tx.h @@ -63,11 +63,10 @@ class Tx_NoDictElement : public Variable { }; -class Tx_DictElementRegexp : public Variable { +class Tx_DictElementRegexp : public VariableRegex { public: explicit Tx_DictElementRegexp(std::string dictElement) - : Variable("TX:regex(" + dictElement + ")"), - m_r(dictElement), + : VariableRegex("TX", dictElement), m_dictElement(dictElement) { } void evaluate(Transaction *t, @@ -77,7 +76,6 @@ class Tx_DictElementRegexp : public Variable { m_dictElement, l, m_keyExclusion); } - Utils::Regex m_r; std::string m_dictElement; }; diff --git a/src/variables/unique_id.h b/src/variables/unique_id.h index 2530ce92..1fe3d0e2 100644 --- a/src/variables/unique_id.h +++ b/src/variables/unique_id.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class UniqueID : public Variable { - public: - UniqueID() - : Variable("UNIQUEID") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableUniqueID.evaluate(l); - } -}; +DEFINE_VARIABLE(UniqueID, UNIQUEID, m_variableUniqueID) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/url_encoded_error.h b/src/variables/url_encoded_error.h index a12b92f7..e7ad1c0f 100644 --- a/src/variables/url_encoded_error.h +++ b/src/variables/url_encoded_error.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class UrlEncodedError : public Variable { - public: - UrlEncodedError() - : Variable("URLENCODED_ERROR") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableUrlEncodedError.evaluate(l); - } -}; +DEFINE_VARIABLE(UrlEncodedError, URLENCODED_ERROR, m_variableUrlEncodedError) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/user.h b/src/variables/user.h index a5ec4c65..c802d95c 100644 --- a/src/variables/user.h +++ b/src/variables/user.h @@ -65,11 +65,10 @@ class User_NoDictElement : public Variable { }; -class User_DictElementRegexp : public Variable { +class User_DictElementRegexp : public VariableRegex { public: explicit User_DictElementRegexp(std::string dictElement) - : Variable("USER:regex(" + dictElement + ")"), - m_r(dictElement), + : VariableRegex("USER", dictElement), m_dictElement(dictElement) { } void evaluate(Transaction *t, @@ -80,7 +79,6 @@ class User_DictElementRegexp : public Variable { t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion); } - Utils::Regex m_r; std::string m_dictElement; }; diff --git a/src/variables/user_id.h b/src/variables/user_id.h index 9393637e..ade04855 100644 --- a/src/variables/user_id.h +++ b/src/variables/user_id.h @@ -29,17 +29,9 @@ namespace modsecurity { class Transaction; namespace Variables { -class UserID : public Variable { - public: - UserID() - : Variable("USERID") { } - void evaluate(Transaction *transaction, - Rule *rule, - std::vector *l) { - transaction->m_variableUserID.evaluate(l); - } -}; +DEFINE_VARIABLE(UserID, USERID, m_variableUserID) + } // namespace Variables } // namespace modsecurity diff --git a/src/variables/variable.cc b/src/variables/variable.cc index 1320a4f1..6114d17f 100644 --- a/src/variables/variable.cc +++ b/src/variables/variable.cc @@ -30,10 +30,7 @@ namespace Variables { Variable::Variable(std::string name) : m_name(name), - m_collectionName(""), - m_isExclusion(false), - m_isCount(false), - m_regex("") { + m_collectionName("") { size_t a = m_name.find(":"); if (a == std::string::npos) { a = m_name.find("."); @@ -51,36 +48,50 @@ Variable::Variable(std::string name) } +Variable::Variable(Variable *var) : + m_name(var->m_name), + m_collectionName(var->m_collectionName), + m_fullName(var->m_fullName) { } +void Variable::addsKeyExclusion(Variable *v) { + std::unique_ptr r; + VariableModificatorExclusion *ve = \ + dynamic_cast(v); + VariableRegex *vr; -std::string Variable::to_s( - std::vector *variables) { - std::string ret; - std::string except(""); - for (int i = 0; i < variables->size() ; i++) { - VariableModificatorExclusion *e = - dynamic_cast(variables->at(i)); - if (e != NULL) { - if (except.empty()) { - except = except + *variables->at(i)->m_fullName.get(); - } else { - except = except + "|" + *variables->at(i)->m_fullName.get(); - } - continue; - } + if (!ve) { + return; + } - if (i == 0) { - ret = ret + *variables->at(i)->m_fullName.get(); + vr = dynamic_cast(ve->m_base.get()); + + if (vr == NULL) { + r.reset(new KeyExclusionString(v->m_name)); + } else { + r.reset(new KeyExclusionRegex(vr->m_regex)); + } + + m_keyExclusion.push_back(std::move(r)); +} + + +std::string operator+(std::string a, Variable *v) { + return *v->m_fullName.get(); +} + + +std::string operator+(std::string a, Variables *v) { + std::string test; + for (auto &b : *v) { + if (test.empty()) { + test = std::string("") + b; } else { - ret = ret + "|" + *variables->at(i)->m_fullName.get(); + test = test + "|" + b; } } - if (except.empty() == false) { - ret = ret + ", except for: " + except; - } - return ret; + return a + test; } diff --git a/src/variables/variable.h b/src/variables/variable.h index 89c97a45..091d0548 100644 --- a/src/variables/variable.h +++ b/src/variables/variable.h @@ -19,6 +19,7 @@ #include #include #include +#include #include "modsecurity/transaction.h" #include "modsecurity/rule.h" @@ -29,23 +30,96 @@ #ifndef SRC_VARIABLES_VARIABLE_H_ #define SRC_VARIABLES_VARIABLE_H_ +#define DEFINE_VARIABLE(n, N, e) \ + VAR_DIRECT(n, N, e) + +#define DEFINE_VARIABLE_DICT(n, N, e) \ + VAR_WITH_DICT_ELEMENT(n, N, e) \ + \ + VAR_WITHOUT_DICT_ELEMENT(n, N, e) \ + \ + VAR_WITH_REGEX(n, N, e) \ + + + +#define VAR_WITH_REGEX(n, N, e) \ +class n ## _DictElementRegexp : public VariableRegex { \ + public: \ + explicit n ## _DictElementRegexp(std::string regex) \ + : VariableRegex(#N, regex) { } \ +\ + void evaluate(Transaction *transaction, \ + Rule *rule, \ + std::vector *l) override { \ + transaction-> e .resolveRegularExpression(&m_r, l, \ + m_keyExclusion); \ + } \ +}; + + +#define VAR_WITH_DICT_ELEMENT(n, N, e) \ +class n ## _DictElement : public VariableDictElement { \ + public: \ + explicit n ## _DictElement(std::string dictElement) \ + : VariableDictElement(#N, dictElement) { } \ +\ + void evaluate(Transaction *transaction, \ + Rule *rule, \ + std::vector *l) override { \ + transaction-> e .resolve(m_dictElement, l); \ + } \ +}; + + +#define VAR_WITHOUT_DICT_ELEMENT(n, N, e) \ +class n ## _NoDictElement : public Variable { \ + public: \ + explicit n ## _NoDictElement() \ + : Variable(#N) { } \ +\ + void evaluate(Transaction *transaction, \ + Rule *rule, \ + std::vector *l) override { \ + transaction-> e .resolve(l, m_keyExclusion); \ + } \ +}; + + +#define VAR_DIRECT(n, N, e) \ +class n : public Variable { \ + public: \ + n() \ + : Variable(#N) { } \ + \ + void evaluate(Transaction *transaction, \ + Rule *rule, \ + std::vector *l) override { \ + transaction-> e .evaluate(l); \ + } \ +}; + + namespace modsecurity { class Transaction; namespace Variables { - class KeyExclusion { public: virtual bool match(std::string &a) = 0; + virtual ~KeyExclusion() { } }; // FIXME: use pre built regex. class KeyExclusionRegex : public KeyExclusion { public: - KeyExclusionRegex(std::string &re) - : m_re(re) { }; + explicit KeyExclusionRegex(Utils::Regex re) + : m_re(re.pattern) { } + explicit KeyExclusionRegex(std::string re) + : m_re(re) { } + + ~KeyExclusionRegex() override { } bool match(std::string &a) override { return m_re.searchAll(a).size() > 0; @@ -58,13 +132,16 @@ class KeyExclusionRegex : public KeyExclusion { class KeyExclusionString : public KeyExclusion { public: KeyExclusionString(std::string &a) - : m_key(utils::string::toupper(a)) { }; + : m_key(utils::string::toupper(a)) { } -bool match(std::string &a) override { - return a.size() == m_key.size() && std::equal(a.begin(), a.end(), m_key.begin(), - [](char aa, char bb) { - return (char) toupper(aa) == (char) bb; - }); + ~KeyExclusionString() override { } + + bool match(std::string &a) override { + return a.size() == m_key.size() && std::equal(a.begin(), a.end(), + m_key.begin(), + [](char aa, char bb) { + return static_cast(toupper(aa)) == static_cast(bb); + }); } std::string m_key; @@ -84,17 +161,8 @@ class KeyExclusions : public std::deque> { }; -class Variable { +class VariableMonkeyResolution { public: - explicit Variable(std::string _name); - virtual ~Variable() { } - - virtual void evaluate(Transaction *t, - Rule *rule, - std::vector *l) = 0; - - static std::string to_s(std::vector *variables); - static inline bool comp(const std::string &a, const std::string &b) { return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin(), @@ -103,34 +171,6 @@ class Variable { }); } - - bool inline belongsToCollection(Variable *var) { - return m_collectionName.size() == var->m_collectionName.size() - && std::equal(m_collectionName.begin(), m_collectionName.end(), var->m_collectionName.begin(), - [](char aa, char bb) { - return toupper(aa) == bb; - }); - } - - - void inline addsKeyExclusion(Variable *v) { - if (v->m_regex.empty()) { - std::unique_ptr r(new KeyExclusionString(v->m_name)); - m_keyExclusion.push_back(std::move(r)); - } else { - std::unique_ptr r(new KeyExclusionRegex(v->m_regex)); - m_keyExclusion.push_back(std::move(r)); - } - } - - - bool operator==(const Variable& b) { - return m_collectionName == b.m_collectionName && - m_name == b.m_name && - *m_fullName == *b.m_fullName; - } - - static void stringMatchResolveMulti(Transaction *t, const std::string &variable, std::vector *l) { @@ -498,44 +538,97 @@ class Variable { } return std::string(*vv.get()); } +}; + + +class Variable : public VariableMonkeyResolution { + public: + explicit Variable(std::string _name); + explicit Variable(Variable *_name); + virtual ~Variable() { } + + + virtual void evaluate(Transaction *t, + Rule *rule, + std::vector *l) = 0; + + + bool inline belongsToCollection(Variable *var) { + return m_collectionName.size() == var->m_collectionName.size() + && std::equal(m_collectionName.begin(), m_collectionName.end(), + var->m_collectionName.begin(), + [](char aa, char bb) { + return toupper(aa) == bb; + }); + } + + + void addsKeyExclusion(Variable *v); + + + bool operator==(const Variable& b) { + return m_collectionName == b.m_collectionName && + m_name == b.m_name && + *m_fullName == *b.m_fullName; + } + + + std::string& operator+=(const char * p) { return m_name; } + std::string m_name; std::string m_collectionName; std::shared_ptr m_fullName; - std::string m_regex; - KeyExclusions m_keyExclusion; +}; - bool m_isExclusion; - bool m_isCount; +class VariableDictElement : public Variable { + public: + VariableDictElement(std::string name, std::string dict_element) + : m_dictElement(dict_element), Variable(name + ":" + dict_element) { } + + std::string m_dictElement; +}; + + +class VariableRegex : public Variable { + public: + VariableRegex(std::string name, std::string regex) + : m_r(regex), + m_regex(regex), + Variable(name + ":" + "regex(" + regex + ")") { } + + // FIXME: no need for that. + std::string m_regex; + Utils::Regex m_r; +}; + +class Variables : public std::vector { + public: }; class VariableModificatorExclusion : public Variable { public: explicit VariableModificatorExclusion(std::unique_ptr var) - : Variable(*var->m_fullName.get()), - m_var(std::move(var)) { - m_isExclusion = true; - m_regex = m_var->m_regex; - } + : m_base(std::move(var)), Variable(var.get()) { } void evaluate(Transaction *t, Rule *rule, std::vector *l) { - m_var->evaluate(t, rule, l); + m_base->evaluate(t, rule, l); } - std::unique_ptr m_var; + std::unique_ptr m_base; }; class VariableModificatorCount : public Variable { public: explicit VariableModificatorCount(std::unique_ptr var) - : Variable(*var->m_fullName.get()), - m_var(std::move(var)) { - m_isCount = true; + : Variable(var.get()), + m_base(nullptr) { + m_base.reset(var.release()); } void evaluate(Transaction *t, @@ -545,7 +638,8 @@ class VariableModificatorCount : public Variable { VariableValue *val = NULL; int count = 0; - m_var->evaluate(t, rule, &reslIn); + m_base->evaluate(t, rule, &reslIn); + for (const VariableValue *a : reslIn) { count++; delete a; @@ -554,16 +648,21 @@ class VariableModificatorCount : public Variable { reslIn.clear(); std::string *res = new std::string(std::to_string(count)); - val = new VariableValue(m_var->m_fullName, res); + val = new VariableValue(m_fullName, res); delete res; l->push_back(val); return; } - std::unique_ptr m_var; + std::unique_ptr m_base; }; + +std::string operator+(std::string a, modsecurity::Variables::Variable *v); +std::string operator+(std::string a, modsecurity::Variables::Variables *v); + + } // namespace Variables } // namespace modsecurity diff --git a/test/optimization/optimization.cc b/test/optimization/optimization.cc index 0aab1ee1..ea8ac4c9 100644 --- a/test/optimization/optimization.cc +++ b/test/optimization/optimization.cc @@ -94,7 +94,7 @@ int main(int argc, char **argv) { key = op; } if (z->m_variables != NULL) { - std::string var = Variable::to_s(z->m_variables); + std::string var = std::string("") + z->m_variables; if (variables.count(var) > 0) { variables[var] = 1 + variables[var]; } else { @@ -119,7 +119,7 @@ int main(int argc, char **argv) { for (auto &z : operators) { auto &s = z.second; std::cout << " " << std::left << std::setw(20) << z.first; - std::cout << std::right << std::setw(4) << std::to_string(s); + std::cout << std::right << std::setw(4) << s; std::cout << std::endl; } @@ -127,14 +127,14 @@ int main(int argc, char **argv) { for (auto &z : variables) { auto &s = z.second; std::cout << " " << std::left << std::setw(20) << z.first; - std::cout << std::right << std::setw(4) << std::to_string(s); + std::cout << std::right << std::setw(4) << s; std::cout << std::endl; } std::cout << " Operators applied to variables" << std::endl; for (auto &z : op2var) { auto &s = z.second; std::cout << " " << std::left << std::setw(40) << z.first; - std::cout << std::right << std::setw(4) << std::to_string(s); + std::cout << std::right << std::setw(4) << s; std::cout << std::endl; }