synapse 2.191.0__py311-none-any.whl → 2.193.0__py311-none-any.whl

synapse/tests/test_lib_stormhttp.py

@@ -9,7 +9,7 @@ import synapse.common as s_common
 import synapse.lib.certdir as s_certdir
 import synapse.lib.httpapi as s_httpapi
 import synapse.lib.stormctrl as s_stormctrl
-import synapse.lib.stormhttp as s_stormhttp
+import synapse.lib.stormtypes as s_stormtypes
 
 import synapse.tests.utils as s_test
 
@@ -606,11 +606,39 @@ class StormHttpTest(s_test.SynTest):
             self.false(resp.get('ok'))
             self.ne(-1, resp['mesg'].find('connect to proxy 127.0.0.1:1'))
 
+            msgs = await core.stormlist('$resp=$lib.axon.wget("http://vertex.link", proxy=(null)) $lib.print($resp.mesg)')
+            self.stormIsInWarn('HTTP proxy argument to $lib.null is deprecated', msgs)
+            self.stormIsInPrint('connect to proxy 127.0.0.1:1', msgs)
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('$lib.axon.wget("http://vertex.link", proxy=(1.1))'))
+
+            # todo: setting the synapse version can be removed once proxy=true support is released
+            try:
+                oldv = core.axoninfo['synapse']['version']
+                core.axoninfo['synapse']['version'] = (oldv[0], oldv[1] + 1, oldv[2])
+                resp = await core.callStorm('return($lib.axon.wget("http://vertex.link", proxy=(null)))')
+                self.false(resp.get('ok'))
+                self.ne(-1, resp['mesg'].find('connect to proxy 127.0.0.1:1'))
+            finally:
+                core.axoninfo['synapse']['version'] = oldv
+
+            size, sha256 = await core.axon.put(b'asdf')
+            opts = {'vars': {'sha256': s_common.ehex(sha256)}}
+            resp = await core.callStorm(f'return($lib.axon.wput($sha256, http://vertex.link))', opts=opts)
+            self.false(resp.get('ok'))
+            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)
             self.eq(code, -1)
             self.eq('ProxyConnectionError', errname)
 
+            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)
+            self.stormIsInPrint('connect to proxy 127.0.0.1:1', msgs)
+
+            await self.asyncraises(s_exc.BadArg, core.nodes('$lib.inet.http.get("http://vertex.link", proxy=(1.1))'))
+
         async with self.getTestCore() as core:
 
             visi = await core.auth.addUser('visi')
@@ -654,6 +682,24 @@ class StormHttpTest(s_test.SynTest):
             self.false(resp.get('ok'))
             self.isin('connect to proxy 127.0.0.1:1', resp['mesg'])
 
+            host, port = await core.addHttpsPort(0)
+            opts = {
+                'vars': {
+                    'url': f'https://loop.vertex.link:{port}',
+                    'proxy': 'socks5://user:pass@127.0.0.1:1',
+                }
+            }
+            try:
+                oldv = core.axoninfo['synapse']['version']
+                minver = s_stormtypes.AXON_MINVERS_PROXY
+                core.axoninfo['synapse']['version'] = minver[2], minver[1] - 1, minver[0]
+                q = '$resp=$lib.axon.wget($url, ssl=(false), proxy=$proxy) $lib.print(`code={$resp.code}`)'
+                mesgs = await core.stormlist(q, opts=opts)
+                self.stormIsInPrint('code=404', mesgs)
+                self.stormIsInWarn('Axon version does not support proxy argument', mesgs)
+            finally:
+                core.axoninfo['synapse']['version'] = oldv
+
         async with self.getTestCore(conf=conf) as core:
             # Proxy permission tests in this section
 
@@ -762,10 +808,15 @@ class StormHttpTest(s_test.SynTest):
             ($ok, $valu) = $sock.tx(lololol)
             return($sock.rx())
             '''
-            opts = {'vars': {'port': port, 'proxy': None}}
+            opts = {'vars': {'port': port, 'proxy': True}}
             self.eq((True, ('echo', 'lololol')),
                     await core.callStorm(query, opts=opts))
 
+            opts = {'vars': {'port': port, 'proxy': None}}
+            mesgs = await core.stormlist(query, opts=opts)
+            self.stormIsInWarn('proxy argument to $lib.null is deprecated', mesgs)
+            self.true(mesgs[-2][0] == 'err' and mesgs[-2][1][1]['mesg'] == "(True, ['echo', 'lololol'])")
+
             visi = await core.auth.addUser('visi')
 
             opts = {'user': visi.iden, 'vars': {'port': port, 'proxy': False}}
@@ -903,16 +954,10 @@ class StormHttpTest(s_test.SynTest):
                     core.axoninfo['synapse']['version'] = oldv
 
                 ## version check succeeds
-                # todo: setting the synapse version can be removed once ssl_opts is released
-                try:
-                    oldv = core.axoninfo['synapse']['version']
-                    core.axoninfo['synapse']['version'] = (oldv[0], oldv[1] + 1, oldv[2])
-                    self.eq(200, await core.callStorm(axon_queries['postfile'], opts=opts))
-                    self.eq(200, await core.callStorm(axon_queries['wget'], opts=opts))
-                    self.eq(200, await core.callStorm(axon_queries['wput'], opts=opts))
-                    self.len(1, await core.nodes(axon_queries['urlfile'], opts=opts))
-                finally:
-                    core.axoninfo['synapse']['version'] = oldv
+                self.eq(200, await core.callStorm(axon_queries['postfile'], opts=opts))
+                self.eq(200, await core.callStorm(axon_queries['wget'], opts=opts))
+                self.eq(200, await core.callStorm(axon_queries['wput'], opts=opts))
+                self.len(1, await core.nodes(axon_queries['urlfile'], opts=opts))
 
                 # verify arg precedence
 

synapse/tests/test_lib_stormlib_json.py

@@ -12,6 +12,26 @@ class JsonTest(s_test.SynTest):
 
             self.eq(((1, 2, 3)), await core.callStorm('return($lib.json.load("[1, 2, 3]"))'))
             self.eq(('["foo", "bar", "baz"]'), await core.callStorm('return($lib.json.save((foo, bar, baz)))'))
+            self.eq(('{"foo": 1, "bar": {"baz": "hello"}}'), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}})))'))
+            self.eq(('{"foo": 1, "bar": {"baz": "hello"}}'), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), (null)))'))
+            self.eq((
+'''{
+    "foo": 1,
+    "bar": {
+        "baz": "hello"
+    }
+}'''), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=(4)))'))
+
+            self.eq((
+'''{
+  "foo": 1,
+  "bar": {
+    "baz": "hello"
+  }
+}'''), await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=2))'))
+
+            with self.raises(s_exc.BadCast):
+                await core.callStorm('return($lib.json.save(({"foo": 1, "bar": {"baz": "hello"}}), indent=x))')
 
             with self.raises(s_exc.BadJsonText):
                 await core.callStorm('return($lib.json.load(foo))')

synapse/tests/test_lib_stormlib_scrape.py

@@ -92,7 +92,7 @@ class StormScrapeTest(s_test.SynTest):
             self.len(0, mods)
             self.len(0, core.modsbyiface.get('scrape'))
 
-            await core.loadStormPkg(pkgdef)
+            core.loadStormPkg(pkgdef)
 
             mods = await core.getStormIfaces('scrape')
             self.len(2, mods)
@@ -131,7 +131,7 @@ class StormScrapeTest(s_test.SynTest):
         conf = {'storm:interface:scrape': False, }
         async with self.getTestCore(conf=conf) as core:
 
-            await core.loadStormPkg(pkgdef)
+            core.loadStormPkg(pkgdef)
 
             mods = await core.getStormIfaces('scrape')
             self.len(2, mods)

synapse/tests/test_model_inet.py

@@ -10,17 +10,40 @@ class InetModelTest(s_t_utils.SynTest):
 
     async def test_model_inet_basics(self):
         async with self.getTestCore() as core:
+            self.len(1, await core.nodes('[ inet:web:hashtag="#🫠" ]'))
+            self.len(1, await core.nodes('[ inet:web:hashtag="#🫠🫠" ]'))
+            self.len(1, await core.nodes('[ inet:web:hashtag="#·bar"]'))
+            self.len(1, await core.nodes('[ inet:web:hashtag="#foo·"]'))
+            self.len(1, await core.nodes('[ inet:web:hashtag="#foo〜"]'))
             self.len(1, await core.nodes('[ inet:web:hashtag="#hehe" ]'))
             self.len(1, await core.nodes('[ inet:web:hashtag="#foo·bar"]'))  # note the interpunct
+            self.len(1, await core.nodes('[ inet:web:hashtag="#foo〜bar"]'))  # note the wave dash
             self.len(1, await core.nodes('[ inet:web:hashtag="#fo·o·······b·ar"]'))
             with self.raises(s_exc.BadTypeValu):
                 await core.nodes('[ inet:web:hashtag="foo" ]')
+
             with self.raises(s_exc.BadTypeValu):
-                await core.nodes('[ inet:web:hashtag="#foo bar" ]')
-            with self.raises(s_exc.BadTypeValu):
-                self.len(1, await core.nodes('[ inet:web:hashtag="#·bar"]'))
-            with self.raises(s_exc.BadTypeValu):
-                self.len(1, await core.nodes('[ inet:web:hashtag="#foo·"]'))
+                await core.nodes('[ inet:web:hashtag="#foo#bar" ]')
+
+            # All unicode whitespace from:
+            # https://www.compart.com/en/unicode/category/Zl
+            # https://www.compart.com/en/unicode/category/Zp
+            # https://www.compart.com/en/unicode/category/Zs
+            whitespace = [
+                '\u0020', '\u00a0', '\u1680', '\u2000', '\u2001', '\u2002', '\u2003', '\u2004',
+                '\u2005', '\u2006', '\u2007', '\u2008', '\u2009', '\u200a', '\u202f', '\u205f',
+                '\u3000', '\u2028', '\u2029',
+            ]
+            for char in whitespace:
+                with self.raises(s_exc.BadTypeValu):
+                    await core.callStorm(f'[ inet:web:hashtag="#foo{char}bar" ]')
+
+                with self.raises(s_exc.BadTypeValu):
+                    await core.callStorm(f'[ inet:web:hashtag="#{char}bar" ]')
+
+                # These are allowed because strip=True
+                await core.callStorm(f'[ inet:web:hashtag="#foo{char}" ]')
+                await core.callStorm(f'[ inet:web:hashtag=" #foo{char}" ]')
 
             nodes = await core.nodes('''
                 [ inet:web:instance=(foo,)
@@ -457,6 +480,7 @@ class InetModelTest(s_t_utils.SynTest):
                 :raw=((10), (20))
                 :src:txfiles={[ file:attachment=* :name=foo.exe ]}
                 :dst:txfiles={[ file:attachment=* :name=bar.exe ]}
+                :capture:host=*
             )]'''
             nodes = await core.nodes(q, opts={'vars': {'valu': valu, 'p': props}})
             self.len(1, nodes)
@@ -500,11 +524,13 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(node.get('src:rdp:hostname'), 'syncoder')
             self.eq(node.get('src:rdp:keyboard:layout'), 'azerty')
             self.eq(node.get('raw'), (10, 20))
+            self.nn(node.get('capture:host'))
             self.len(2, await core.nodes('inet:flow -> crypto:x509:cert'))
             self.len(1, await core.nodes('inet:flow :src:ssh:key -> crypto:key'))
             self.len(1, await core.nodes('inet:flow :dst:ssh:key -> crypto:key'))
             self.len(1, await core.nodes('inet:flow :src:txfiles -> file:attachment +:name=foo.exe'))
             self.len(1, await core.nodes('inet:flow :dst:txfiles -> file:attachment +:name=bar.exe'))
+            self.len(1, await core.nodes('inet:flow :capture:host -> it:host'))
 
     async def test_fqdn(self):
         formname = 'inet:fqdn'
@@ -2746,6 +2772,7 @@ class InetModelTest(s_t_utils.SynTest):
             q = '''
             [
             inet:email:message="*"
+                :id="Woot-12345 "
                 :to=woot@woot.com
                 :from=visi@vertex.link
                 :replyto=root@root.com
@@ -2767,6 +2794,7 @@ class InetModelTest(s_t_utils.SynTest):
             nodes = await core.nodes(q, opts={'vars': {'flow': flow}})
             self.len(1, nodes)
 
+            self.eq(nodes[0].get('id'), 'Woot-12345')
             self.eq(nodes[0].get('cc'), ('baz@faz.org', 'foo@bar.com'))
             self.eq(nodes[0].get('received:from:ipv6'), '::1')
             self.eq(nodes[0].get('received:from:ipv4'), 0x01020304)
@@ -2847,6 +2875,7 @@ class InetModelTest(s_t_utils.SynTest):
             nodes = await core.nodes('''
             [ inet:egress=*
                 :host = *
+                :host:iface = *
                 :client=1.2.3.4
                 :client:ipv6="::1"
             ]
@@ -2854,10 +2883,14 @@ class InetModelTest(s_t_utils.SynTest):
 
             self.len(1, nodes)
             self.nn(nodes[0].get('host'))
+            self.nn(nodes[0].get('host:iface'))
             self.eq(nodes[0].get('client'), 'tcp://1.2.3.4')
             self.eq(nodes[0].get('client:ipv4'), 0x01020304)
             self.eq(nodes[0].get('client:ipv6'), '::1')
 
+            self.len(1, await core.nodes('inet:egress -> it:host'))
+            self.len(1, await core.nodes('inet:egress -> inet:iface'))
+
     async def test_model_inet_tls_handshake(self):
 
         async with self.getTestCore() as core:
@@ -2976,6 +3009,7 @@ class InetModelTest(s_t_utils.SynTest):
                 (inet:service:account=(blackout, account, vertex, slack)
                     :id=U7RN51U1J
                     :user=blackout
+                    :url=https://vertex.link/users/blackout
                     :email=blackout@vertex.link
                     :profile={ gen.ps.contact.email vertex.employee blackout@vertex.link }
                     :tenant={[ inet:service:tenant=({"id": "VS-31337"}) ]}
@@ -3003,6 +3037,7 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(accounts[0].ndef, ('inet:service:account', s_common.guid(('blackout', 'account', 'vertex', 'slack'))))
             self.eq(accounts[0].get('id'), 'U7RN51U1J')
             self.eq(accounts[0].get('user'), 'blackout')
+            self.eq(accounts[0].get('url'), 'https://vertex.link/users/blackout')
             self.eq(accounts[0].get('email'), 'blackout@vertex.link')
             self.eq(accounts[0].get('profile'), blckprof.ndef[1])
 

synapse/tests/test_model_risk.py

@@ -430,6 +430,7 @@ class RiskModelTest(s_t_utils.SynTest):
                 :disclosed=20231102
                 :owner={ gen.ou.org.hq acme }
                 :leaker={ gen.ou.org.hq wikileaks }
+                :recipient={ gen.ou.org.hq everyone }
                 :type=public
                 :goal={[ ou:goal=* :name=publicity ]}
                 :compromise={[ risk:compromise=* :target={ gen.ou.org.hq acme } ]}
@@ -458,6 +459,7 @@ class RiskModelTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('risk:leak -> risk:leak:type:taxonomy'))
             self.len(1, await core.nodes('risk:leak :owner -> ps:contact +:orgname=acme'))
             self.len(1, await core.nodes('risk:leak :leaker -> ps:contact +:orgname=wikileaks'))
+            self.len(1, await core.nodes('risk:leak :recipient -> ps:contact +:orgname=everyone'))
             self.len(1, await core.nodes('risk:leak -> ou:goal +:name=publicity'))
             self.len(1, await core.nodes('risk:leak -> risk:compromise :target -> ps:contact +:orgname=acme'))
             self.len(1, await core.nodes('risk:leak :reporter -> ou:org +:name=vertex'))

synapse/tests/test_servers_univ.py

@@ -56,18 +56,6 @@ class UnivServerTest(s_t_utils.SynTest):
                     async with await s_telepath.openurl(f'cell://{dirn}') as proxy:
                         self.eq('cell', await proxy.getCellType())
 
-                argv = [
-                    'synapse.tests.test_lib_cell.EchoAuth',
-                    '--telepath', 'tcp://127.0.0.1:0/',
-                    '--https', '0',
-                    '--name', 'univtest',
-                    dirn,
-                ]
-                # Or start the Cortex off a a EchoAuth (don't do this in practice...)
-                async with await s_s_univ.main(argv) as cell:
-                    async with await s_telepath.openurl(f'cell://{dirn}') as proxy:
-                        self.eq('echoauth', await proxy.getCellType())
-
                 argv = ['synapse.lib.newp.Newp']
                 with self.raises(s_exc.NoSuchCtor):
                     async with await s_s_univ.main(argv) as core:

synapse/tests/test_tools_apikey.py

@@ -0,0 +1,227 @@
+import datetime
+
+import synapse.exc as s_exc
+import synapse.common as s_common
+
+import synapse.lib.time as s_time
+import synapse.lib.output as s_output
+
+import synapse.tests.utils as s_test
+import synapse.tools.apikey as s_t_apikey
+
+async def getApiKeyByName(core, name):
+    keys = {k.get('name'): k async for k in core.getApiKeys()}
+    return keys.get(name)
+
+class ApiKeyTest(s_test.SynTest):
+
+    async def test_tools_apikey(self):
+        async with self.getTestCore() as core:
+
+            await core.auth.addUser('blackout')
+
+            rooturl = core.getLocalUrl()
+            blckurl = core.getLocalUrl(user='blackout')
+
+            # Add API keys
+            argv = (
+                '--svcurl', rooturl,
+                'add',
+                'rootkey00',
+                '-d', '120',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+
+            self.isin('Successfully added API key with name=rootkey00.', str(outp))
+            rootkey00 = await getApiKeyByName(core, 'rootkey00')
+
+            self.isin(f'Iden: {rootkey00.get("iden")}', str(outp))
+            self.isin('  API Key: ', str(outp))
+            self.isin('  Name: rootkey00', str(outp))
+            self.isin(f'  Created: {s_time.repr(rootkey00.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(rootkey00.get("updated"))}', str(outp))
+            self.isin(f'  Expires: {s_time.repr(rootkey00.get("expires"))}', str(outp))
+            self.eq(rootkey00.get('expires'), rootkey00.get('created') + 120000)
+
+            argv = (
+                '--svcurl', rooturl,
+                'add',
+                '-u', 'blackout',
+                'blckkey00',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+
+            self.isin('Successfully added API key with name=blckkey00.', str(outp))
+            blckkey00 = await getApiKeyByName(core, 'blckkey00')
+
+            self.isin(f'Iden: {blckkey00.get("iden")}', str(outp))
+            self.isin('  API Key: ', str(outp))
+            self.isin('  Name: blckkey00', str(outp))
+            self.isin(f'  Created: {s_time.repr(blckkey00.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(blckkey00.get("updated"))}', str(outp))
+            self.notin('  Expires: ', str(outp))
+
+            argv = (
+                '--svcurl', blckurl,
+                'add',
+                'blckkey01',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+
+            self.isin('Successfully added API key with name=blckkey01.', str(outp))
+            blckkey01 = await getApiKeyByName(core, 'blckkey01')
+
+            self.isin(f'Iden: {blckkey01.get("iden")}', str(outp))
+            self.isin('  API Key: ', str(outp))
+            self.isin('  Name: blckkey01', str(outp))
+            self.isin(f'  Created: {s_time.repr(blckkey01.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(blckkey01.get("updated"))}', str(outp))
+            self.notin('  Expires: ', str(outp))
+
+            # List API keys
+            argv = (
+                '--svcurl', rooturl,
+                'list',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+
+            self.isin(f'Iden: {rootkey00.get("iden")}', str(outp))
+            self.notin('  API Key: ', str(outp))
+            self.isin('  Name: rootkey00', str(outp))
+            self.isin(f'  Created: {s_time.repr(rootkey00.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(rootkey00.get("updated"))}', str(outp))
+            self.isin(f'  Expires: {s_time.repr(rootkey00.get("expires"))}', str(outp))
+            self.eq(rootkey00.get('expires'), rootkey00.get('created') + 120000)
+
+            argv = (
+                '--svcurl', rooturl,
+                'list',
+                '-u', 'blackout',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+
+            self.isin(f'Iden: {blckkey00.get("iden")}', str(outp))
+            self.notin('  API Key: ', str(outp))
+            self.isin('  Name: blckkey00', str(outp))
+            self.isin(f'  Created: {s_time.repr(blckkey00.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(blckkey00.get("updated"))}', str(outp))
+            self.notin('  Expires: ', str(outp))
+
+            self.isin(f'Iden: {blckkey01.get("iden")}', str(outp))
+            self.notin('  API Key: ', str(outp))
+            self.isin('  Name: blckkey01', str(outp))
+            self.isin(f'  Created: {s_time.repr(blckkey01.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(blckkey01.get("updated"))}', str(outp))
+            self.notin('  Expires: ', str(outp))
+
+            argv = (
+                '--svcurl', blckurl,
+                'list',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+
+            self.isin(f'Iden: {blckkey00.get("iden")}', str(outp))
+            self.notin('  API Key: ', str(outp))
+            self.isin('  Name: blckkey00', str(outp))
+            self.isin(f'  Created: {s_time.repr(blckkey00.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(blckkey00.get("updated"))}', str(outp))
+            self.notin('  Expires: ', str(outp))
+
+            self.isin(f'Iden: {blckkey01.get("iden")}', str(outp))
+            self.notin('  API Key: ', str(outp))
+            self.isin('  Name: blckkey01', str(outp))
+            self.isin(f'  Created: {s_time.repr(blckkey01.get("created"))}', str(outp))
+            self.isin(f'  Updated: {s_time.repr(blckkey01.get("updated"))}', str(outp))
+            self.notin('  Expires: ', str(outp))
+
+            # Delete API keys
+            rootiden00 = rootkey00.get('iden')
+            argv = (
+                '--svcurl', rooturl,
+                'del',
+                rootiden00,
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+            self.isin(f'Successfully deleted API key with iden={rootiden00}.', str(outp))
+
+            blckiden00 = blckkey00.get('iden')
+            argv = (
+                '--svcurl', rooturl,
+                'del',
+                blckiden00,
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+            self.isin(f'Successfully deleted API key with iden={blckiden00}.', str(outp))
+
+            blckiden01 = blckkey01.get('iden')
+            argv = (
+                '--svcurl', blckurl,
+                'del',
+                blckiden01,
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+            self.isin(f'Successfully deleted API key with iden={blckiden01}.', str(outp))
+
+            # List API keys again
+            argv = (
+                '--svcurl', rooturl,
+                'list',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+            self.isin('No API keys found.', str(outp))
+
+            argv = (
+                '--svcurl', rooturl,
+                'list',
+                '-u', 'blackout',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+            self.isin('No API keys found.', str(outp))
+
+            argv = (
+                '--svcurl', blckurl,
+                'list',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(0, await s_t_apikey.main(argv, outp=outp))
+            self.isin('No API keys found.', str(outp))
+
+            # Check errors
+            argv = (
+                '--svcurl', rooturl,
+                'list',
+                '-u', 'newp',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(1, await s_t_apikey.main(argv, outp=outp))
+            self.isin('ERROR: NoSuchUser: No user named newp.', str(outp))
+
+            argv = (
+                '--svcurl', blckurl,
+                'list',
+                '-u', 'root',
+            )
+            outp = s_output.OutPutStr()
+            self.eq(1, await s_t_apikey.main(argv, outp=outp))
+            self.isin('ERROR: AuthDeny: getUserInfo denied for non-admin and non-self', str(outp))
+
+            newpiden = s_common.guid()
+            argv = (
+                '--svcurl', rooturl,
+                'del',
+                newpiden,
+            )
+            outp = s_output.OutPutStr()
+            self.eq(1, await s_t_apikey.main(argv, outp=outp))
+            self.isin(f"ERROR: NoSuchIden: User API key with iden='{newpiden}' does not exist.", str(outp))

synapse/tests/test_tools_storm.py

@@ -1,4 +1,9 @@
 import os
+import sys
+import signal
+import asyncio
+import multiprocessing
+
 import synapse.tests.utils as s_test
 
 from prompt_toolkit.document import Document
@@ -6,10 +11,49 @@ from prompt_toolkit.completion import Completion, CompleteEvent
 
 import synapse.exc as s_exc
 import synapse.common as s_common
+import synapse.telepath as s_telepath
+
+import synapse.lib.coro as s_coro
 import synapse.lib.output as s_output
 import synapse.lib.msgpack as s_msgpack
 import synapse.tools.storm as s_t_storm
 
+def run_cli_till_print(url, evt1):
+    '''
+    Run the stormCLI until we get a print mesg then set the event.
+
+    This is a Process target.
+    '''
+    async def main():
+        outp = s_output.OutPutStr()  # Capture output instead of sending it to stdout
+        async with await s_telepath.openurl(url) as proxy:
+            async with await s_t_storm.StormCli.anit(proxy, outp=outp) as scli:
+                cmdqueue = asyncio.Queue()
+                await cmdqueue.put('while (true) { $lib.print(go) $lib.time.sleep(1) }')
+                await cmdqueue.put('!quit')
+
+                async def fake_prompt():
+                    return await cmdqueue.get()
+
+                scli.prompt = fake_prompt
+
+                d = {'evt1': False}
+                async def onmesg(event):
+                    if d.get('evt1'):
+                        return
+                    mesg = event[1].get('mesg')
+                    if mesg[0] != 'print':
+                        return
+                    evt1.set()
+                    d['evt1'] = True
+
+                with scli.onWith('storm:mesg', onmesg):
+                    await scli.addSignalHandlers()
+                    await scli.runCmdLoop()
+
+    asyncio.run(main())
+    sys.exit(137)
+
 class StormCliTest(s_test.SynTest):
 
     async def test_tools_storm(self):
@@ -378,3 +422,54 @@ class StormCliTest(s_test.SynTest):
                 ),
                 vals
             )
+
+    async def test_storm_cmdloop_interrupt(self):
+        '''
+        Test interrupting a long-running query in the command loop
+        '''
+        async with self.getTestCore() as core:
+
+            async with core.getLocalProxy() as proxy:
+
+                outp = s_test.TstOutPut()
+                async with await s_t_storm.StormCli.anit(proxy, outp=outp) as scli:
+
+                    cmdqueue = asyncio.Queue()
+                    await cmdqueue.put('while (true) { $lib.time.sleep(1) }')
+                    await cmdqueue.put('!quit')
+
+                    async def fake_prompt():
+                        return await cmdqueue.get()
+                    scli.prompt = fake_prompt
+
+                    cmdloop_task = asyncio.create_task(scli.runCmdLoop())
+                    await asyncio.sleep(0.1)
+
+                    if scli.cmdtask is not None:
+                        scli.cmdtask.cancel()
+
+                    await cmdloop_task
+
+                    outp.expect('<ctrl-c>')
+                    outp.expect('o/')
+                    self.true(scli.isfini)
+
+    async def test_storm_cmdloop_sigint(self):
+        '''
+        Test interrupting a long-running query in the command loop with a process target and SIGINT.
+        '''
+
+        async with self.getTestCore() as core:
+            url = core.getLocalUrl()
+
+            ctx = multiprocessing.get_context('spawn')
+
+            evt1 = ctx.Event()
+
+            proc = ctx.Process(target=run_cli_till_print, args=(url, evt1,))
+            proc.start()
+
+            self.true(await s_coro.executor(evt1.wait, timeout=30))
+            os.kill(proc.pid, signal.SIGINT)
+            proc.join(timeout=30)
+            self.eq(proc.exitcode, 137)

synapse/tests/test_utils_getrefs.py

@@ -24,7 +24,7 @@ class TestUtilsGetrefs(s_utils.SynTest):
         cm = myvcr.use_cassette(fp)
         return cm
 
-    async def test_basics(self):
+    def test_basics(self):
 
         args = s_getrefs.parse_args([
             s_data.path('attack-flow', 'attack-flow-schema-2.0.0.json')