github_mirrors/ModSecurity
3
0
Fork 1
mirror of https://github.com/owasp-modsecurity/ModSecurity.git synced 2025-08-13 13:26:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

Having a better organization for Variables::

Browse Source
This commit is contained in:
Felipe Zimmerle 2018-09-24 13:50:13 -03:00
parent ee50fea266
commit 98b9ae659d
No known key found for this signature in database
GPG Key ID: E6DFB08CE8B11277
91 changed files with 412 additions and 1681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
headers/modsecurity/rule.h
View File

@ -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::Variable *> *_variables,
Variables::Variables *_variables,
std::vector<actions::Action *> *_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<Variables::Variable *> *m_variables;
modsecurity::Variables::Variables *m_variables;
std::string m_ver;
private:

6
src/parser/seclang-parser.cc
View File

@ -2011,7 +2011,7 @@ namespace yy {
for (auto &i : *yystack_[0].value.as< std::unique_ptr<std::vector<std::unique_ptr<actions::Action> > > > ().get()) {
a->push_back(i.release());
}
std::vector<Variable *> *v = new std::vector<Variable *>();
Variables::Variables *v = new Variables::Variables();
for (auto &i : *yystack_[2].value.as< std::unique_ptr<std::vector<std::unique_ptr<Variable> > > > ().get()) {
v->push_back(i.release());
}
@ -2035,7 +2035,7 @@ namespace yy {
case 74:
#line 1121 "seclang-parser.yy" // lalr1.cc:856
{
std::vector<Variable *> *v = new std::vector<Variable *>();
Variables::Variables *v = new Variables::Variables();
for (auto &i : *yystack_[1].value.as< std::unique_ptr<std::vector<std::unique_ptr<Variable> > > > ().get()) {
v->push_back(i.release());
}
@ -2896,7 +2896,7 @@ namespace yy {
while (!originalList->empty()) {
std::unique_ptr<Variable> var = std::move(originalList->back());
originalList->pop_back();
if (var->m_isExclusion) {
if (dynamic_cast<VariableModificatorExclusion*>(var.get())) {
exclusionVars->push_back(std::move(var));
} else {
newList->push_back(std::move(var));

6
src/parser/seclang-parser.yy
View File

@ -1099,7 +1099,7 @@ expression:
for (auto &i : *$4.get()) {
a->push_back(i.release());
}
std::vector<Variable *> *v = new std::vector<Variable *>();
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<Variable *> *v = new std::vector<Variable *>();
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<Variable> var = std::move(originalList->back());
originalList->pop_back();
if (var->m_isExclusion) {
if (dynamic_cast<VariableModificatorExclusion*>(var.get())) {
exclusionVars->push_back(std::move(var));
} else {
newList->push_back(std::move(var));

19
src/rule.cc
View File

@ -70,7 +70,7 @@ Rule::Rule(std::string marker)
Rule::Rule(Operator *_op,
std::vector<Variable *> *_variables,
Variables::Variables *_variables,
std::vector<Action *> *actions,
std::string fileName,
int lineNumber)
@ -425,7 +425,7 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
std::list<std::string> exclusions_update_by_tag_remove;
std::list<std::string> exclusions_update_by_msg_remove;
std::list<std::string> exclusions_update_by_id_remove;
std::vector<Variables::Variable *> variables;
Variables::Variables variables;
std::vector<std::unique_ptr<VariableValue>> finalVars;
std::copy(m_variables->begin(), m_variables->end(),
@ -436,7 +436,8 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
if (containsTag(*a.first.get(), trans) == false) {
continue;
}
if (a.second->m_isExclusion) {
if (dynamic_cast<Variables::VariableModificatorExclusion*>(
a.second.get())) {
std::vector<const VariableValue *> z;
a.second->evaluate(trans, this, &z);
for (auto &y : z) {
@ -458,7 +459,8 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
if (containsMsg(*a.first.get(), trans) == false) {
continue;
}
if (a.second->m_isExclusion) {
if (dynamic_cast<Variables::VariableModificatorExclusion*>(
a.second.get())) {
std::vector<const VariableValue *> z;
a.second->evaluate(trans, this, &z);
for (auto &y : z) {
@ -480,7 +482,8 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
if (m_ruleId != a.first) {
continue;
}
if (a.second->m_isExclusion) {
if (dynamic_cast<Variables::VariableModificatorExclusion*>(
a.second.get())) {
std::vector<const VariableValue *> 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> ruleMessage) {
bool globalRet = false;
std::vector<Variable *> *variables = this->m_variables;
Variables::Variables *variables = this->m_variables;
bool recursiveGlobalRet;
bool containsBlock = false;
std::vector<std::unique_ptr<VariableValue>> 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
}

46
src/variables/args.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableArgs.resolveRegularExpression(&m_r, l,
m_keyExclusion);
}
Utils::Regex m_r;
};
DEFINE_VARIABLE_DICT(Args, ARGS, m_variableArgs)
} // namespace Variables

13
src/variables/args_combined_size.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableARGScombinedSize.evaluate(l);
}
};
DEFINE_VARIABLE(ArgsCombinedSize, ARGS_COMBINED_SIZE,
m_variableARGScombinedSize)
} // namespace Variables
} // namespace modsecurity

44
src/variables/args_get.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

42
src/variables/args_get_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableArgsGetNames.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
} // namespace Variables
} // namespace modsecurity

42
src/variables/args_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableArgsNames.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
} // namespace Variables
} // namespace modsecurity

44
src/variables/args_post.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

42
src/variables/args_post_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableArgsPostNames.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
} // namespace Variables
} // namespace modsecurity

12
src/variables/auth_type.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableAuthType.evaluate(l);
}
};
DEFINE_VARIABLE(AuthType, AUTH_TYPE, m_variableAuthType)
} // namespace Variables
} // namespace modsecurity

45
src/variables/files.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableFiles.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
DEFINE_VARIABLE_DICT(Files, FILES, m_variableFiles)
} // namespace Variables

13
src/variables/files_combined_size.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableFilesCombinedSize.evaluate(l);
}
};
DEFINE_VARIABLE(FilesCombinedSize, FILES_COMBINED_SIZE,
m_variableFilesCombinedSize)
} // namespace Variables
} // namespace modsecurity

46
src/variables/files_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

45
src/variables/files_sizes.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

46
src/variables/files_tmp_content.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

44
src/variables/files_tmp_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

12
src/variables/full_request.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableFullRequest.evaluate(l);
}
};
DEFINE_VARIABLE(FullRequest, FULL_REQUEST, m_variableFullRequest)
} // namespace Variables
} // namespace modsecurity

13
src/variables/full_request_length.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableFullRequestLength.evaluate(l);
}
};
DEFINE_VARIABLE(FullRequestLength, FULL_REQUEST_LENGTH,
m_variableFullRequestLength)
} // namespace Variables
} // namespace modsecurity

45
src/variables/geo.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableGeo.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
DEFINE_VARIABLE_DICT(Geo, GEO, m_variableGeo)
} // namespace Variables

6
src/variables/global.h
View File

@ -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;
};

12
src/variables/inbound_data_error.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableInboundDataError.evaluate(l);
}
};
DEFINE_VARIABLE(InboundDataError, INBOUND_DATA_ERROR, m_variableInboundDataError)
} // namespace Variables
} // namespace modsecurity

6
src/variables/ip.h
View File

@ -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;
};

12
src/variables/matched_var.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMatchedVar.evaluate(l);
}
};
DEFINE_VARIABLE(MatchedVar, MATCHED_VAR, m_variableMatchedVar)
} // namespace Variables
} // namespace modsecurity

12
src/variables/matched_var_name.h
View File

@ -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<const VariableValue *> *l) override {
transaction->m_variableMatchedVarName.evaluate(l);
}
};
DEFINE_VARIABLE(MatchedVarName, MATCHED_VAR_NAME, m_variableMatchedVarName)
} // namespace Variables
} // namespace modsecurity

45
src/variables/matched_vars.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

46
src/variables/matched_vars_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

13
src/variables/multipart_boundary_quoted.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartBoundaryQuoted.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartBoundaryQuoted, MULTIPART_BOUNDARY_QUOTED,
m_variableMultipartBoundaryQuoted)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_boundary_whitespace.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartBoundaryWhiteSpace.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartBoundaryWhiteSpace, MULTIPART_BOUNDARY_WHITESPACE,
m_variableMultipartBoundaryWhiteSpace)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_crlf_lf_lines.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartCrlfLFLines.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartCrlfLFLines, MULTIPART_CRLF_LF_LINES,
m_variableMultipartCrlfLFLines)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_data_after.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartDataAfter.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartDateAfter, MULTIPART_DATA_AFTER,
m_variableMultipartDataAfter)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_data_before.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartDataBefore.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartDateBefore, MULTIPART_DATA_BEFORE,
m_variableMultipartDataBefore)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_file_limit_exceeded.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartFileLimitExceeded.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartFileLimitExceeded, MULTIPART_FILE_LIMIT_EXCEEDED,
m_variableMultipartFileLimitExceeded)
} // namespace Variables
} // namespace modsecurity

46
src/variables/multipart_file_name.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

13
src/variables/multipart_header_folding.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartHeaderFolding.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartHeaderFolding, MULTIPART_HEADER_FOLDING,
m_variableMultipartHeaderFolding)
} // namespace Variables
} // namespace modsecurity

12
src/variables/multipart_invalid_header_folding.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartInvalidHeaderFolding.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartInvalidHeaderFolding, MULTIPART_INVALID_HEADER_FOLDING, m_variableMultipartInvalidHeaderFolding)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_invalid_part.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartInvalidPart.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartInvalidPart, MULTIPART_INVALID_PART,
m_variableMultipartInvalidHeaderFolding)
} // namespace Variables
} // namespace modsecurity

14
src/variables/multipart_invalid_quoting.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartInvalidQuoting.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartInvalidQuoting, MULTIPART_INVALID_QUOTING,
m_variableMultipartInvalidQuoting)
} // namespace Variables
} // namespace modsecurity

12
src/variables/multipart_lf_line.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartLFLine.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartLFLine, MULTIPART_LF_LINE, m_variableMultipartLFLine)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_missing_semicolon.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartMissingSemicolon.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartMissingSemicolon, MULTIPART_MISSING_SEMICOLON,
m_variableMultipartMissingSemicolon)
} // namespace Variables
} // namespace modsecurity

45
src/variables/multipart_name.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

13
src/variables/multipart_strict_error.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartStrictError.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartStrictError, MULTIPART_STRICT_ERROR,
m_variableMultipartStrictError)
} // namespace Variables
} // namespace modsecurity

13
src/variables/multipart_unmatched_boundary.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableMultipartUnmatchedBoundary.evaluate(l);
}
};
DEFINE_VARIABLE(MultipartUnmatchedBoundary, MULTIPART_UNMATCHED_BOUNDARY,
m_variableMultipartUnmatchedBoundary)
} // namespace Variables
} // namespace modsecurity

13
src/variables/outbound_data_error.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableOutboundDataError.evaluate(l);
}
};
DEFINE_VARIABLE(OutboundDataError, OUTBOUND_DATA_ERROR,
m_variableOutboundDataError)
} // namespace Variables
} // namespace modsecurity

12
src/variables/path_info.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variablePathInfo.evaluate(l);
}
};
DEFINE_VARIABLE(PathInfo, PATH_INFO, m_variablePathInfo)
} // namespace Variables
} // namespace modsecurity

12
src/variables/query_string.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableQueryString.evaluate(l);
}
};
DEFINE_VARIABLE(QueryString, QUERY_STRING, m_variableQueryString)
} // namespace Variables
} // namespace modsecurity

12
src/variables/remote_addr.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRemoteAddr.evaluate(l);
}
};
DEFINE_VARIABLE(RemoteAddr, REMOTE_ADDR, m_variableRemoteAddr)
} // namespace Variables
} // namespace modsecurity

12
src/variables/remote_host.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRemoteHost.evaluate(l);
}
};
DEFINE_VARIABLE(RemoteHost, REMOTE_HOST, m_variableRemoteHost)
} // namespace Variables
} // namespace modsecurity

12
src/variables/remote_port.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRemotePort.evaluate(l);
}
};
DEFINE_VARIABLE(RemotePort, REMOTE_PORT, m_variableRemotePort)
} // namespace Variables
} // namespace modsecurity

12
src/variables/reqbody_error.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableReqbodyError.evaluate(l);
}
};
DEFINE_VARIABLE(ReqbodyError, REQBODY_ERROR, m_variableReqbodyError)
} // namespace Variables
} // namespace modsecurity

13
src/variables/reqbody_error_msg.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableReqbodyErrorMsg.evaluate(l);
}
};
DEFINE_VARIABLE(ReqbodyErrorMsg, REQBODY_ERROR_MSG, m_variableReqbodyErrorMsg)
} // namespace Variables
} // namespace modsecurity

13
src/variables/reqbody_processor.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableReqbodyProcessor.evaluate(l);
}
};
DEFINE_VARIABLE(ReqbodyProcessor, REQBODY_PROCESSOR, m_variableReqbodyProcessor)
} // namespace Variables
} // namespace modsecurity

13
src/variables/reqbody_processor_error.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableReqbodyProcessorError.evaluate(l);
}
};
DEFINE_VARIABLE(ReqbodyProcessorError, REQBODY_PROCESSOR_ERROR,
m_variableReqbodyProcessorError)
} // namespace Variables
} // namespace modsecurity

13
src/variables/reqbody_processor_error_msg.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableReqbodyProcessorErrorMsg.evaluate(l);
}
};
DEFINE_VARIABLE(ReqbodyProcessorErrorMsg, PROCESSOR_ERROR_MSG,
m_variableReqbodyProcessorErrorMsg)
} // namespace Variables
} // namespace modsecurity

12
src/variables/request_base_name.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestBasename.evaluate(l);
}
};
DEFINE_VARIABLE(RequestBasename, REQUEST_BASENAME, m_variableRequestBasename)
} // namespace Variables
} // namespace modsecurity

13
src/variables/request_body.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestBody.evaluate(l);
}
};
DEFINE_VARIABLE(RequestBody, REQUEST_BODY, m_variableRequestBody)
} // namespace Variables
} // namespace modsecurity

14
src/variables/request_body_length.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestBodyLength.evaluate(l);
}
};
DEFINE_VARIABLE(RequestBodyLength, REQUEST_BODY_LENGTH,
m_variableRequestBodyLength)
} // namespace Variables
} // namespace modsecurity

47
src/variables/request_cookies.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

46
src/variables/request_cookies_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

13
src/variables/request_file_name.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestFilename.evaluate(l);
}
};
DEFINE_VARIABLE(RequestFilename, REQUEST_FILENAME, m_variableRequestFilename)
} // namespace Variables
} // namespace modsecurity

45
src/variables/request_headers.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

43
src/variables/request_headers_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableRequestHeadersNames.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
} // namespace Variables
} // namespace modsecurity

13
src/variables/request_line.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestLine.evaluate(l);
}
};
DEFINE_VARIABLE(RequestLine, REQUEST_LINE, m_variableRequestLine)
} // namespace Variables
} // namespace modsecurity

13
src/variables/request_method.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestMethod.evaluate(l);
}
};
DEFINE_VARIABLE(RequestMethod, REQUEST_METHOD, m_variableRequestMethod)
} // namespace Variables
} // namespace modsecurity

13
src/variables/request_protocol.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestProtocol.evaluate(l);
}
};
DEFINE_VARIABLE(RequestProtocol, REQUEST_PROTOCOL, m_variableRequestProtocol)
} // namespace Variables
} // namespace modsecurity

13
src/variables/request_uri.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestURI.evaluate(l);
}
};
DEFINE_VARIABLE(RequestURI, REQUEST_URI, m_variableRequestURI)
} // namespace Variables
} // namespace modsecurity

13
src/variables/request_uri_raw.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableRequestURIRaw.evaluate(l);
}
};
DEFINE_VARIABLE(RequestURIRaw, REQUEST_URI_RAW, m_variableRequestURIRaw)
} // namespace Variables
} // namespace modsecurity

6
src/variables/resource.h
View File

@ -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;
};

13
src/variables/response_body.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableResponseBody.evaluate(l);
}
};
DEFINE_VARIABLE(ResponseBody, RESPONSE_BODY, m_variableResponseBody)
} // namespace Variables
} // namespace modsecurity

14
src/variables/response_content_length.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableResponseContentLength.evaluate(l);
}
};
DEFINE_VARIABLE(ResponseContentLength, RESPONSE_CONTENT_LENGTH,
m_variableResponseContentLength)
} // namespace Variables
} // namespace modsecurity

14
src/variables/response_content_type.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableResponseContentType.evaluate(l);
}
};
DEFINE_VARIABLE(ResponseContentType, RESPONSE_CONTENT_TYPE,
m_variableResponseContentType)
} // namespace Variables
} // namespace modsecurity

46
src/variables/response_headers.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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

43
src/variables/response_headers_names.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableResponseHeadersNames.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
} // namespace Variables
} // namespace modsecurity

13
src/variables/response_protocol.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableResponseProtocol.evaluate(l);
}
};
DEFINE_VARIABLE(ResponseProtocol, RESPONSE_PROTOCOL, m_variableResponseProtocol)
} // namespace Variables
} // namespace modsecurity

13
src/variables/response_status.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableResponseStatus.evaluate(l);
}
};
DEFINE_VARIABLE(ResponseStatus, RESPONSE_STATUS, m_variableResponseStatus)
} // namespace Variables
} // namespace modsecurity

44
src/variables/rule.h
View File

@ -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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *l) override {
transaction->m_variableRule.resolveRegularExpression(
&m_r, l, m_keyExclusion);
}
Utils::Regex m_r;
};
} // namespace Variables
} // namespace modsecurity

12
src/variables/server_addr.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableServerAddr.evaluate(l);
}
};
DEFINE_VARIABLE(ServerAddr, SERVER_ADDR, m_variableServerAddr)
} // namespace Variables
} // namespace modsecurity

12
src/variables/server_name.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableServerName.evaluate(l);
}
};
DEFINE_VARIABLE(ServerName, SERVER_NAME, m_variableServerName)
} // namespace Variables
} // namespace modsecurity

12
src/variables/server_port.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableServerPort.evaluate(l);
}
};
DEFINE_VARIABLE(ServerPort, SERVER_PORT, m_variableServerPort)
} // namespace Variables
} // namespace modsecurity

6
src/variables/session.h
View File

@ -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;
};

11
src/variables/session_id.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableSessionID.evaluate(l);
}
};
} // namespace Variables
} // namespace modsecurity

12
src/variables/status.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableResponseStatus.evaluate(l);
}
};
DEFINE_VARIABLE(Status, STATUS, m_variableResponseStatus)
} // namespace Variables
} // namespace modsecurity

6
src/variables/tx.h
View File

@ -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;
};

12
src/variables/unique_id.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableUniqueID.evaluate(l);
}
};
DEFINE_VARIABLE(UniqueID, UNIQUEID, m_variableUniqueID)
} // namespace Variables
} // namespace modsecurity

12
src/variables/url_encoded_error.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableUrlEncodedError.evaluate(l);
}
};
DEFINE_VARIABLE(UrlEncodedError, URLENCODED_ERROR, m_variableUrlEncodedError)
} // namespace Variables
} // namespace modsecurity

6
src/variables/user.h
View File

@ -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;
};

12
src/variables/user_id.h
View File

@ -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<const VariableValue *> *l) {
transaction->m_variableUserID.evaluate(l);
}
};
DEFINE_VARIABLE(UserID, USERID, m_variableUserID)
} // namespace Variables
} // namespace modsecurity

63
src/variables/variable.cc
View File

@ -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<KeyExclusion> r;
VariableModificatorExclusion *ve = \
dynamic_cast<VariableModificatorExclusion *>(v);
VariableRegex *vr;
std::string Variable::to_s(
std::vector<Variable *> *variables) {
std::string ret;
std::string except("");
for (int i = 0; i < variables->size() ; i++) {
VariableModificatorExclusion *e =
dynamic_cast<VariableModificatorExclusion *>(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<VariableRegex *>(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;
}

227
src/variables/variable.h
View File

@ -19,6 +19,7 @@
#include <string>
#include <utility>
#include <vector>
#include <deque>
#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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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<const VariableValue *> *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<char>(toupper(aa)) == static_cast<char>(bb);
});
}
std::string m_key;
@ -84,17 +161,8 @@ class KeyExclusions : public std::deque<std::unique_ptr<KeyExclusion>> {
};
class Variable {
class VariableMonkeyResolution {
public:
explicit Variable(std::string _name);
virtual ~Variable() { }
virtual void evaluate(Transaction *t,
Rule *rule,
std::vector<const VariableValue *> *l) = 0;
static std::string to_s(std::vector<Variable *> *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<KeyExclusion> r(new KeyExclusionString(v->m_name));
m_keyExclusion.push_back(std::move(r));
} else {
std::unique_ptr<KeyExclusion> 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<const VariableValue *> *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<const VariableValue *> *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<std::string> 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<Variable *> {
public:
};
class VariableModificatorExclusion : public Variable {
public:
explicit VariableModificatorExclusion(std::unique_ptr<Variable> 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<const VariableValue *> *l) {
m_var->evaluate(t, rule, l);
m_base->evaluate(t, rule, l);
}
std::unique_ptr<Variable> m_var;
std::unique_ptr<Variable> m_base;
};
class VariableModificatorCount : public Variable {
public:
explicit VariableModificatorCount(std::unique_ptr<Variable> 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<Variable> m_var;
std::unique_ptr<Variable> 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

8
test/optimization/optimization.cc
View File

@ -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;
}