Adds XML variable, xml body request processor and @validateSchema

src/operators/validate_schema.cc

@@ -18,26 +18,116 @@
 #include <string>
 
 #include "operators/operator.h"
+#include "request_body_processor/xml.h"
+#include "src/utils.h"
+
 
 namespace modsecurity {
 namespace operators {
 
-bool ValidateSchema::evaluate(Transaction *transaction,
-    const std::string &str) {
-    /**
-     * @todo Implement the operator ValidateSchema.
-     *       Reference: https://github.com/SpiderLabs/ModSecurity/wiki/Reference-Manual#validateSchema
-     */
+bool ValidateSchema::init(const std::string &file, const char **error) {
+    m_resource = find_resource(param, file);
+    if (m_resource == "") {
+        std::string f("XML: File not found: " + param + ".");
+        *error = strdup(f.c_str());
+        return false;
+    }
+
+    m_parserCtx = xmlSchemaNewParserCtxt(m_resource.c_str());
+    if (m_parserCtx == NULL) {
+        std::stringstream err;
+        err << "XML: Failed to load Schema from file: ";
+        err << m_resource;
+        err << ". ";
+        if (m_err.empty() == false) {
+            err << m_err;
+        }
+        *error = strdup(err.str().c_str());
+        return false;
+    }
+
+    xmlSchemaSetParserErrors(m_parserCtx,
+        (xmlSchemaValidityErrorFunc)error_load,
+        (xmlSchemaValidityWarningFunc)warn_load, &m_err);
+
+    xmlThrDefSetGenericErrorFunc(m_parserCtx,
+        null_error);
+
+    xmlSetGenericErrorFunc(m_parserCtx,
+        null_error);
+
+    m_schema = xmlSchemaParse(m_parserCtx);
+    if (m_schema == NULL) {
+        std::stringstream err;
+        err << "XML: Failed to load Schema: ";
+        err << m_resource;
+        err << ".";
+        if (m_err.empty() == false) {
+            err << " " << m_err;
+        }
+        *error = strdup(err.str().c_str());
+        xmlSchemaFreeParserCtxt(m_parserCtx);
+        return false;
+    }
+
+    m_validCtx = xmlSchemaNewValidCtxt(m_schema);
+    if (m_validCtx == NULL) {
+        std::stringstream err("XML: Failed to create validation context.");
+        if (m_err.empty() == false) {
+            err << " " << m_err;
+        }
+        *error = strdup(err.str().c_str());
+        return false;
+    }
+
     return true;
 }
 
 
-ValidateSchema::ValidateSchema(std::string op, std::string param,
-    bool negation)
-    : Operator() {
-    this->op = op;
-    this->param = param;
+bool ValidateSchema::evaluate(Transaction *t,
+    const std::string &str) {
+    int rc;
+
+    /* Send validator errors/warnings to msr_log */
+    xmlSchemaSetValidErrors(m_validCtx,
+        (xmlSchemaValidityErrorFunc)error_runtime,
+        (xmlSchemaValidityWarningFunc)warn_runtime, t);
+
+    if (t->m_xml->m_data.doc == NULL) {
+        t->debug(4, "XML document tree could not be found for " \
+            "schema validation.");
+        return true;
+    }
+
+    if (t->m_xml->m_data.well_formed != 1) {
+        t->debug(4, "XML: Schema validation failed because " \
+            "content is not well formed.");
+        return true;
+    }
+
+    /* Make sure there were no other generic processing errors */
+    /*
+    if (msr->msc_reqbody_error) {
+        t->debug(4, "XML: Schema validation could not proceed due to previous"
+                " processing errors.");
+        return true;
+    }
+    */
+
+    rc = xmlSchemaValidateDoc(m_validCtx, t->m_xml->m_data.doc);
+    if (rc != 0) {
+       t->debug(4, "XML: Schema validation failed.");
+        xmlSchemaFree(m_schema);
+        xmlSchemaFreeParserCtxt(m_parserCtx);
+        return true; /* No match. */
+    }
+
+    t->debug(4, "XML: Successfully validated payload against " \
+        "Schema: " + m_resource);
+
+    return false;
 }
 
+
 }  // namespace operators
 }  // namespace modsecurity

src/operators/validate_schema.h

@@ -16,6 +16,12 @@
 #ifndef SRC_OPERATORS_VALIDATE_SCHEMA_H_
 #define SRC_OPERATORS_VALIDATE_SCHEMA_H_
 
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xpath.h>
+
 #include <string>
 
 #include "operators/operator.h"
@@ -27,8 +33,100 @@ namespace operators {
 class ValidateSchema : public Operator {
  public:
     /** @ingroup ModSecurity_Operator */
-    ValidateSchema(std::string o, std::string p, bool i);
+    ValidateSchema(std::string o, std::string p, bool i)
+        : Operator(o, p, i),
+        m_schema(NULL),
+        m_validCtx(NULL),
+        m_parserCtx(NULL) { }
+    ~ValidateSchema() {
+        /*
+        if (m_schema != NULL) {
+            xmlSchemaFree(m_schema);
+            m_schema = NULL;
+        }
+        */
+        if (m_validCtx != NULL) {
+            xmlSchemaFreeValidCtxt(m_validCtx);
+            m_validCtx = NULL;
+        }
+    }
+
     bool evaluate(Transaction *transaction, const std::string  &str) override;
+    bool init(const std::string &file, const char **error) override;
+
+
+    static void error_load(void *ctx, const char *msg, ...) {
+        std::string *t = reinterpret_cast<std::string *>(ctx);
+        char buf[1024];
+        va_list args;
+
+        va_start(args, msg);
+        int len = vsnprintf(buf, sizeof(buf), msg, args);
+        va_end(args);
+
+        if (len > 0) {
+            t->append("XML Error: " + std::string(buf));
+        }
+    }
+
+
+    static void warn_load(void *ctx, const char *msg, ...) {
+        std::string *t = reinterpret_cast<std::string *>(ctx);
+        char buf[1024];
+        va_list args;
+
+        va_start(args, msg);
+        int len = vsnprintf(buf, sizeof(buf), msg, args);
+        va_end(args);
+
+        if (len > 0) {
+            t->append("XML Warning: " + std::string(buf));
+        }
+    }
+
+
+    static void error_runtime(void *ctx, const char *msg, ...) {
+        Transaction *t = reinterpret_cast<Transaction *>(ctx);
+        char buf[1024];
+        std::string s;
+        va_list args;
+
+        va_start(args, msg);
+        int len = vsnprintf(buf, sizeof(buf), msg, args);
+        va_end(args);
+
+        if (len > 0) {
+            s = "XML Error: " + std::string(buf);
+        }
+        t->debug(4, s);
+    }
+
+
+    static void warn_runtime(void *ctx, const char *msg, ...) {
+        Transaction *t = reinterpret_cast<Transaction *>(ctx);
+        char buf[1024];
+        std::string s;
+        va_list args;
+
+        va_start(args, msg);
+        int len = vsnprintf(buf, sizeof(buf), msg, args);
+        va_end(args);
+
+        if (len > 0) {
+            s = "XML Warning: " + std::string(buf);
+        }
+        t->debug(4, s);
+    }
+
+    static void null_error(void *ctx, const char *msg, ...) {
+    }
+
+ private:
+    xmlSchemaParserCtxtPtr m_parserCtx;
+    xmlSchemaValidCtxtPtr m_validCtx;
+    xmlSchemaPtr m_schema;
+    std::string m_resource;
+    std::string m_err;
 };
 
 }  // namespace operators