synapse 2.180.0__py311-none-any.whl → 2.181.0__py311-none-any.whl

synapse/lib/snap.py

@@ -1380,6 +1380,11 @@ class Snap(s_base.Base):
             mesg = 'The snapshot is in read-only mode.'
             raise s_exc.IsReadOnly(mesg=mesg)
 
+        if isinstance(valu, dict):
+            form = self.core.model.reqForm(name)
+            if isinstance(form.type, s_types.Guid):
+                return await self._addGuidNodeByDict(form, valu, props=props)
+
         async with self.getEditor() as editor:
             protonode = await editor.addNode(name, valu, props=props, norminfo=norminfo)
             if protonode is None:
@@ -1388,6 +1393,130 @@ class Snap(s_base.Base):
         # the newly constructed node is cached
         return await self.getNodeByBuid(protonode.buid)
 
+    async def _addGuidNodeByDict(self, form, vals, props=None):
+
+        norms = {}
+        counts = []
+        proplist = []
+
+        if props is None:
+            props = {}
+
+        trycast = vals.pop('$try', False)
+        addprops = vals.pop('$props', None)
+        if addprops is not None:
+            props.update(addprops)
+
+        try:
+            for name, valu in list(props.items()):
+                props[name] = form.reqProp(name).type.norm(valu)
+
+            for name, valu in vals.items():
+
+                prop = form.reqProp(name)
+                norm, norminfo = prop.type.norm(valu)
+
+                norms[name] = (prop, norm, norminfo)
+                proplist.append((name, norm))
+        except s_exc.BadTypeValu as e:
+            if not trycast: raise
+            mesg = e.errinfo.get('mesg')
+            await self.warn(f'Bad value for prop {name}: {mesg}')
+            return
+
+        proplist.sort()
+
+        # check first for an exact match via our same deconf strategy
+        iden = s_common.guid(proplist)
+
+        node = await self.getNodeByNdef((form.full, iden))
+        if node is not None:
+
+            # ensure we still match the property deconf criteria
+            for name, (prop, norm, info) in norms.items():
+                if not self._filtByPropAlts(node, prop, norm):
+                    break
+            else:
+                # ensure the non-deconf props are set
+                async with self.getEditor() as editor:
+                    proto = editor.loadNode(node)
+                    for name, (valu, info) in props.items():
+                        await proto.set(name, valu, norminfo=info)
+                return node
+
+        # TODO there is an opportunity here to populate
+        # a look-aside for the alternative iden to speed
+        # up future deconfliction and potentially pop them
+        # if we lookup a node and it no longer passes the
+        # filter...
+
+        # no exact match. lets do some counting.
+        for name, (prop, norm, info) in norms.items():
+            count = await self._getPropAltCount(prop, norm)
+            counts.append((count, prop, norm))
+
+        counts.sort(key=lambda x: x[0])
+
+        # lift starting with the lowest count
+        count, prop, norm = counts[0]
+        async for node in self._nodesByPropAlts(prop, norm):
+            await asyncio.sleep(0)
+
+            # filter on the remaining props/alts
+            for count, prop, norm in counts[1:]:
+                if not self._filtByPropAlts(node, prop, norm):
+                    break
+            else:
+                # ensure the non-deconf props are set
+                async with self.getEditor() as editor:
+                    proto = editor.loadNode(node)
+                    for name, (valu, info) in props.items():
+                        await proto.set(name, valu, norminfo=info)
+                return node
+
+        async with self.getEditor() as editor:
+            proto = await editor.addNode(form.name, iden)
+            for name, (prop, valu, info) in norms.items():
+                await proto.set(name, valu, norminfo=info)
+            for name, (valu, info) in props.items():
+                await proto.set(name, valu, norminfo=info)
+
+        return await self.getNodeByBuid(proto.buid)
+
+    async def _getPropAltCount(self, prop, valu):
+        count = 0
+        proptype = prop.type
+        for prop in prop.getAlts():
+            if prop.type.isarray and prop.type.arraytype == proptype:
+                count += await self.view.getPropArrayCount(prop.full, valu=valu)
+            else:
+                count += await self.view.getPropCount(prop.full, valu=valu)
+        return count
+
+    def _filtByPropAlts(self, node, prop, valu):
+        # valu must be normalized in advance
+        proptype = prop.type
+        for prop in prop.getAlts():
+            if prop.type.isarray and prop.type.arraytype == proptype:
+                if valu in node.get(prop.name):
+                    return True
+            else:
+                if node.get(prop.name) == valu:
+                    return True
+
+        return False
+
+    async def _nodesByPropAlts(self, prop, valu):
+        # valu must be normalized in advance
+        proptype = prop.type
+        for prop in prop.getAlts():
+            if prop.type.isarray and prop.type.arraytype == proptype:
+                async for node in self.nodesByPropArray(prop.full, '=', valu, norm=False):
+                    yield node
+            else:
+                async for node in self.nodesByPropValu(prop.full, '=', valu, norm=False):
+                    yield node
+
     async def addFeedNodes(self, name, items):
         '''
         Call a feed function and return what it returns (typically yields Node()s).

synapse/lib/storm.lark

@@ -97,9 +97,23 @@ YIELD.1: /yield(?=[\s\{])/
 
 // Split out case subqueries to prevent invalid state merging
 casesubquery: "{" query "}" -> baresubquery
-switchcase: "switch" _varvalu "{" ((DEFAULTCASE | DOUBLEQUOTEDSTRING | SINGLEQUOTEDSTRING | formatstring | CASEBARE) ":" casesubquery)* "}"
+_caseentry: DOUBLEQUOTEDSTRING | SINGLEQUOTEDSTRING | CASEBARE
+_mcaseentry: DOUBLEQUOTEDSTRING | SINGLEQUOTEDSTRING | MCASEBARE
+caseentry: (DEFAULTCASE | _caseentry | "(" _mcaseentry ("," _mcaseentry)+ ")") ":" casesubquery
+switchcase: "switch" _varvalu "{" caseentry* "}"
 DEFAULTCASE.2: "*"
-CASEBARE.2: /(?<=[\s{])(?!\*)([^:\s"']+)(?=[\s]*:[\s]*\{)/
+CASEBARE.2: /
+    (?<=[\s{])          # can follow whitespace or the opening curly brace of the switch statement
+    (?!\*)              # should not include the DEFAULTCASE bare asterisk
+    ([^:\s"'()]+)       # can be anything except these characters
+    (?=[\s]*:[\s]*\{)   # must precede a colon and the open brace of the subquery (with any whitespace in between)
+/x
+MCASEBARE.2: /
+    (?<=[\s(,])         # can follow whitespace, open parens, or comma
+    ([^:\s"'(),]+)      # can be anything except these characters
+    (?=\s*(?:,|\)\s*:)) # must precede a comma or a close parens with colon (with any whitespace in between)
+/x
+
 
 yieldvalu: YIELD _argvalu
 

synapse/lib/storm.py

@@ -5505,6 +5505,9 @@ class ScrapeCmd(Cmd):
         # Scrape only the :engine and :text props from the inbound nodes.
         inet:search:query | scrape :text :engine
 
+        # Scrape the primary property from the inbound nodes.
+        it:dev:str | scrape $node.repr()
+
         # Scrape properties inbound nodes and yield newly scraped nodes.
         inet:search:query | scrape --yield
 

synapse/lib/storm_format.py

@@ -52,6 +52,7 @@ TerminalPygMap = {
     'LISTTOKN': p_t.Literal.String,
     'LPAR': p_t.Punctuation,
     'LSQB': p_t.Punctuation,
+    'MCASEBARE': p_t.Literal.String,
     'MODSET': p_t.Operator,
     'NONQUOTEWORD': p_t.Literal,
     'NOT': p_t.Keyword,

synapse/lib/stormhttp.py

@@ -464,12 +464,28 @@ class LibHttp(s_stormtypes.Lib):
                     kwargs['json'] = json
 
                 async with sess.request(meth, url, headers=headers, **kwargs) as resp:
+                    history = []
+                    for hist in resp.history:
+                        hnfo = {
+                            'code': hist.status,
+                            'reason': await self.codereason(hist.status),
+                            'headers': dict(hist.headers),
+                            'url': str(hist.url),
+                            # aiohttp has already closed the connection by this point
+                            # so there is no connection to read a body from.
+                            'body': b'',
+                            'history': [],
+                            'request_headers': dict(hist.request_info.headers)
+                        }
+                        history.append(hnfo)
                     info = {
                         'code': resp.status,
                         'reason': await self.codereason(resp.status),
                         'headers': dict(resp.headers),
                         'url': str(resp.url),
                         'body': await resp.read(),
+                        'history': history,
+                        'request_headers': dict(resp.request_info.headers)
                     }
                     return HttpResp(info)
 
@@ -485,12 +501,14 @@ class LibHttp(s_stormtypes.Lib):
                     reason = f'Exception occurred during request: {err[0]}'
 
                 info = {
+                    'err': err,
                     'code': -1,
                     'reason': reason,
                     'headers': dict(),
                     'url': url,
                     'body': b'',
-                    'err': err,
+                    'history': [],
+                    'request_headers': dict(),
                 }
                 return HttpResp(info)
 
@@ -505,7 +523,13 @@ class HttpResp(s_stormtypes.Prim):
         {'name': 'reason', 'desc': 'The reason phrase for the HTTP status code.', 'type': 'str'},
         {'name': 'body', 'desc': 'The raw HTTP response body as bytes.', 'type': 'bytes', },
         {'name': 'headers', 'type': 'dict', 'desc': 'The HTTP Response headers.'},
+        {'name': 'request_headers', 'type': 'dict', 'desc': 'The HTTP Request headers.'},
+        {'name': 'url', 'type': 'str',
+         'desc': 'The response URL. If the request was redirected, this would be the final URL in the redirection chain. If the status code is -1, then this is the request URL.'},
         {'name': 'err', 'type': 'list', 'desc': 'Tuple of the error type and information if an exception occurred.'},
+        {'name': 'history', 'desc': 'A list of response objects representing the history of the response. This is populated when responses are redirected.',
+         'type': {'type': 'gtor', '_gtorfunc': '_gtorHistory',
+                  'returns': {'type': 'list', 'desc': 'A list of ``inet:http:resp`` objects.', }}},
         {'name': 'json', 'desc': 'Get the JSON deserialized response.',
          'type': {'type': 'function', '_funcname': '_httpRespJson',
                   'args': (
@@ -525,12 +549,18 @@ class HttpResp(s_stormtypes.Prim):
     def __init__(self, valu, path=None):
         super().__init__(valu, path=path)
         self.locls.update(self.getObjLocals())
+        self.locls['url'] = self.valu.get('url')
         self.locls['code'] = self.valu.get('code')
         self.locls['reason'] = self.valu.get('reason')
         self.locls['body'] = self.valu.get('body')
         self.locls['headers'] = self.valu.get('headers')
+        self.locls['request_headers'] = self.valu.get('request_headers')
         self.locls['err'] = self.valu.get('err', ())
 
+        self.gtors.update({
+            'history': self._gtorHistory,
+        })
+
     def getObjLocals(self):
         return {
             'json': self._httpRespJson,
@@ -561,3 +591,6 @@ class HttpResp(s_stormtypes.Prim):
         unpk = s_msgpack.Unpk()
         for _, item in unpk.feed(byts):
             yield item
+
+    async def _gtorHistory(self):
+        return [HttpResp(hnfo) for hnfo in self.valu.get('history')]

synapse/lib/stormlib/auth.py

@@ -877,7 +877,7 @@ class User(s_stormtypes.Prim):
         ''',
          'type': {'type': 'function', '_funcname': '_methUserSetRoles',
                   'args': (
-                      {'name': 'idens', 'type': 'list', 'desc': 'The idens to  of the Role.', },
+                      {'name': 'idens', 'type': 'list', 'desc': 'The idens of the Roles to set on the User.', },
                   ),
                   'returns': {'type': 'null', }}},
         {'name': 'revoke', 'desc': 'Remove a Role from the User',

synapse/lib/stormlib/cortex.py

@@ -1085,7 +1085,7 @@ class CortexHttpApi(s_stormtypes.Lib):
                       {'name': 'path', 'type': 'string',
                        'desc': 'The extended HTTP API path.'},
                       {'name': 'name', 'type': 'string',
-                       'desc': 'Friendly name for the Extended HTTP API', 'default': ''},
+                       'desc': 'Friendly name for the Extended HTTP API.', 'default': ''},
                       {'name': 'desc', 'type': 'string',
                        'desc': 'Description for the Extended HTTP API.', 'default': ''},
                       {'name': 'runas', 'type': 'string',
@@ -1095,6 +1095,8 @@ class CortexHttpApi(s_stormtypes.Lib):
                        'desc': 'Require the API endpoint to be authenticated.', 'default': True},
                       {'name': 'readonly', 'type': 'boolean',
                        'desc': 'Run the Extended HTTP Storm methods in readonly mode.', 'default': False},
+                      {'name': 'iden', 'type': 'str',
+                       'desc': 'An iden for the new Extended HTTP API.', 'default': None},
                   ),
                   'returns': {'type': 'http:api', 'desc': 'A new ``http:api`` object.'}}},
         {'name': 'del', 'desc': 'Delete an Extended HTTP API endpoint.',
@@ -1196,7 +1198,7 @@ class CortexHttpApi(s_stormtypes.Lib):
         apis = [HttpApi(self.runt, adef) for adef in adefs]
         return apis
 
-    async def addHttpApi(self, path, name='', desc='', runas='owner', authenticated=True, readonly=False):
+    async def addHttpApi(self, path, name='', desc='', runas='owner', authenticated=True, readonly=False, iden=None):
         s_stormtypes.confirm(('storm', 'lib', 'cortex', 'httpapi', 'add'))
 
         path = await s_stormtypes.tostr(path)
@@ -1207,6 +1209,7 @@ class CortexHttpApi(s_stormtypes.Lib):
         authenticated = await s_stormtypes.tobool(authenticated)
 
         adef = {
+            'iden': iden,
             'path': path,
             'view': self.runt.snap.view.iden,
             'runas': runas,

synapse/lib/stormlib/ipv6.py

@@ -1,11 +1,11 @@
 import logging
-import ipaddress
-
 
 import synapse.exc as s_exc
+import synapse.common as s_common
 
 import synapse.lib.stormtypes as s_stormtypes
 
+ipaddress = s_common.ipaddress
 logger = logging.getLogger(__name__)
 
 @s_stormtypes.registry.registerLib

synapse/lib/stormlib/model.py

@@ -3,6 +3,7 @@ import synapse.common as s_common
 
 import synapse.lib.node as s_node
 import synapse.lib.cache as s_cache
+import synapse.lib.layer as s_layer
 import synapse.lib.stormtypes as s_stormtypes
 
 import synapse.models.infotech as s_infotech
@@ -497,6 +498,7 @@ class ModelType(s_stormtypes.Prim):
     _storm_locals = (
         {'name': 'name', 'desc': 'The name of the Type.', 'type': 'str', },
         {'name': 'stortype', 'desc': 'The storetype of the Type.', 'type': 'int', },
+        {'name': 'opts', 'desc': 'The options for the Type.', 'type': 'dict', },
         {'name': 'repr', 'desc': 'Get the repr of a value for the Type.',
          'type': {'type': 'function', '_funcname': '_methRepr',
                   'args': (
@@ -516,6 +518,7 @@ class ModelType(s_stormtypes.Prim):
         s_stormtypes.Prim.__init__(self, valu, path=path)
         self.locls.update(self.getObjLocals())
         self.locls.update({'name': valu.name,
+                           'opts': valu.opts,
                            'stortype': valu.stortype,
                            })
 
@@ -756,6 +759,16 @@ class MigrationEditorMixin:
                 if overwrite or not proto.hasTagProp(tagname, propname):
                     await proto.setTagProp(tagname, propname, valu) # use tag perms
 
+    async def copyExtProps(self, src, proto):
+
+        form = src.form
+
+        for name, valu in src.props.items():
+            prop = form.props.get(name)
+            if not prop.isext:
+                continue
+
+            await proto.set(name, valu)
 
 @s_stormtypes.registry.registerLib
 class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
@@ -788,6 +801,13 @@ class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
                        'desc': 'Copy tag property value even if the property exists on the destination node.', },
                   ),
                   'returns': {'type': 'null', }}},
+        {'name': 'copyExtProps', 'desc': 'Copy extended properties from the src node to the dst node.',
+         'type': {'type': 'function', '_funcname': '_methCopyExtProps',
+                  'args': (
+                      {'name': 'src', 'type': 'node', 'desc': 'The node to copy extended props from.', },
+                      {'name': 'dst', 'type': 'node', 'desc': 'The node to copy extended props to.', },
+                  ),
+                  'returns': {'type': 'null', }}},
     )
     _storm_lib_path = ('model', 'migration')
 
@@ -796,6 +816,9 @@ class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
             'copyData': self._methCopyData,
             'copyEdges': self._methCopyEdges,
             'copyTags': self._methCopyTags,
+            'copyExtProps': self._methCopyExtProps,
+            'liftByPropValuNoNorm': self._methLiftByPropValuNoNorm,
+            'setNodePropValuNoNorm': self._methSetNodePropValuNoNorm,
         }
 
     async def _methCopyData(self, src, dst, overwrite=False):
@@ -839,6 +862,79 @@ class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
             proto = editor.loadNode(dst)
             await self.copyTags(src, proto, overwrite=overwrite)
 
+    async def _methCopyExtProps(self, src, dst):
+
+        if not isinstance(src, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyExtProps() source argument must be a node.')
+        if not isinstance(dst, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.copyExtProps() dest argument must be a node.')
+
+        snap = self.runt.snap
+
+        async with snap.getEditor() as editor:
+            proto = editor.loadNode(dst)
+            await self.copyExtProps(src, proto)
+
+    async def _methLiftByPropValuNoNorm(self, formname, propname, valu, cmpr='=', reverse=False):
+        '''
+        No storm docs for this on purpose. It is restricted for use during model migrations only.
+        '''
+        formname = await s_stormtypes.tostr(formname)
+        propname = await s_stormtypes.tostr(propname)
+        valu = await s_stormtypes.toprim(valu)
+
+        prop = self.runt.snap.core.model.prop(f'{formname}:{propname}')
+        if prop is None:
+            mesg = f'Could not find prop: {formname}:{propname}'
+            raise s_exc.NoSuchProp(mesg=mesg, formname=formname, propname=propname)
+
+        if not self.runt.snap.core.migration:
+            mesg = '$lib.model.migration.liftByPropValuNoNorm() is restricted to model migrations only.'
+            raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
+
+        stortype = prop.type.stortype
+
+        # Normally we'd call proptype.getStorCmprs() here to get the cmprvals
+        # but getStorCmprs() calls norm() which we're  trying to avoid so build
+        # cmprvals manually here.
+
+        if prop.type.isarray:
+            stortype &= (~s_layer.STOR_FLAG_ARRAY)
+            liftfunc = self.runt.snap.wlyr.liftByPropArray
+        else:
+            liftfunc = self.runt.snap.wlyr.liftByPropValu
+
+        cmprvals = ((cmpr, valu, stortype),)
+
+        layriden = self.runt.snap.wlyr.iden
+        async for _, buid, sode in liftfunc(formname, propname, cmprvals, reverse=reverse):
+            yield await self.runt.snap._joinStorNode(buid, {layriden: sode})
+
+    async def _methSetNodePropValuNoNorm(self, n, propname, valu):
+        '''
+        No storm docs for this on purpose. It is restricted for use during model migrations only.
+        '''
+
+        # NB: I'm sure there are all kinds of edges cases that this function doesn't account for. At the time of it's
+        # creation, this was intended to be used to update array properties with bad it:sec:cpe values in them. It works
+        # for that use case (see model migration 0.2.28). Any additional use of this function should perform heavy
+        # testing.
+
+        if not isinstance(n, s_node.Node):
+            raise s_exc.BadArg(mesg='$lib.model.migration.setNodePropValuNoNorm() argument must be a node.')
+
+        if not self.runt.snap.core.migration:
+            mesg = '$lib.model.migration.setNodePropValuNoNorm() is restricted to model migrations only.'
+            raise s_exc.AuthDeny(mesg=mesg, user=self.runt.user.iden, username=self.runt.user.name)
+
+        propname = await s_stormtypes.tostr(propname)
+        valu = await s_stormtypes.toprim(valu)
+
+        async with self.runt.snap.getNodeEditor(n) as proto:
+            await proto.set(propname, valu, norminfo={})
+
+        return n
+
 @s_stormtypes.registry.registerLib
 class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
     '''
@@ -980,10 +1076,15 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
     def getObjLocals(self):
         return {
             'itSecCpe_2_170_0': self._itSecCpe_2_170_0,
+            'itSecCpe_2_170_0_internal': self._itSecCpe_2_170_0_internal,
             'riskHasVulnToVulnerable': self._riskHasVulnToVulnerable,
         }
 
     async def _itSecCpe_2_170_0(self, n, prefer_v22=False, force=False):
+        info = await self._itSecCpe_2_170_0_internal(n, prefer_v22=prefer_v22, force=force, set_nodedata=True)
+        return info.get('status') == 'success'
+
+    async def _itSecCpe_2_170_0_internal(self, n, prefer_v22=False, force=False, set_nodedata=False):
 
         if not isinstance(n, s_node.Node):
             raise s_exc.BadArg(mesg='$lib.model.migration.s.itSecCpe_2_170_0() argument must be a node.')
@@ -1008,13 +1109,12 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
             if self.runt.debug:
                 mesg = f'DEBUG: itSecCpe_2_170_0({reprvalu}): Node already migrated.'
                 await self.runt.printf(mesg)
-            return True
+            return nodedata
 
         modl = self.runt.model.type('it:sec:cpe')
 
         valu23 = None
         valu22 = None
-        invalid = ''
 
         # Check the primary property for validity.
         cpe23 = s_infotech.cpe23_regex.match(curv)
@@ -1036,11 +1136,11 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                     mesg = f'DEBUG: itSecCpe_2_170_0({reprvalu}): Node is valid, no migration necessary.'
                     await self.runt.printf(mesg)
 
-                await proto.setData('migration.s.itSecCpe_2_170_0', {
-                    'status': 'success',
-                })
+                nodedata = {'status': 'success'}
+                if set_nodedata:
+                    await proto.setData('migration.s.itSecCpe_2_170_0', nodedata)
 
-                return True
+                return nodedata
 
             if valu23 is None and valu22 is None:
                 reason = 'Unable to migrate due to invalid data. Primary property and :v2_2 are both invalid.'
@@ -1049,12 +1149,14 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                 mesg = f'itSecCpe_2_170_0({reprvalu}): {reason}'
                 await self.runt.warn(mesg)
 
-                await proto.setData('migration.s.itSecCpe_2_170_0', {
+                nodedata = {
                     'status': 'failed',
                     'reason': reason,
-                })
+                }
+                if set_nodedata:
+                    await proto.setData('migration.s.itSecCpe_2_170_0', nodedata)
 
-                return False
+                return nodedata
 
             if prefer_v22:
                 valu = valu22 or valu23
@@ -1065,7 +1167,6 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
             norm, info = modl.norm(valu)
             subs = info.get('subs')
 
-            edits = []
             nodedata = {'status': 'success'}
 
             if norm != curv:
@@ -1097,7 +1198,8 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                 # Update the existing property with the re-normalized property value.
                 await proto.set(propname, subscurv, ignore_ro=True)
 
-            await proto.setData('migration.s.itSecCpe_2_170_0', nodedata)
+            if set_nodedata:
+                await proto.setData('migration.s.itSecCpe_2_170_0', nodedata)
 
             if self.runt.debug:
                 if nodedata.get('updated'):
@@ -1107,7 +1209,7 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                     mesg = f'DEBUG: itSecCpe_2_170_0({reprvalu}): No property updates required.'
                     await self.runt.printf(mesg)
 
-            return True
+            return nodedata
 
     async def _riskHasVulnToVulnerable(self, n, nodata=False):
 

synapse/lib/stormlib/project.py

@@ -847,7 +847,7 @@ class LibProjects(s_stormtypes.Lib):
                       {'name': 'name', 'type': 'str', 'desc': 'The name of the Project to get'},
                   ),
                   'returns': {'type': 'proj:project',
-                              'desc': 'The `proj:project `object, if it exists, otherwise null'}}},
+                              'desc': 'The project object, if it exists, otherwise null'}}},
 
         {'name': 'add', 'desc': 'Add a new project',
          'type': {'type': 'function', '_funcname': '_funcProjAdd',