Patch to matrix_gen to fix revoked status issue, minor patches to

spacing/alignment

Author: clittle

layers/exporters/matrix_gen.py

@@ -109,6 +109,20 @@ def __init__(self, source='taxii', local=None):
         self.matrix = {}
         self._build_matrix()
 
+    @staticmethod
+    def _remove_revoked_deprecated(content):
+        """Remove any revoked or deprecated objects from queries made to the data source"""
+        return list(
+            filter(
+                lambda x: x.get("x_mitre_deprecated", False) is False and x.get("revoked", False) is False,
+                content
+            )
+        )
+
+    def _search(self, domain, query):
+        interum = self.collections[domain].query(query)
+        return self._remove_revoked_deprecated(interum)
+
     def _get_tactic_listing(self, domain='enterprise'):
         """
             INTERNAL - retrieves tactics for the associated domain
@@ -117,11 +131,11 @@ def _get_tactic_listing(self, domain='enterprise'):
         """
         tactics = {}
         t_filt = []
-        matrix = self.collections[domain].query([Filter('type', '=', 'x-mitre-matrix')])
+        matrix = self._search(domain, [Filter('type', '=', 'x-mitre-matrix')])
         for i in range(len(matrix)):
             tactics[matrix[i]['name']] = []
             for tactic_id in matrix[i]['tactic_refs']:
-                tactics[matrix[i]['name']].append(self.collections[domain].query([Filter('id', '=', tactic_id)])[0])
+                tactics[matrix[i]['name']].append(self._search(domain,([Filter('id', '=', tactic_id)]))[0])
         for entry in tactics[matrix[0]['name']]:
             self.convert_data[entry['x_mitre_shortname']] = entry['name']
             self.convert_data[entry['name']] = entry['x_mitre_shortname']
@@ -137,7 +151,8 @@ def _get_technique_listing(self, tactic, domain='enterprise'):
         """
         techniques = []
         subtechs = {}
-        techs = self.collections[domain].query([Filter('type', '=', 'attack-pattern'), Filter('kill_chain_phases.phase_name', '=', tactic)])
+        techs = self._search(domain,[Filter('type', '=', 'attack-pattern'),
+                                     Filter('kill_chain_phases.phase_name', '=', tactic)])
         for entry in techs:
             if entry['kill_chain_phases'][0]['kill_chain_name'] == 'mitre-attack' or \
                             entry['kill_chain_phases'][0]['kill_chain_name'] == 'mitre-mobile-attack':

layers/exporters/svg_objects.py

@@ -135,6 +135,9 @@ def _optimalFontSize(st, width, height, maxFontSize=12):
         num_breaks = 2
     elif num_spaces < 50:
         num_breaks = 3
+
+    if _findSpace([st], width, height, maxFontSize) == maxFontSize:
+        return maxFontSize, [st]
     breaks = _find_breaks(num_spaces, num_breaks)
     for binaryString in breaks:
         wordSet = []
@@ -152,8 +155,8 @@ def _optimalFontSize(st, width, height, maxFontSize=12):
         if size > bestSize:
             bestSize = size
             bestWordArrangement = wordSet
-        if size == maxFontSize:
-            break
+        #if size == maxFontSize:
+        #    break
 
     return bestSize, bestWordArrangement
 
@@ -257,24 +260,28 @@ def build(height, width, label, config, variant='text', t1text=None, t2text=None
             upper = G(tx=0, ty=2.1)
             internal.append(upper)
             if t1text is not None:
-                fs, patch_text = _optimalFontSize(t1text, width, (height-5)/2, maxFontSize=28)
+                bu = t2text is not None and t2text is not ""
+                theight = (height-5)
+                if bu:
+                    theight = theight / 2
+                fs, patch_text = _optimalFontSize(t1text, width, theight, maxFontSize=28)
                 lines = len(patch_text)
-                y = (height-5)/4 + 2.1
+                y = theight/2 + 2.1
                 if lines > 1:
-                    y = y - (((height-5)/16) * (lines-1))
+                    y = y - (theight / 5 * (lines-1))
                 t1 = Text("\n".join(patch_text), fs, '', x=4, y=y)
                 upper.append(t1)
-                upper.append(Line(0, width-10, (height-5)/2, (height-5)/2, stroke='#dddddd'))
-                if t2text is not None and t2text is not "":
+                if bu:
+                    upper.append(Line(0, width - 10, theight, theight, stroke='#dddddd'))
                     upper_fs = fs
-                    lower_offset = ((height-5)/2 + 2.1)
+                    lower_offset = (theight + 2.1)
                     lower = G(tx=0, ty= lower_offset)
                     fs, patch_text = _optimalFontSize(t2text, width, (height - (height/3 + upper_fs)), maxFontSize=28)
-                    y = (height-5)/4 + 2.1
+                    y = theight / 2 + 2.1
                     lines = len(patch_text)
                     adju = "\n".join(patch_text)
                     if lines > 1:
-                        y = y - (((height - 5) / 16) * (lines - 1))
+                        y = y - ((theight / 5) * (lines - 1))
                     if float(fs) > lower_offset:
                         y = y + 2*(float(fs) - lower_offset)
                     t2 = Text(adju, fs, '', x=4, y=y)

layers/exporters/svg_templates.py

@@ -60,7 +60,6 @@ def _build_headers(self, name, config, desc=None, filters=None, gradient=None):
         psych = 0
         overlay = None
         if config.showHeader:
-            operation_x = max_x - 30
 
             root = G(tx=5, ty=5, style='font-family: {}'.format(ff))
 
@@ -74,11 +73,12 @@ def _build_headers(self, name, config, desc=None, filters=None, gradient=None):
                 header_count += 1
             if config.showFilters:
                 header_count += 1
-            if config.showLegend and config.legendDocked:
+            if config.showLegend and gradient is not False and config.legendDocked:
                 header_count += 1
 
+            operation_x = (max_x - 10) - (15 * (header_count - 1))
             if header_count > 0:
-                header_width = max_x / header_count - (15 * (header_count-1))
+                header_width = operation_x / header_count
                 if config.showAbout:
                     if desc is not None:
                         g = SVG_HeaderBlock().build(height=header_height, width=header_width, label='about', t1text=name,
@@ -96,11 +96,11 @@ def _build_headers(self, name, config, desc=None, filters=None, gradient=None):
                         fi.stages = ["act"]
                     g2 = SVG_HeaderBlock().build(height=header_height, width=header_width, label='filters',
                                              t1text=', '.join(fi.platforms), t2text=fi.stages[0], config=config)
-                    b2 = G(tx=operation_x / header_count * psych + 20 * psych)
+                    b2 = G(tx=operation_x / header_count * psych + 15 * psych)
                     header.append(b2)
                     b2.append(g2)
                     psych += 1
-                if config.showLegend:
+                if config.showLegend and gradient is not False:
                     gr = gradient
                     if gr is None:
                         gr = Gradient(colors=["#ff6666","#ffe766","#8ec843"], minValue=1, maxValue=100)
@@ -111,7 +111,7 @@ def _build_headers(self, name, config, desc=None, filters=None, gradient=None):
                             (gr.compute_color(int(gr.minValue + div * i)), gr.minValue + div * i))
                     colors.append((gr.compute_color(gr.maxValue), gr.maxValue))
                     if config.legendDocked:
-                        b3 = G(tx=operation_x / header_count * psych + 20 * psych)
+                        b3 = G(tx=operation_x / header_count * psych + 15 * psych)
                         g3 = SVG_HeaderBlock().build(height=header_height, width=header_width, label='legend',
                                                      variant='graphic', colors=colors, config=config)
                         header.append(b3)
@@ -149,7 +149,7 @@ def get_tactic(self, tactic, height, width, config, colors=[], scores=[], subtec
             :param subtechs: List of visible subtechniques
             :param exclude: List of excluded techniques
             :param mode: Tuple describing text for techniques (Show Name, Show ID)
-            :return: Instantiated tactic column
+            :return: Instantiated tactic column (or none if no techniques were found)
         """
         offset = 0
         column = G(ty=2)
@@ -172,6 +172,8 @@ def get_tactic(self, tactic, height, width, config, colors=[], scores=[], subtec
                 a, offset = self.get_tech(offset, mode, x, tactic=self.h.convert(tactic.tactic.name),
                                           subtechniques=[], colors=colors, config=config, height=height, width=width)
             column.append(a)
+        if len(column.children) == 0:
+            return None
         return column
 
     def get_tech(self, offset, mode, technique, tactic, config, height, width, subtechniques=[], colors=[]):
@@ -209,30 +211,33 @@ def export(self, showName, showID, lhandle, config, sort=0, scores=[], colors=[]
             :param exclude: List of excluded techniques
             :return:
         """
+        grad = False
+        if len(scores):
+            grad = lhandle.gradient
         d, presence, overlay = self._build_headers(lhandle.name, config, lhandle.description, lhandle.filters,
-                                            lhandle.gradient)
+                                            grad)
         self.codex = self.h._adjust_ordering(self.codex, sort, scores)
         self.lhandle = lhandle
         glob = G()
         index = 5
         lengths = []
         for x in self.codex:
-            sum = len(x.techniques)
+            su = len(x.techniques)
             for enum in exclude:
                 if enum[0] in [y.id for y in x.techniques]:
                     if self.h.convert(enum[1]) == x.tactic.name or enum[1] == False:
-                        sum -= 1
+                        su -= 1
             for y in x.subtechniques:
                 if y in [z[0] for z in subtechs]:
-                    sum += len(x.subtechniques[y])
-            lengths.append(sum)
-        tech_width = (convertToPx(config.width, config.unit) / len(self.codex)) - 10
+                    su += len(x.subtechniques[y])
+            lengths.append(su)
+        tech_width = (convertToPx(config.width, config.unit) / sum([1 for x in lengths if x > 0])) - 10
         header_offset = convertToPx(config.headerHeight, config.unit)
         if presence == 0:
             header_offset = 0
-        header_offset += 30
+        header_offset += 15
         tech_height = (convertToPx(config.height, config.unit) - header_offset -
-                       convertToPx(config.border, config.unit)) / max(lengths)
+                       convertToPx(config.border, config.unit)) / (max(lengths) + 1)
         incre = tech_width + 10
         for x in self.codex:
             disp = ''
@@ -245,16 +250,19 @@ def export(self, showName, showID, lhandle, config, sort=0, scores=[], colors=[]
 
             g = G(tx=index, ty=header_offset)
 
-            index += incre
-            fs, _ = _optimalFontSize(disp, tech_width, tech_height+10, maxFontSize=28)
+            fs, _ = _optimalFontSize(disp, tech_width, tech_height, maxFontSize=28)
             tx = Text(ctype='TacticName', font_size=fs, text=disp, position='middle')
-            gt = G(tx=(tech_width)/2)
+            gt = G(tx=(tech_width)/2, ty=(tech_height)/2)
             gt.append(tx)
             a = self.get_tactic(x, tech_height, tech_width, colors=colors, subtechs=subtechs, exclude=exclude,
                                 mode=(showName, showID), scores=scores, config=config)
+            b = G(ty=tech_height)
             g.append(gt)
-            g.append(a)
-            glob.append(g)
+            b.append(a)
+            g.append(b)
+            if a:
+                glob.append(g)
+                index += incre
         d.append(glob)
         if overlay:
             d.append(overlay)