Add a "warnings" member to Rules. (VirusTotal#208)

wxsBSD · web-flow · commit e14f096e3b9b · 2022-05-18T09:37:55.000+02:00
When compiling rules that have warnings currently the only way to know they have warnings is to specify error_on_warning=True to yara.compile(). This will throw an exception that you can then check the warnings member of, like this: ``` r = 'rule a { strings: $a = "a" condition: $a } rule b { strings: $b = "b" condition: $b }' try: rules = yara.compile(source=r, error_on_warning=True) except yara.WarningError as e: print(e.warnings) ``` This stops the compilation process, so if you're trying to just know if there are warnings but still run the rules there is no good way to do it without using the exception mechanism and then compiling the rules a second time (with error_on_warning not set). This patch adds a warnings member to the compiled Rules object, which is always set to a list of warning strings. If you want to error on warning you can still use error_on_warning=True in yara.compile() and get the normal behavior, but if you just want to compile and know if there are warnings you can now use this new member without having to compile a second time. Suggested by: Tom Lancaster Fixes: VirusTotal#207
diff --git a/tests.py b/tests.py
@@ -1132,6 +1132,31 @@ def testWarningCallback(self):
         self.assertTrue(warnings_callback_message.rule == "x")
         self.assertTrue(warnings_callback_message.string == "$x")
 
+    def testCompilerErrorOnWarning(self):
+        # Make sure we always throw on warnings if requested, and that warnings
+        # are accumulated.
+
+        rules = """
+        rule a { strings: $a = "A" condition: $a }
+        rule b { strings: $b = "B" condition: $b }
+        """
+
+        expected = [
+            'line 2: string "$a" may slow down scanning',
+            'line 3: string "$b" may slow down scanning',
+        ]
+
+        with self.assertRaises(yara.WarningError) as ctx:
+            yara.compile(source=rules, error_on_warning=True)
+
+        e = ctx.exception
+        self.assertListEqual(e.warnings, expected)
+
+        # Now make sure the warnings member is set if error_on_warning is not
+        # set.
+        rules = yara.compile(source=rules)
+        self.assertListEqual(rules.warnings, expected)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/yara-python.c b/yara-python.c
@@ -316,6 +316,7 @@ typedef struct
 {
   PyObject_HEAD
   PyObject* externals;
+  PyObject* warnings;
   YR_RULES* rules;
   YR_RULE* iter_current_rule;
 } Rules;
@@ -347,6 +348,17 @@ static PyObject* Rules_getattro(
 static PyObject* Rules_next(
     PyObject* self);
 
+static PyMemberDef Rules_members[] = {
+  {
+    "warnings",
+    T_OBJECT_EX,
+    offsetof(Rules, warnings),
+    READONLY,
+    "List of compiler warnings"
+  },
+  { NULL } // End marker
+};
+
 static PyMethodDef Rules_methods[] =
 {
   {
@@ -399,7 +411,7 @@ static PyTypeObject Rules_Type = {
   PyObject_SelfIter,          /* tp_iter */
   (iternextfunc) Rules_next,  /* tp_iternext */
   Rules_methods,              /* tp_methods */
-  0,                          /* tp_members */
+  Rules_members,              /* tp_members */
   0,                          /* tp_getset */
   0,                          /* tp_base */
   0,                          /* tp_dict */
@@ -1517,6 +1529,7 @@ static Rules* Rules_NEW(void)
   {
     rules->rules = NULL;
     rules->externals = NULL;
+    rules->warnings = NULL;
   }
 
   return rules;
@@ -1528,6 +1541,7 @@ static void Rules_dealloc(
   Rules* object = (Rules*) self;
 
   Py_XDECREF(object->externals);
+  Py_XDECREF(object->warnings);
 
   if (object->rules != NULL)
     yr_rules_destroy(object->rules);
@@ -2435,8 +2449,6 @@ static PyObject* yara_compile(
       PyErr_SetObject(YaraWarningError, warnings);
     }
 
-    Py_DECREF(warnings);
-
     if (PyErr_Occurred() == NULL)
     {
       rules = Rules_NEW();
@@ -2451,6 +2463,7 @@ static PyObject* yara_compile(
         {
           rules->rules = yara_rules;
           rules->iter_current_rule = rules->rules->rules_table;
+          rules->warnings = warnings;
 
           if (externals != NULL && externals != Py_None)
             rules->externals = PyDict_Copy(externals);
