synapse 2.211.0__py311-none-any.whl → 2.213.0__py311-none-any.whl

synapse/lib/cell.py

@@ -3495,13 +3495,16 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
                         await user.addRule(rule)
 
     @contextlib.asynccontextmanager
-    async def getLocalProxy(self, share='*', user='root'):
+    async def getLocalProxy(self, share=None, user='root'):
         url = self.getLocalUrl(share=share, user=user)
         prox = await s_telepath.openurl(url)
         yield prox
 
-    def getLocalUrl(self, share='*', user='root'):
-        return f'cell://{user}@{self.dirn}:{share}'
+    def getLocalUrl(self, share=None, user='root'):
+        url = f'cell://{user}@{self.dirn}'
+        if share is not None:
+            url = f'{url}:{share}'
+        return url
 
     def _initCellConf(self, conf):
         '''

synapse/lib/node.py

@@ -207,8 +207,13 @@ class Node:
 
             embdnode = retn.get(nodepath)
             if embdnode is None:
-                embdnode = retn[nodepath] = {}
-                embdnode['*'] = s_common.ehex(node.buid)
+                iden = node.iden()
+                # TODO deprecate / remove use of * once we can minver optic
+                embdnode = retn[nodepath] = {
+                    '*': iden,
+                    '$iden': iden,
+                    '$form': node.form.name,
+                }
 
             for relp in relprops:
                 embdnode[relp] = node.props.get(relp)

synapse/lib/scrape.py

@@ -65,6 +65,8 @@ inverse_prefixs = {
     '<': '>',
     '{': '}',
     '(': ')',
+    '\u2018': '\u2019',  # Unicode Left Single Quotation Mark and Right Single Quotation Mark
+    '\u201c': '\u201d',  # Unicode Left Double Quotation Mark and Right Double Quotation Mark
 }
 
 cve_dashes = ''.join(('-',) + s_chop.unicode_dashes)
@@ -287,7 +289,7 @@ def url_scheme_check(match: regex.Match):
 scrape_types = [  # type: ignore
     ('file:path', linux_path_regex, {'callback': linux_path_check, 'flags': regex.VERBOSE}),
     ('file:path', windows_path_regex, {'callback': windows_path_check, 'flags': regex.VERBOSE}),
-    ('inet:url', r'(?P<prefix>[\\{<\(\[]?)(?P<valu>[a-zA-Z][a-zA-Z0-9]*://(?(?=[,.]+[ \'\"\t\n\r\f\v])|[^ \'\"\t\n\r\f\v])+)',
+    ('inet:url', r'(?P<prefix>[‘“\\{<\(\[]?)(?P<valu>[a-zA-Z][a-zA-Z0-9]*://(?(?=[,.]+[ \'\"\t\n\r\f\v])|[^ \'\"\t\n\r\f\v])+)',
      {'callback': url_scheme_check}),
     ('inet:url', r'(["\'])?(?P<valu>\\[^\n]+?)(?(1)\1|\s)', {'callback': unc_path_check}),
     ('inet:email', r'(?=(?:[^a-z0-9_.+-]|^)(?P<valu>[a-z0-9_\.\-+]{1,256}@(?:[a-z0-9_-]{1,63}\.){1,10}(?:%s))(?:[^a-z0-9_.-]|[.\s]|$))' % tldcat, {}),

synapse/lib/snap.py

@@ -746,19 +746,25 @@ class Snap(s_base.Base):
 
     async def _joinEmbedStor(self, storage, embeds):
         for nodePath, relProps in embeds.items():
+
             await asyncio.sleep(0)
-            iden = relProps.get('*')
+
+            iden = relProps.get('$iden')
             if not iden:
                 continue
 
             stor = await self.view.getStorNodes(s_common.uhex(iden))
             for relProp in relProps.keys():
+
                 await asyncio.sleep(0)
-                if relProp == '*':
+
+                if relProp[0] in ('*', '$'):
                     continue
 
                 for idx, layrstor in enumerate(stor):
+
                     await asyncio.sleep(0)
+
                     props = layrstor.get('props')
                     if not props:
                         continue
@@ -1319,13 +1325,13 @@ class Snap(s_base.Base):
 
                 if etyp == s_layer.EDIT_NODE_ADD:
                     node.bylayer['ndef'] = wlyr.iden
-                    callbacks.append((node.form.wasAdded, (node,), {}))
-                    callbacks.append((self.view.runNodeAdd, (node,), {}))
+                    callbacks.append((node.form.wasAdded, (node,)))
+                    callbacks.append((self.view.runNodeAdd, (node,)))
                     continue
 
                 if etyp == s_layer.EDIT_NODE_DEL:
-                    callbacks.append((node.form.wasDeleted, (node,), {}))
-                    callbacks.append((self.view.runNodeDel, (node,), {}))
+                    callbacks.append((node.form.wasDeleted, (node,)))
+                    callbacks.append((self.view.runNodeDel, (node,)))
                     continue
 
                 if etyp == s_layer.EDIT_PROP_SET:
@@ -1340,8 +1346,8 @@ class Snap(s_base.Base):
                     node.props[name] = valu
                     node.bylayer['props'][name] = wlyr.iden
 
-                    callbacks.append((prop.wasSet, (node, oldv), {}))
-                    callbacks.append((self.view.runPropSet, (node, prop, oldv), {}))
+                    callbacks.append((prop.wasSet, (node, oldv)))
+                    callbacks.append((self.view.runPropSet, (node, prop, oldv)))
                     continue
 
                 if etyp == s_layer.EDIT_PROP_DEL:
@@ -1356,8 +1362,8 @@ class Snap(s_base.Base):
                     node.props.pop(name, None)
                     node.bylayer['props'].pop(name, None)
 
-                    callbacks.append((prop.wasDel, (node, oldv), {}))
-                    callbacks.append((self.view.runPropSet, (node, prop, oldv), {}))
+                    callbacks.append((prop.wasDel, (node, oldv)))
+                    callbacks.append((self.view.runPropSet, (node, prop, oldv)))
                     continue
 
                 if etyp == s_layer.EDIT_TAG_SET:
@@ -1367,8 +1373,7 @@ class Snap(s_base.Base):
                     node.tags[tag] = valu
                     node.bylayer['tags'][tag] = wlyr.iden
 
-                    callbacks.append((self.view.runTagAdd, (node, tag, valu), {}))
-                    callbacks.append((self.wlyr.fire, ('tag:add', ), {'tag': tag, 'node': node.iden()}))
+                    callbacks.append((self.view.runTagAdd, (node, tag, valu)))
                     continue
 
                 if etyp == s_layer.EDIT_TAG_DEL:
@@ -1378,8 +1383,7 @@ class Snap(s_base.Base):
                     node.tags.pop(tag, None)
                     node.bylayer['tags'].pop(tag, None)
 
-                    callbacks.append((self.view.runTagDel, (node, tag, oldv), {}))
-                    callbacks.append((self.wlyr.fire, ('tag:del', ), {'tag': tag, 'node': node.iden()}))
+                    callbacks.append((self.view.runTagDel, (node, tag, oldv)))
                     continue
 
                 if etyp == s_layer.EDIT_TAGPROP_SET:
@@ -1414,14 +1418,14 @@ class Snap(s_base.Base):
                 if etyp == s_layer.EDIT_EDGE_ADD:
                     verb, n2iden = parms
                     n2 = await self.getNodeByBuid(s_common.uhex(n2iden))
-                    callbacks.append((self.view.runEdgeAdd, (node, verb, n2), {}))
+                    callbacks.append((self.view.runEdgeAdd, (node, verb, n2)))
 
                 if etyp == s_layer.EDIT_EDGE_DEL:
                     verb, n2iden = parms
                     n2 = await self.getNodeByBuid(s_common.uhex(n2iden))
-                    callbacks.append((self.view.runEdgeDel, (node, verb, n2), {}))
+                    callbacks.append((self.view.runEdgeDel, (node, verb, n2)))
 
-        [await func(*args, **kwargs) for (func, args, kwargs) in callbacks]
+        [await func(*args) for (func, args) in callbacks]
 
         if actualedits:
             await self.fire('node:edits', edits=actualedits)

synapse/lib/stormlib/json.py

@@ -134,7 +134,7 @@ class JsonLib(s_stormtypes.Lib):
 
     @s_stormtypes.stormfunc(readonly=True)
     async def _jsonSchema(self, schema, use_default=True):
-        schema = await s_stormtypes.toprim(schema)
+        schema = await s_stormtypes.toprim(schema, use_list=True)
         use_default = await s_stormtypes.tobool(use_default)
         # We have to ensure that we have a valid schema for making the object.
         try:

synapse/lib/stormlib/spooled.py

@@ -107,3 +107,6 @@ class SpooledSet(s_stormtypes.Set):
 
     async def value(self):
         return set([x async for x in self.valu])
+
+    async def bool(self):
+        return bool(len(self.valu))

synapse/lib/stormtypes.py

@@ -4731,6 +4731,9 @@ class Str(Prim):
             return str(self) == str(othr)
         return False
 
+    async def bool(self):
+        return bool(self.valu)
+
     @stormfunc(readonly=True)
     async def _methStrFind(self, valu):
         text = await tostr(valu)
@@ -4970,6 +4973,9 @@ class Bytes(Prim):
             return self.valu == othr.valu
         return False
 
+    async def bool(self):
+        return bool(self.valu)
+
     async def _storm_copy(self):
         item = await s_coro.ornot(self.value)
         return s_msgpack.deepcopy(item, use_list=True)
@@ -5042,6 +5048,9 @@ class Dict(Prim):
     def __len__(self):
         return len(self.valu)
 
+    async def bool(self):
+        return bool(self.valu)
+
     async def _storm_copy(self):
         item = await s_coro.ornot(self.value)
         return s_msgpack.deepcopy(item, use_list=True)
@@ -5194,6 +5203,9 @@ class Set(Prim):
     def __len__(self):
         return len(self.valu)
 
+    async def bool(self):
+        return bool(self.valu)
+
     async def _methSetSize(self):
         return len(self)
 
@@ -5384,6 +5396,9 @@ class List(Prim):
     def __len__(self):
         return len(self.valu)
 
+    async def bool(self):
+        return bool(self.valu)
+
     @stormfunc(readonly=True)
     async def _methListHas(self, valu):
         if valu in self.valu:
@@ -5519,6 +5534,9 @@ class Bool(Prim):
     def __hash__(self):
         return hash((self._storm_typename, self.value()))
 
+    async def bool(self):
+        return bool(self.valu)
+
 @registry.registerType
 class Number(Prim):
     '''

synapse/lib/types.py

@@ -651,9 +651,10 @@ class Hex(Type):
 
     def postTypeInit(self):
         self._size = self.opts.get('size')
+        self._zeropad = self.opts.get('zeropad')
 
         # This is for backward compat with v2.142.x where zeropad was a bool
-        self._zeropad = self.opts.get('zeropad')
+        # TODO: Remove this compat check in 3xx
         if isinstance(self._zeropad, bool):
             if self._zeropad:
                 self._zeropad = self._size
@@ -678,6 +679,7 @@ class Hex(Type):
         if self._size:
             self._zeropad = min(self._zeropad, self._size)
 
+        self.setNormFunc(int, self._normPyInt)
         self.setNormFunc(str, self._normPyStr)
         self.setNormFunc(bytes, self._normPyBytes)
         self.storlifts.update({
@@ -703,21 +705,47 @@ class Hex(Type):
         return self._storLiftNorm(cmpr, valu)
 
     def _storLiftPref(self, cmpr, valu):
+        if not isinstance(valu, str):
+            vtyp = type(valu).__name__
+            mesg = f'Hex prefix lift values must be str, not {vtyp}.'
+            raise s_exc.BadTypeValu(mesg=mesg, type=vtyp, name=self.name)
+
         valu = self._preNormHex(valu)
         return (
             ('^=', valu, self.stortype),
         )
 
+    def _normPyInt(self, valu):
+        extra = 7
+        if valu < 0:
+            # Negative values need a little more space to store the sign
+            extra = 8
+
+        bytelen = max((valu.bit_length() + extra) // 8, self._zeropad // 2)
+
+        try:
+            byts = valu.to_bytes(bytelen, 'big', signed=(valu < 0))
+            hexval = s_common.ehex(byts)
+
+        except OverflowError as e: # pragma: no cover
+            mesg = f'Invalid width for {valu}.'
+            raise s_exc.BadTypeValu(mesg=mesg, name=self.name)
+
+        if self._size and len(hexval) != self._size:
+            raise s_exc.BadTypeValu(valu=valu, reqwidth=self._size, name=self.name,
+                                    mesg='Invalid width.')
+
+        return hexval, {}
+
     def _normPyStr(self, valu):
-        valu = valu.strip().lower()
-        if valu.startswith('0x'):
-            valu = valu[2:]
+        valu = self._preNormHex(valu)
 
-        valu = valu.replace(' ', '').replace(':', '')
+        if len(valu) % 2 != 0:
+            valu = f'0{valu}'
 
         if not valu:
-            raise s_exc.BadTypeValu(valu=valu, name='hex',
-                                    mesg='No string left after stripping')
+            raise s_exc.BadTypeValu(valu=valu, name=self.name,
+                                    mesg='No string left after stripping.')
 
         if self._zeropad and len(valu) < self._zeropad:
             padlen = self._zeropad - len(valu)
@@ -732,7 +760,7 @@ class Hex(Type):
 
         if self._size and len(valu) != self._size:
             raise s_exc.BadTypeValu(valu=valu, reqwidth=self._size, name=self.name,
-                                    mesg='invalid width')
+                                    mesg='Invalid width.')
         return valu, {}
 
     def _normPyBytes(self, valu):

synapse/lib/version.py

@@ -223,6 +223,6 @@ def reqVersion(valu, reqver,
 ##############################################################################
 # The following are touched during the release process by bumpversion.
 # Do not modify these directly.
-version = (2, 211, 0)
+version = (2, 213, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '99beab651131ab996a967c6d0345c80b89de4a74'
+commit = 'e3d843a470b137e9d2094b69a7878101afb4f8b1'

synapse/models/inet.py

@@ -35,6 +35,10 @@ ipv4max = 2 ** 32 - 1
 
 rfc6598 = ipaddress.IPv4Network('100.64.0.0/10')
 
+# defined from https://x.com/4A4133/status/1887269972545839559
+ja4_regex = r'^([tqd])([sd\d]\d)([di])(\d{2})(\d{2})([a-zA-Z0-9]{2})_([0-9a-f]{12})_([0-9a-f]{12})$'
+ja4s_regex = r'^([tq])([sd\d]\d)(\d{2})([a-zA-Z0-9]{2})_([0-9a-f]{4})_([0-9a-f]{12})$'
+
 def getAddrType(ip):
 
     if ip.is_multicast:
@@ -1678,6 +1682,18 @@ class InetModule(s_module.CoreModule):
                     ('inet:tls:handshake', ('guid', {}), {
                         'doc': 'An instance of a TLS handshake between a server and client.'}),
 
+                    ('inet:tls:ja4', ('str', {'strip': True, 'regex': ja4_regex}), {
+                        'doc': 'A JA4 TLS client fingerprint.'}),
+
+                    ('inet:tls:ja4s', ('str', {'strip': True, 'regex': ja4s_regex}), {
+                        'doc': 'A JA4S TLS server fingerprint.'}),
+
+                    ('inet:tls:ja4:sample', ('comp', {'fields': (('client', 'inet:client'), ('ja4', 'inet:tls:ja4'))}), {
+                        'doc': 'A JA4 TLS client fingerprint used by a client.'}),
+
+                    ('inet:tls:ja4s:sample', ('comp', {'fields': (('server', 'inet:server'), ('ja4s', 'inet:tls:ja4s'))}), {
+                        'doc': 'A JA4S TLS server fingerprint used by a server.'}),
+
                     ('inet:tls:ja3s:sample', ('comp', {'fields': (('server', 'inet:server'), ('ja3s', 'hash:md5'))}), {
                         'doc': 'A JA3 sample taken from a server.'}),
 
@@ -3565,23 +3581,70 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The server that was sampled to compute the JARM hash.'}),
                     )),
 
+                    ('inet:tls:ja4', {}, ()),
+                    ('inet:tls:ja4s', {}, ()),
+
+                    ('inet:tls:ja4:sample', {}, (
+
+                        ('ja4', ('inet:tls:ja4', {}), {
+                            'ro': True,
+                            'doc': 'The JA4 TLS client fingerprint.'}),
+
+                        ('client', ('inet:client', {}), {
+                            'ro': True,
+                            'doc': 'The client which initiated the TLS handshake with a JA4 fingerprint.'}),
+                    )),
+
+                    ('inet:tls:ja4s:sample', {}, (
+
+                        ('ja4s', ('inet:tls:ja4s', {}), {
+                            'ro': True,
+                            'doc': 'The JA4S TLS server fingerprint.'}),
+
+                        ('server', ('inet:server', {}), {
+                            'ro': True,
+                            'doc': 'The server which responded to the TLS handshake with a JA4S fingerprint.'}),
+                    )),
+
                     ('inet:tls:handshake', {}, (
+
                         ('time', ('time', {}), {
                             'doc': 'The time the handshake was initiated.'}),
+
                         ('flow', ('inet:flow', {}), {
                             'doc': 'The raw inet:flow associated with the handshake.'}),
+
                         ('server', ('inet:server', {}), {
                             'doc': 'The TLS server during the handshake.'}),
+
                         ('server:cert', ('crypto:x509:cert', {}), {
                             'doc': 'The x509 certificate sent by the server during the handshake.'}),
-                        ('server:fingerprint:ja3', ('hash:md5', {}), {
-                            'doc': 'The JA3S finger of the server.'}),
+
+                        ('server:ja3s', ('hash:md5', {}), {
+                            'doc': 'The JA3S fingerprint of the server response.'}),
+
+                        ('server:ja4s', ('inet:tls:ja4s', {}), {
+                            'doc': 'The JA4S fingerprint of the server response.'}),
+
                         ('client', ('inet:client', {}), {
                             'doc': 'The TLS client during the handshake.'}),
+
                         ('client:cert', ('crypto:x509:cert', {}), {
                             'doc': 'The x509 certificate sent by the client during the handshake.'}),
+
+                        ('client:ja3', ('hash:md5', {}), {
+                            'doc': 'The JA3 fingerprint of the client request.'}),
+
+                        ('client:ja4', ('inet:tls:ja4', {}), {
+                            'doc': 'The JA4 fingerprint of the client request.'}),
+
                         ('client:fingerprint:ja3', ('hash:md5', {}), {
-                            'doc': 'The JA3 fingerprint of the client.'}),
+                            'deprecated': True,
+                            'doc': 'Deprecated. Please use :client:ja3.'}),
+
+                        ('server:fingerprint:ja3', ('hash:md5', {}), {
+                            'deprecated': True,
+                            'doc': 'Deprecated. Please use :server:ja3s.'}),
                     )),
 
                     ('inet:tls:ja3s:sample', {}, (

synapse/telepath.py

@@ -1605,8 +1605,6 @@ async def openinfo(info):
         # cell://rel/path/to/celldir:share
         path = info.get('path')
 
-        name = info.get('name', '*')
-
         # support cell://<relpath>/<to>/<cell>
         # by detecting host...
         host = info.get('host')
@@ -1614,9 +1612,12 @@ async def openinfo(info):
             path = path.strip('/')
             path = os.path.join(host, path)
 
+        name = '*'
         if ':' in path:
             path, name = path.split(':')
 
+        name = info.get('name', name)
+
         full = os.path.join(path, 'sock')
         link = await s_link.unixconnect(full)
 
@@ -1626,6 +1627,7 @@ async def openinfo(info):
         path = info.get('path')
         if ':' in path:
             path, name = path.split(':')
+        name = info.get('name', name)
         link = await s_link.unixconnect(path)
 
     elif scheme in ('tcp', 'ssl'):

synapse/tests/test_lib_cell.py

@@ -194,6 +194,18 @@ testDataSchema_v1 = {
 
 class CellTest(s_t_utils.SynTest):
 
+    async def test_cell_getLocalUrl(self):
+        with self.getTestDir() as dirn:
+            async with self.getTestCell(dirn=dirn) as cell:
+                url = cell.getLocalUrl()
+                self.eq(url, f'cell://root@{dirn}')
+
+                url = cell.getLocalUrl(share='*/layer')
+                self.eq(url, f'cell://root@{dirn}:*/layer')
+
+                url = cell.getLocalUrl(user='lowuser', share='*/view')
+                self.eq(url, f'cell://lowuser@{dirn}:*/view')
+
     async def test_cell_drive(self):
 
         with self.getTestDir() as dirn:
@@ -2580,10 +2592,10 @@ class CellTest(s_t_utils.SynTest):
                     viewiden = view.get('iden')
 
                     opts = {'view': viewiden}
-                    with self.getLoggerStream('synapse.lib.lmdbslab',
+                    with self.getAsyncLoggerStream('synapse.lib.lmdbslab',
                                               'Error during slab resize callback - foo') as stream:
-                        nodes = await core.stormlist('for $x in $lib.range(200) {[inet:ipv4=$x]}', opts=opts)
-                        self.true(stream.wait(1))
+                        msgs = await core.stormlist('for $x in $lib.range(200) {[test:int=$x]}', opts=opts)
+                        self.true(await stream.wait(timeout=30))
 
         async with self.getTestCore() as core:
 

synapse/tests/test_lib_config.py

@@ -164,8 +164,8 @@ class ConfTest(s_test.SynTest):
         # We can ensure that certain vars are loaded
         self.eq('Funky string time!', conf.req('key:string'))
         # And throw if they are not, or if the requested key isn't even schema valid
-        self.raises(s_exc.NeedConfValu, conf.reqConfValu, 'key:bool:nodefval')
-        self.raises(s_exc.BadArg, conf.reqConfValu, 'key:newp')
+        self.raises(s_exc.NeedConfValu, conf.req, 'key:bool:nodefval')
+        self.raises(s_exc.BadArg, conf.req, 'key:newp')
 
         # Since we're an Mutable mapping, we have some dict methods available to us
         self.len(8, conf)  # __len__
@@ -380,6 +380,12 @@ class ConfTest(s_test.SynTest):
         self.eq(item['key:number'], 123)
         self.notin('key:string', item)
 
+        item = validator({'key:multi': 123})
+        self.eq(item['key:multi'], 123)
+
+        item = validator({'key:multi': '123'})
+        self.eq(item['key:multi'], '123')
+
     async def test_config_ref_handler(self):
 
         filename = pathlib.Path(s_data.path(

synapse/tests/test_lib_layer.py

@@ -1399,8 +1399,8 @@ class LayerTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('inet:ipv4', 0x01020304))
             self.eq(nodes[0].get('asn'), 33)
-            self.true(nodes[0].getTag('foo.bar'), (None, None))
-            self.true(nodes[0].getTagProp('foo.bar', 'confidence'), 22)
+            self.eq(nodes[0].getTag('foo.bar'), (None, None))
+            self.eq(nodes[0].getTagProp('foo.bar', 'confidence'), 100)
 
             self.eq(10004, await core.count('.created'))
             self.len(2, await core.nodes('syn:tag~=foo'))

synapse/tests/test_lib_scrape.py

@@ -203,6 +203,10 @@ A bunch of prefixed urls
 
 https://c2server.com/evil/malware/doesnot[care+]aboutstandards{at-all}
 
+beep “https://unicode.doublequote.org/test.php” boop
+
+x ‘https://unicode.singlequote.org/test.php’ z
+
 '''
 
 data3 = '''
@@ -725,6 +729,8 @@ class ScrapeTest(s_t_utils.SynTest):
         nodes.remove(('inet:url', 'https://www.thingspace.com/blog/giggles.html'))
         nodes.remove(('inet:url', 'https://testme.org/test.php'))
         nodes.remove(('inet:url', 'https://c2server.com/evil/malware/doesnot[care+]aboutstandards{at-all}'))
+        nodes.remove(('inet:url', 'https://unicode.doublequote.org/test.php'))
+        nodes.remove(('inet:url', 'https://unicode.singlequote.org/test.php'))
 
         nodes = list(s_scrape.scrape(btc_addresses))
         self.len(11, nodes)

synapse/tests/test_lib_storm.py

@@ -1736,6 +1736,8 @@ class StormTest(s_t_utils.SynTest):
             self.stormHasNoErr(await core.stormlist('merge --diff', opts=altview))
 
             oldn = await core.nodes('[ ou:name=readonly ]', opts=altview)
+            # need to pause a moment so the created times differ
+            await asyncio.sleep(0.01)
             newn = await core.nodes('[ ou:name=readonly ]')
             self.ne(oldn[0].props['.created'], newn[0].props['.created'])
 
@@ -2251,16 +2253,18 @@ class StormTest(s_t_utils.SynTest):
             nodes = [m[1] for m in msgs if m[0] == 'node']
 
             node = nodes[0]
+            self.eq('inet:asn', node[1]['embeds']['asn']['$form'])
             self.eq('hehe', node[1]['embeds']['asn']['name'])
-            self.eq('796d67b92a6ffe9b88fa19d115b46ab6712d673a06ae602d41de84b1464782f2', node[1]['embeds']['asn']['*'])
+            self.eq('796d67b92a6ffe9b88fa19d115b46ab6712d673a06ae602d41de84b1464782f2', node[1]['embeds']['asn']['$iden'])
 
             opts = {'embeds': {'ou:org': {'hq::email': ('user',)}}}
             msgs = await core.stormlist('[ ou:org=* :country=* :hq=* ] { -> ps:contact [ :email=visi@vertex.link ] }', opts=opts)
             nodes = [m[1] for m in msgs if m[0] == 'node']
             node = nodes[0]
 
+            self.eq('inet:email', node[1]['embeds']['hq::email']['$form'])
             self.eq('visi', node[1]['embeds']['hq::email']['user'])
-            self.eq('2346d7bed4b0fae05e00a413bbf8716c9e08857eb71a1ecf303b8972823f2899', node[1]['embeds']['hq::email']['*'])
+            self.eq('2346d7bed4b0fae05e00a413bbf8716c9e08857eb71a1ecf303b8972823f2899', node[1]['embeds']['hq::email']['$iden'])
 
             fork = await core.callStorm('return($lib.view.get().fork().iden)')
 
@@ -2373,10 +2377,17 @@ class StormTest(s_t_utils.SynTest):
             self.eq(['inet:service:rule', 'risk:vulnerable'], [n[0][0] for n in nodes])
 
             embeds = nodes[0][1]['embeds']
+
+            self.nn(embeds['object']['$iden'])
+            self.eq('risk:vulnerable', embeds['object']['$form'])
             self.eq(1, embeds['object']['mitigated'])
             self.eq(None, embeds['object']['newp'])
+
+            self.nn(embeds['object::node']['$iden'])
+            self.eq('it:prod:hardware', embeds['object::node']['$form'])
             self.eq('foohw', embeds['object::node']['name'])
             self.eq(None, embeds['object::node']['newp'])
+            self.eq('inet:service:account', embeds['grantee']['$form'])
             self.eq('foocon', embeds['grantee']['id'])
             self.eq(None, embeds['grantee']['newp'])
 

synapse/tests/test_lib_stormhttp.py

@@ -642,9 +642,9 @@ class StormHttpTest(s_test.SynTest):
             self.isin('connect to proxy 127.0.0.1:1', resp['mesg'])
 
             q = '$resp=$lib.inet.http.get("http://vertex.link") return(($resp.code, $resp.err))'
-            code, (errname, _) = await core.callStorm(q)
+            code, (errname, errinfo) = await core.callStorm(q)
             self.eq(code, -1)
-            self.eq('ProxyConnectionError', errname)
+            self.isin("connect to proxy 127.0.0.1:1", errinfo.get('mesg'))
 
             msgs = await core.stormlist('$resp=$lib.inet.http.get("http://vertex.link", proxy=(null)) $lib.print($resp.err)')
             self.stormIsInWarn('HTTP proxy argument to $lib.null is deprecated', msgs)
@@ -669,7 +669,7 @@ class StormHttpTest(s_test.SynTest):
             self.stormIsInErr(errmsg.format(perm='storm.lib.inet.http.proxy'), msgs)
 
             resp = await core.callStorm('return($lib.inet.http.get(http://vertex.link, proxy=socks5://user:pass@127.0.0.1:1))')
-            self.eq('ProxyConnectionError', resp['err'][0])
+            self.isin("connect to proxy 127.0.0.1:1", resp['err'][1].get('mesg'))
 
             # test $lib.axon proxy API
             asvisi = {'user': visi.iden}
@@ -748,13 +748,13 @@ class StormHttpTest(s_test.SynTest):
             opts = {'vars': {'proxy': 'socks5://user:pass@127.0.0.1:1'}, 'user': visi.iden}
 
             resp = await core.callStorm(q1, opts=opts)
-            self.eq('ProxyConnectionError', resp['err'][0])
+            self.isin("connect to proxy 127.0.0.1:1", resp['err'][1].get('mesg'))
 
             resp = await core.callStorm(q2, opts=opts)
-            self.eq('ProxyConnectionError', resp['err'][0])
+            self.isin("connect to proxy 127.0.0.1:1", resp['err'][1].get('mesg'))
 
             resp = await core.callStorm(q3, opts=opts)
-            self.eq('ProxyConnectionError', resp['err'][0])
+            self.isin("connect to proxy 127.0.0.1:1", resp['err'][1].get('mesg'))
 
             opts = {'vars': {'proxy': False}, 'user': visi.iden}