synapse 2.174.0__py311-none-any.whl → 2.176.0__py311-none-any.whl

synapse/tests/test_daemon.py

@@ -75,6 +75,42 @@ class DaemonTest(s_t_utils.SynTest):
             async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}') as proxy:
                 self.eq(proxy._ahainfo, ahainfo)
 
+    async def test_dmon_errors(self):
+
+        async with self.getTestCell(s_cell.Cell, conf={'dmon:listen': 'tcp://0.0.0.0:0/', 'auth:anon': 'root'}) as cell:
+            host, port = cell.sockaddr
+
+            async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}') as prox:
+
+                # Throw an exception when trying to handle mesg outright
+                async with await prox.getPoolLink() as link:
+                    with self.getAsyncLoggerStream('synapse.daemon', 'Dmon.onLinkMesg Handler: mesg=') as stream:
+                        await link.tx(31337)
+                        self.true(await stream.wait(timeout=6))
+
+                # Valid format; do not know what the message is.
+                async with await prox.getPoolLink() as link:
+                    mesg = ('newp', {})
+                    emsg = "Dmon.onLinkMesg Invalid mesg: mesg=('newp', {})"
+                    with self.getAsyncLoggerStream('synapse.daemon', emsg) as stream:
+                        await link.tx(mesg)
+                        self.true(await stream.wait(timeout=6))
+
+                # Invalid data casues a link to fail on rx
+                async with await prox.getPoolLink() as link:
+                    with self.getAsyncLoggerStream('synapse.lib.link', 'rx error') as stream:
+                        byts = b'\x16\x03\x01\x02\x00\x01\x00\x01\xfc\x03\x03\xa6\xa3D\xd5\xdf%\xac\xa9\x92\xc3'
+                        await link.send(byts)
+                        self.true(await stream.wait(timeout=6))
+
+                # bad t2:init message
+                async with await prox.getPoolLink() as link:
+                    mesg = ('t2:init', {})
+                    emsg = "Error on t2:init:"
+                    with self.getAsyncLoggerStream('synapse.daemon', emsg) as stream:
+                        await link.tx(mesg)
+                        self.true(await stream.wait(timeout=6))
+
 class SvcApi(s_cell.CellApi, s_stormsvc.StormSvc):
     _storm_svc_name = 'foo'
     _storm_svc_pkgs = (  # type:  ignore

synapse/tests/test_lib_ast.py

@@ -713,6 +713,41 @@ class AstTest(s_test.SynTest):
             self.len(3, await core.nodes('test:str=ndefs :ndefs -> *'))
             self.len(2, await core.nodes('test:str=ndefs :ndefs -> it:dev:int'))
 
+            await core.nodes('[ risk:technique:masquerade=* :node=(it:dev:int, 1) ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ :target=(it:dev:int, 1) ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ :target=(it:dev:int, 2) ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ -:node ]')
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(1, nodes)
+            self.eq('test:str', nodes[0].ndef[0])
+
+            await core.nodes('test:str=ndefs [ :ndefs-=(it:dev:int, 1) ]')
+            self.len(0, await core.nodes('it:dev:int=1 <- *'))
+            nodes = await core.nodes('it:dev:int=2 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['test:str', 'risk:technique:masquerade'])
+
+            await core.nodes('risk:technique:masquerade [ -:target ]')
+            await core.nodes('test:str=ndefs [ -:ndefs ]')
+            self.len(0, await core.nodes('it:dev:int=1 <- *'))
+            self.len(0, await core.nodes('it:dev:int=2 <- *'))
+
     async def test_ast_pivot(self):
         # a general purpose pivot test. come on in!
         async with self.getTestCore() as core:

synapse/tests/test_lib_cell.py

@@ -503,6 +503,13 @@ class CellTest(s_t_utils.SynTest):
             cell.COMMIT = 'mycommit'
             cell.VERSION = (1, 2, 3)
             cell.VERSTRING = '1.2.3'
+
+            http_info = []
+            host, port = await cell.addHttpsPort(0)
+            http_info.append({'host': host, 'port': port})
+            host, port = await cell.addHttpsPort(0, host='127.0.0.1')
+            http_info.append({'host': host, 'port': port})
+
             async with cell.getLocalProxy() as prox:
                 info = await prox.getCellInfo()
                 # Cell information
@@ -527,6 +534,10 @@ class CellTest(s_t_utils.SynTest):
                 self.eq(snfo.get('verstring'), s_version.verstring),
                 self.eq(snfo.get('commit'), s_version.commit)
 
+                netw = cnfo.get('network')
+                https = netw.get('https')
+                self.eq(https, http_info)
+
     async def test_cell_dyncall(self):
 
         with self.getTestDir() as dirn:

synapse/tests/test_lib_modelrev.py

@@ -530,3 +530,32 @@ class ModelRevTest(s_tests.SynTest):
             self.len(2, nodes)
             titles = [n.ndef[1] for n in nodes]
             self.sorteq(titles, positions)
+
+    async def test_modelrev_0_2_26(self):
+        async with self.getRegrCore('model-0.2.26') as core:
+
+            nodes = await core.nodes('it:dev:int=1 <- *')
+            self.len(3, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['risk:vulnerable', 'risk:vulnerable', 'inet:fqdn'])
+
+            nodes = await core.nodes('it:dev:int=2 <- *')
+            self.len(2, nodes)
+            forms = [node.ndef[0] for node in nodes]
+            self.sorteq(forms, ['inet:fqdn', 'inet:fqdn'])
+
+            nodes = await core.nodes('it:dev:int=3 <- *')
+            self.len(1, nodes)
+            self.eq(nodes[0].ndef[0], 'risk:vulnerable')
+
+            nodes = await core.nodes('it:dev:int=4 <- *')
+            self.len(1, nodes)
+            self.eq(nodes[0].ndef[0], 'inet:fqdn')
+
+            nodes = await core.nodes('risk:vulnerable:node=(it:dev:int, 1)')
+            self.len(2, nodes)
+
+            rnodes = await core.nodes('reverse(risk:vulnerable:node=(it:dev:int, 1))')
+            self.len(2, rnodes)
+
+            self.eq([node.ndef[0] for node in nodes], [node.ndef[0] for node in reversed(rnodes)])

synapse/tests/test_lib_storm.py

@@ -1348,6 +1348,12 @@ class StormTest(s_t_utils.SynTest):
 
             self.len(0, await core.nodes('diff', opts=altview))
 
+            await core.nodes('[ ps:contact=* :name=con0 +#con0 +#con0.foo +#conalt ]', opts=altview)
+            await core.nodes('[ ps:contact=* :name=con1 +#con1 +#conalt ]', opts=altview)
+
+            nodes = await core.nodes('diff --tag conalt con1 con0.foo con0 newp', opts=altview)
+            self.sorteq(['con0', 'con1'], [n.get('name') for n in nodes])
+
             q = '''
             [ ou:name=foo +(bar)> {[ ou:name=bar ]} ]
             { for $i in $lib.range(1001) { $node.data.set($i, $i) }}
@@ -1537,6 +1543,112 @@ class StormTest(s_t_utils.SynTest):
             await core.nodes('inet:ssl:cert | merge --apply', opts=altview)
             self.len(1, await core.nodes('inet:ipv4'))
 
+    async def test_storm_merge_perms(self):
+
+        async with self.getTestCore() as core:
+
+            await core.addTagProp('score', ('int', {}), {})
+
+            visi = await core.auth.addUser('visi')
+            opts = {'user': visi.iden}
+
+            view2 = await core.callStorm('return($lib.view.get().fork())')
+            view2opts = opts | {'view': view2['iden']}
+            layr2 = view2['layers'][0]['iden']
+            layr1 = view2['layers'][1]['iden']
+
+            await visi.addRule((True, ('view',)))
+            await visi.addRule((True, ('node', 'add')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'prop', 'set')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'tag', 'add')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'data', 'set')), gateiden=layr2)
+            await visi.addRule((True, ('node', 'edge', 'add')), gateiden=layr2)
+
+            await core.nodes('[ ou:name=test ]')
+
+            await core.nodes('''
+                [ ps:contact=*
+                    :name=test0
+                    +(test)> { ou:name=test }
+                    +#test1.foo=now
+                    +#test2
+                    +#test3:score=42
+                ]
+                $node.data.set(foo, bar)
+            ''', opts=view2opts)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.del.ps:contact', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'del')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.add.ps:contact', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'add')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.prop.del.ps:contact..created', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'prop', 'del')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.prop.set.ps:contact..created', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'prop', 'set')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.del.test1.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'del', 'test1', 'foo')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.add.test1.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'add', 'test1', 'foo')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.del.test3', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'del', 'test3')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.add.test3', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'add', 'test3')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.del.test2', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'del', 'test2')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.tag.add.test2', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'tag', 'add', 'test2')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.data.pop.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'data', 'pop')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.data.set.foo', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'data', 'set')), gateiden=layr1)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.edge.del.test', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'edge', 'del')), gateiden=layr2)
+
+            with self.raises(s_exc.AuthDeny) as ecm:
+                await core.nodes('ps:contact merge --apply', opts=view2opts)
+            self.eq('node.edge.add.test', ecm.exception.errinfo['perm'])
+            await visi.addRule((True, ('node', 'edge', 'add')), gateiden=layr1)
+
+            await core.nodes('ps:contact merge --apply', opts=view2opts)
+
     async def test_storm_movenodes(self):
 
         async with self.getTestCore() as core:
@@ -2912,27 +3024,30 @@ class StormTest(s_t_utils.SynTest):
 
             q = 'inet:ipv4=1.2.3.4 | tee --join { -> * } { <- * }'
             nodes = await core.nodes(q)
-            self.len(3, nodes)
+            self.len(4, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
 
             q = 'inet:ipv4=1.2.3.4 | tee --join { -> * } { <- * } { -> edge:refs:n2 :n1 -> * }'
             nodes = await core.nodes(q)
-            self.len(4, nodes)
+            self.len(5, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('media:news'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef[0], ('media:news'))
+            self.eq(nodes[4].ndef, ('inet:ipv4', 0x01020304))
 
             # Queries can be a heavy list
             q = '$list = $lib.list(${ -> * }, ${ <- * }, ${ -> edge:refs:n2 :n1 -> * }) inet:ipv4=1.2.3.4 | tee --join $list'
             nodes = await core.nodes(q)
-            self.len(4, nodes)
+            self.len(5, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('media:news'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef[0], ('media:news'))
+            self.eq(nodes[4].ndef, ('inet:ipv4', 0x01020304))
 
             # A empty list of queries still works as an nop
             q = '$list = $lib.list() | tee $list'
@@ -2959,11 +3074,12 @@ class StormTest(s_t_utils.SynTest):
             q = 'inet:ipv4=1.2.3.4 | tee --join $list'
             queries = ('-> *', '<- *', '-> edge:refs:n2 :n1 -> *')
             nodes = await core.nodes(q, {'vars': {'list': queries}})
-            self.len(4, nodes)
+            self.len(5, nodes)
             self.eq(nodes[0].ndef, ('inet:asn', 0))
             self.eq(nodes[1].ndef[0], ('inet:dns:a'))
-            self.eq(nodes[2].ndef[0], ('media:news'))
-            self.eq(nodes[3].ndef, ('inet:ipv4', 0x01020304))
+            self.eq(nodes[2].ndef[0], ('edge:refs'))
+            self.eq(nodes[3].ndef[0], ('media:news'))
+            self.eq(nodes[4].ndef, ('inet:ipv4', 0x01020304))
 
             # Empty queries are okay - they will just return the input node
             q = 'inet:ipv4=1.2.3.4 | tee {}'

synapse/tests/test_lib_stormlib_storm.py

@@ -5,7 +5,7 @@ import synapse.tests.utils as s_test
 
 class LibStormTest(s_test.SynTest):
 
-    async def test_lib_stormlib_storm(self):
+    async def test_lib_stormlib_storm_eval(self):
         async with self.getTestCore() as core:
 
             opts = {'vars': {'text': '(10)'}}
@@ -61,3 +61,84 @@ class LibStormTest(s_test.SynTest):
 
                 mesg = f'Executing storm query via $lib.storm.eval() {{{q}}} as [root]'
                 self.isin(mesg, data)
+
+    async def test_lib_stormlib_storm(self):
+
+        async with self.getTestCore() as core:
+
+            q = '''
+            $query = '[ inet:fqdn=foo.com inet:fqdn=bar.com ]'
+            storm.exec $query
+            '''
+            self.len(2, await core.nodes(q))
+
+            q = '''[
+            (inet:ipv4=1.2.3.4 :asn=4)
+            (inet:ipv4=1.2.3.5 :asn=5)
+            (inet:ipv4=1.2.3.6 :asn=10)
+            ]'''
+            await core.nodes(q)
+
+            q = '''
+            $filter = '-:asn=10'
+            inet:ipv4:asn
+            storm.exec $filter
+            '''
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.ne(node.get('asn'), 10)
+
+            q = '''
+            $pivot = ${ -> inet:asn }
+            inet:ipv4:asn
+            storm.exec $pivot
+            '''
+            nodes = await core.nodes(q)
+            self.len(3, nodes)
+            for node in nodes:
+                self.eq(node.form.name, 'inet:asn')
+
+            # Exec a non-runtsafe query
+            q = '''
+            inet:ipv4:asn
+            $filter = `+:asn={$node.repr().split('.').'-1'}`
+            storm.exec $filter
+            '''
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.ne(node.get('asn'), 10)
+
+            iden = await core.callStorm('return($lib.view.get().fork().iden)')
+            msgs = await core.stormlist('''
+                $query = "[inet:fqdn=vertex.link +#haha] $lib.print(woot)"
+                $opts = ({"view": $view})
+                for $mesg in $lib.storm.run($query, opts=$opts) {
+                    if ($mesg.0 = "print") { $lib.print($mesg.1.mesg) }
+                }
+            ''', opts={'vars': {'view': iden}})
+            self.stormIsInPrint('woot', msgs)
+            self.len(1, await core.nodes('inet:fqdn#haha', opts={'view': iden}))
+
+            visi = await core.auth.addUser('visi')
+            msgs = await core.stormlist('''
+                $opts=({"user": $lib.auth.users.byname(root).iden})
+                for $mesg in $lib.storm.run("$lib.print(lolz)", opts=$opts) {
+                    if ($mesg.0 = "err") { $lib.print($mesg) }
+                    if ($mesg.0 = "print") { $lib.print($mesg) }
+                }
+            ''', opts={'user': visi.iden})
+            self.stormIsInErr('must have permission impersonate', msgs)
+            self.stormNotInPrint('lolz', msgs)
+
+            # no opts provided
+            msgs = await core.stormlist('''
+                $q = ${ $lib.print('hello') }
+                for $mesg in $lib.storm.run($q) {
+                    if ( $mesg.0 = 'print' ) {
+                        $lib.print(`mesg={$mesg.1.mesg}`)
+                    }
+                }
+            ''')
+            self.stormIsInPrint('mesg=hello', msgs)

synapse/tests/test_model_inet.py

@@ -3300,3 +3300,34 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('resource'), resource.ndef[1])
             self.true(nodes[0].get('success'))
             self.eq(nodes[0].get('time'), 1715856900000)
+
+            q = '''
+            [ inet:service:message=(visi, says, relax)
+                :title="Hehe Haha"
+                :thread={[
+                    inet:service:thread=*
+                        :title="Woot  Woot"
+                        :message=(visi, says, hello)
+                        :channel={[
+                            inet:service:channel=(synapse, subreddit)
+                                :name="/r/synapse"
+                        ]}
+                ]}
+            ]
+            '''
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.len(1, await core.nodes('inet:service:message=(visi, says, hello) -> inet:service:thread:message'))
+            self.len(1, await core.nodes('''
+                inet:service:message:title="hehe haha"
+                :thread -> inet:service:thread
+                +:title="woot woot"
+            '''))
+            self.len(2, await core.nodes('inet:service:thread -> inet:service:message'))
+
+            self.len(1, await core.nodes('''
+                inet:service:message:title="hehe haha"
+                :thread -> inet:service:thread
+                :channel -> inet:service:channel
+                +:name="/r/synapse"
+            '''))

synapse/tools/changelog.py

@@ -1,4 +1,5 @@
 import os
+import re
 import sys
 import pprint
 import asyncio
@@ -41,8 +42,6 @@ def gen(opts: argparse.Namespace,
     data['type'] = opts.type
     data['desc'] = opts.desc
 
-    if opts.migration_desc:
-        data['migration_desc'] = opts.migration_desc
     if opts.pr:
         data['prs'] = [opts.pr]
 
@@ -104,19 +103,40 @@ def format(opts: argparse.Namespace,
 
         s_schemas._reqChanglogSchema(data)
 
+        data.setdefault('prs', [])
+        prs = data.get('prs')
+
         if opts.prs_from_git:
-            outp.printf('--prs-from-git not yet implemented.')
-            return 1
 
-        if opts.enforce_prs and not data.get('prs'):
+            argv = ['git', 'log', '--pretty=oneline', fp]
+            ret = subprocess.run(argv, capture_output=True)
+            if opts.verbose:
+                outp.printf(f'stddout={ret.stdout}')
+                outp.printf(f'stderr={ret.stderr}')
+            ret.check_returncode()
+
+            for line in ret.stdout.splitlines():
+                line = line.decode()
+                line = line.strip()
+                if not line:
+                    continue
+                match = re.search('\\(#(?P<pr>\\d{1,})\\)', line)
+                if match:
+                    for pr in match.groups():
+                        pr = int(pr)
+                        if pr not in prs:
+                            prs.append(pr)
+                            if opts.verbose:
+                                outp.printf(f'Added PR #{pr} to the pr list from [{line=}]')
+
+        if opts.enforce_prs and not prs:
             outp.printf(f'Entry is missing PR numbers: {fp=}')
             return 1
-        data.setdefault('prs', [])
 
         if opts.verbose:
             outp.printf(f'Got data from {fp=}')
 
-        data.get('prs').sort()  # sort the PRs inplace
+        prs.sort() # sort the PRs inplace
         entries[data.get('type')].append(data)
 
     if not entries:

{synapse-2.174.0.dist-info → synapse-2.176.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synapse
-Version: 2.174.0
+Version: 2.176.0
 Summary: Synapse Intelligence Analysis Framework
 Author-email: The Vertex Project LLC <root@vertex.link>
 License: Apache License 2.0