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

synapse/tests/test_lib_stormlib_json.py

@@ -46,11 +46,13 @@ class JsonTest(s_test.SynTest):
             q = '''$schemaObj = $lib.json.schema($schema)
             $item=({})
             $item."key:integer"=(4)
+            $item."key:multi"=(4)
             return ( $schemaObj.validate($item) )
             '''
             isok, valu = await core.callStorm(q, opts=opts)
             self.true(isok)
             self.eq(4, valu.get('key:integer'))
+            self.eq(4, valu.get('key:multi'))
             self.eq('Default string!', valu.get('key:string'))
 
             q = '''$schemaObj = $lib.json.schema($schema)
@@ -68,12 +70,13 @@ class JsonTest(s_test.SynTest):
 
             q = '''
             $schemaObj = $lib.json.schema($schema, use_default=$lib.false)
-            $item = ({"key:integer": 4})
+            $item = ({"key:integer": 4, "key:multi": "4"})
             return($schemaObj.validate($item))
             '''
             isok, valu = await core.callStorm(q, opts={'vars': {'schema': s_test.test_schema}})
             self.true(isok)
             self.eq(4, valu.get('key:integer'))
+            self.eq('4', valu.get('key:multi'))
             self.notin('key:string', valu)
 
             # Print a json schema obj

synapse/tests/test_lib_stormlib_spooled.py

@@ -124,6 +124,17 @@ class StormlibSpooledTest(s_test.SynTest):
             msgs = await core.stormlist(q, opts={'vars': {'items': [True, 'neato', False, 9001]}})
             self.stormIsInPrint("The set is {'neato'}", msgs)
 
+            q = '''
+            $set = $lib.spooled.set()
+            for $v in $lib.range($n) {
+                $set.add($v)
+            }
+            if $set { return ( (true) ) }
+            else { return ( (false) ) }
+            '''
+            self.false(await core.callStorm(q, opts={'vars': {'n': 0}}))
+            self.true(await core.callStorm(q, opts={'vars': {'n': 1}}))
+
             # force a fallback
             q = '''
                 $set = $lib.spooled.set()

synapse/tests/test_lib_stormtypes.py

@@ -1902,6 +1902,17 @@ class StormTypesTest(s_test.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('test:str', 'asdf'))
 
+            q = '''
+            $set = $lib.set()
+            for $v in $lib.range($n) {
+                $set.add($v)
+            }
+            if $set { return ( (true) ) }
+            else { return ( (false) ) }
+            '''
+            self.false(await core.callStorm(q, opts={'vars': {'n': 0}}))
+            self.true(await core.callStorm(q, opts={'vars': {'n': 1}}))
+
             # test that some of the more complex objects we've got uniq down properly
             # Bool
             q = '''

synapse/tests/test_lib_types.py

@@ -338,42 +338,80 @@ class TypesTest(s_t_utils.SynTest):
             t = core.model.type('test:hexa')
             # Test norming to index values
             testvectors = [
-                ('0C', b'\x0c'),
-                ('0X010001', b'\x01\x00\x01'),
-                ('0FfF', b'\x0f\xff'),
-                ('f12A3e', b'\xf1\x2a\x3e'),
-                (b'\x01\x00\x01', b'\x01\x00\x01'),
+                (0xc, '0c'),
+                (-0xc, 'f4'),
+                ('c', '0c'),
+                ('0c', '0c'),
+                ('-0c', (s_exc.BadTypeValu, 'Non-hexadecimal digit found')),
+                ('0x0c', '0c'),
+                ('-0x0c', (s_exc.BadTypeValu, 'Non-hexadecimal digit found')),
+                (b'\x0c', '0c'),
+
+                (0x10001, '010001'),
+                ('10001', '010001'),
+                ('0x10001', '010001'),
+                ('010001', '010001'),
+                ('0x010001', '010001'),
+                (b'\x01\x00\x01', '010001'),
+
+                (0xFfF, '0fff'),
+                ('FfF', '0fff'),
+                ('0FfF', '0fff'),
+                ('0x0FfF', '0fff'),
+                (b'\x0F\xfF', '0fff'),
+
                 (b'\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\t\x98\xec\xf8B~',
-                 b'\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\t\x98\xec\xf8B~'),
-                (65537, s_exc.BadTypeValu),
+                 'd41d8cd98f00b204e9800998ecf8427e'),
+
+                ('01\udcfe0101', (s_exc.BadTypeValu, 'string argument should contain only ASCII characters')),
             ]
 
-            for v, b in testvectors:
-                if isinstance(b, bytes):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
-            # width = 4
+            # size = 4
             testvectors4 = [
-                ('d41d', b'\xd4\x1d'),
-                (b'\x10\x01', b'\x10\x01'),
-                ('01', s_exc.BadTypeValu),
-                ('010101', s_exc.BadTypeValu),
-                (b'\x10\x01\xff', s_exc.BadTypeValu),
-                (b'\xff', s_exc.BadTypeValu),
-                ('01\udcfe0101', s_exc.BadTypeValu),
+                (0xc, (s_exc.BadTypeValu, 'Invalid width.')),
+                (-0xc, (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0c', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0x0c', (s_exc.BadTypeValu, 'Invalid width.')),
+                (b'\x0c', (s_exc.BadTypeValu, 'Invalid width.')),
+
+                (0xd41d, 'd41d'),
+                ('d41d', 'd41d'),
+                ('0xd41d', 'd41d'),
+                (b'\xd4\x1d', 'd41d'),
+
+                (0x10001, (s_exc.BadTypeValu, 'Invalid width.')),
+                ('10001', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0x10001', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('010001', (s_exc.BadTypeValu, 'Invalid width.')),
+                ('0x010001', (s_exc.BadTypeValu, 'Invalid width.')),
+                (b'\x01\x00\x01', (s_exc.BadTypeValu, 'Invalid width.')),
+
+                ('01\udcfe0101', (s_exc.BadTypeValu, 'string argument should contain only ASCII characters')),
             ]
             t = core.model.type('test:hex4')
-            for v, b in testvectors4:
-                if isinstance(b, bytes):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors4:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
             # size = 8, zeropad = True
             testvectors = [
@@ -384,29 +422,45 @@ class TypesTest(s_t_utils.SynTest):
                 ('0X12345678', '12345678'),
                 ('56:78', '00005678'),
                 ('12:34:56:78', '12345678'),
-                ('::', s_exc.BadTypeValu),
-                ('0x::', s_exc.BadTypeValu),
-                ('0x1234qwer', s_exc.BadTypeValu),
-                ('0x123456789a', s_exc.BadTypeValu),
-                ('::', s_exc.BadTypeValu),
+                (-1, 'ffffffff'),
+                (-0xff, 'ffffff01'),
+                (1234, '000004d2'),
+                (0x12345678, '12345678'),
+                (0x123456789a, (s_exc.BadTypeValu, 'Invalid width.')),
+                ('::', (s_exc.BadTypeValu, 'No string left after stripping.')),
+                ('0x::', (s_exc.BadTypeValu, 'No string left after stripping.')),
+                ('0x1234qwer', (s_exc.BadTypeValu, 'Non-hexadecimal digit found')),
+                ('0x123456789a', (s_exc.BadTypeValu, 'Invalid width.')),
                 (b'\x12', '00000012'),
                 (b'\x12\x34', '00001234'),
                 (b'\x12\x34\x56', '00123456'),
                 (b'\x12\x34\x56\x78', '12345678'),
-                (b'\x12\x34\x56\x78\x9a', s_exc.BadTypeValu),
+                (b'\x12\x34\x56\x78\x9a', (s_exc.BadTypeValu, 'Invalid width.')),
             ]
             t = core.model.type('test:hexpad')
-            for v, b in testvectors:
-                if isinstance(b, (str, bytes)):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
-                    self.eq(r, b)
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
             # zeropad = 20
             testvectors = [
+                (-1, 'ffffffffffffffffffff'),
+                (-0xff, 'ffffffffffffffffff01'),
+                (0x12, '00000000000000000012'),
+                (0x123, '00000000000000000123'),
+                (0x1234, '00000000000000001234'),
+                (0x123456, '00000000000000123456'),
+                (0x12345678, '00000000000012345678'),
+                (0x123456789abcdef123456789abcdef, '123456789abcdef123456789abcdef'),
+                (-0x123456789abcdef123456789abcdef, 'edcba9876543210edcba9876543211'),
                 ('0x12', '00000000000000000012'),
                 ('0x123', '00000000000000000123'),
                 ('0x1234', '00000000000000001234'),
@@ -421,14 +475,17 @@ class TypesTest(s_t_utils.SynTest):
                 (b'\x12\x34\x56\x78\x9a\xbc\xde\xf1\x23\x45\x67\x89\xab\xcd\xef', '123456789abcdef123456789abcdef'),
             ]
             t = core.model.type('test:zeropad')
-            for v, b in testvectors:
-                if isinstance(b, (str, bytes)):
-                    r, subs = t.norm(v)
-                    self.isinstance(r, str)
+            for valu, expected in testvectors:
+                if isinstance(expected, str):
+                    norm, subs = t.norm(valu)
+                    self.isinstance(norm, str)
                     self.eq(subs, {})
-                    self.eq(r, b)
+                    self.eq(norm, expected)
                 else:
-                    self.raises(b, t.norm, v)
+                    etype, mesg = expected
+                    with self.raises(etype) as exc:
+                        t.norm(valu)
+                    self.eq(exc.exception.get('mesg'), mesg, f'{valu=}')
 
             # Do some node creation and lifting
             nodes = await core.nodes('[test:hexa="01:00 01"]')
@@ -436,8 +493,19 @@ class TypesTest(s_t_utils.SynTest):
             node = nodes[0]
             self.eq(node.ndef, ('test:hexa', '010001'))
             self.len(1, await core.nodes('test:hexa=010001'))
+            self.len(1, await core.nodes('test:hexa=(0x10001)'))
             self.len(1, await core.nodes('test:hexa=$byts', opts={'vars': {'byts': b'\x01\x00\x01'}}))
 
+            nodes = await core.nodes('[test:hexa=(-10)]')
+            self.len(1, nodes)
+            self.eq(nodes[0].repr(), 'f6')
+
+            self.len(1, await core.nodes('test:hexa=(-10)'))
+
+            with self.raises(s_exc.BadTypeValu) as exc:
+                await core.callStorm('test:hexa^=(-10)')
+            self.eq(exc.exception.get('mesg'), 'Hex prefix lift values must be str, not int.')
+
             # Do some fancy prefix searches for test:hexa
             valus = ['deadb33f',
                      'deadb33fb33f',
@@ -467,9 +535,25 @@ class TypesTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('[test:hexa=0xf00fb33b00000000]'))
             self.len(1, await core.nodes('test:hexa=0xf00fb33b00000000'))
             self.len(1, await core.nodes('test:hexa^=0xf00fb33b'))
+            self.len(1, await core.nodes('test:hexa^=0xf00fb33'))
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('test:hexa^=(0xf00fb33b)')
+
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('test:hexa^=(0xf00fb33)')
 
             # Check creating and lifting zeropadded hex types
-            self.len(3, await core.nodes('[test:zeropad=11 test:zeropad=0x22 test:zeropad=111]'))
+            q = '''
+            [
+                test:zeropad=11
+                test:zeropad=0x22
+                test:zeropad=111
+                test:zeropad=(0x33)
+                test:zeropad=(0x444)
+            ]
+            '''
+            self.len(5, await core.nodes(q))
             self.len(1, await core.nodes('test:zeropad=0x11'))
             self.len(1, await core.nodes('test:zeropad=0x111'))
             self.len(1, await core.nodes('test:zeropad=000000000011'))
@@ -479,6 +563,14 @@ class TypesTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('test:zeropad=000000000022'))
             self.len(1, await core.nodes('test:zeropad=00000000000000000022'))  # len=20
             self.len(0, await core.nodes('test:zeropad=0000000000000000000022'))  # len=22
+            self.len(1, await core.nodes('test:zeropad=(0x33)'))
+            self.len(1, await core.nodes('test:zeropad=000000000033'))
+            self.len(1, await core.nodes('test:zeropad=00000000000000000033'))  # len=20
+            self.len(0, await core.nodes('test:zeropad=0000000000000000000033'))  # len=22
+            self.len(1, await core.nodes('test:zeropad=(0x444)'))
+            self.len(1, await core.nodes('test:zeropad=000000000444'))
+            self.len(1, await core.nodes('test:zeropad=00000000000000000444'))  # len=20
+            self.len(0, await core.nodes('test:zeropad=0000000000000000000444'))  # len=22
 
     def test_int(self):
 

synapse/tests/test_model_crypto.py

@@ -545,6 +545,14 @@ class CryptoModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('identities:ipv4s'), (0x01020304, 0x05050505))
             self.eq(nodes[0].get('identities:ipv6s'), ('ff::11', 'ff::aa'))
 
+            nodes = await core.nodes('[ crypto:x509:cert=* :serial=(1234) ]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('serial'), '00000000000000000000000000000000000004d2')
+
+            nodes = await core.nodes('[ crypto:x509:cert=* :serial=(-1234) ]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('serial'), 'fffffffffffffffffffffffffffffffffffffb2e')
+
             nodes = await core.nodes('''
                 [
                     crypto:x509:crl=$crl

synapse/tests/test_model_inet.py

@@ -2908,10 +2908,10 @@ class InetModelTest(s_t_utils.SynTest):
                         :flow=*
                         :server=$server
                         :server:cert=*
-                        :server:fingerprint:ja3=$ja3s
+                        :server:ja3s=$ja3s
                         :client=$client
                         :client:cert=*
-                        :client:fingerprint:ja3=$ja3
+                        :client:ja3=$ja3
                 ]
             ''', opts={'vars': props})
             self.len(1, nodes)
@@ -2920,8 +2920,8 @@ class InetModelTest(s_t_utils.SynTest):
             self.nn(nodes[0].get('server:cert'))
             self.nn(nodes[0].get('client:cert'))
 
-            self.eq(props['ja3'], nodes[0].get('client:fingerprint:ja3'))
-            self.eq(props['ja3s'], nodes[0].get('server:fingerprint:ja3'))
+            self.eq(props['ja3'], nodes[0].get('client:ja3'))
+            self.eq(props['ja3s'], nodes[0].get('server:ja3s'))
 
             self.eq(props['client'], nodes[0].get('client'))
             self.eq(props['server'], nodes[0].get('server'))
@@ -3498,3 +3498,41 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(1, await core.nodes('inet:service:subscription -> inet:service:subscription:level:taxonomy'))
             self.len(1, await core.nodes('inet:service:subscription :pay:instrument -> econ:bank:account'))
             self.len(1, await core.nodes('inet:service:subscription :subscriber -> inet:service:tenant'))
+
+    async def test_model_inet_tls_ja4(self):
+
+        async with self.getTestCore() as core:
+
+            nodes = await core.nodes('[ inet:tls:ja4:sample=(1.2.3.4, t13d190900_9dc949149365_97f8aa674fd9) ]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('ja4'), 't13d190900_9dc949149365_97f8aa674fd9')
+            self.eq(nodes[0].get('client'), 'tcp://1.2.3.4')
+            self.len(1, await core.nodes('inet:tls:ja4:sample -> inet:client'))
+            self.len(1, await core.nodes('inet:tls:ja4:sample -> inet:tls:ja4'))
+
+            nodes = await core.nodes('[ inet:tls:ja4s:sample=(1.2.3.4:443, t130200_1301_a56c5b993250) ]')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('ja4s'), 't130200_1301_a56c5b993250')
+            self.eq(nodes[0].get('server'), 'tcp://1.2.3.4:443')
+            self.len(1, await core.nodes('inet:tls:ja4s:sample -> inet:server'))
+            self.len(1, await core.nodes('inet:tls:ja4s:sample -> inet:tls:ja4s'))
+
+            nodes = await core.nodes('''[
+                inet:tls:handshake=*
+                    :client:ja4=t13d190900_9dc949149365_97f8aa674fd9
+                    :server:ja4s=t130200_1301_a56c5b993250
+            ]''')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('client:ja4'), 't13d190900_9dc949149365_97f8aa674fd9')
+            self.eq(nodes[0].get('server:ja4s'), 't130200_1301_a56c5b993250')
+            self.len(1, await core.nodes('inet:tls:handshake :client:ja4 -> inet:tls:ja4'))
+            self.len(1, await core.nodes('inet:tls:handshake :server:ja4s -> inet:tls:ja4s'))
+
+            ja4_t = core.model.type('inet:tls:ja4')
+            ja4s_t = core.model.type('inet:tls:ja4s')
+            self.eq('t13d1909Tg_9dc949149365_97f8aa674fd9', ja4_t.norm(' t13d1909Tg_9dc949149365_97f8aa674fd9 ')[0])
+            self.eq('t1302Tg_1301_a56c5b993250', ja4s_t.norm(' t1302Tg_1301_a56c5b993250 ')[0])
+            with self.raises(s_exc.BadTypeValu):
+                ja4_t.norm('t13d190900_9dc949149365_97f8aa674fD9')
+            with self.raises(s_exc.BadTypeValu):
+                ja4s_t.norm('t130200_1301_a56c5B993250')

synapse/tests/test_telepath.py

@@ -316,6 +316,24 @@ class TeleTest(s_t_utils.SynTest):
         self.true(prox.isfini)
         await self.asyncraises(s_exc.IsFini, prox.bar((10, 20)))
 
+    async def test_telepath_openinfo_cell(self):
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn) as core:
+
+                layr00 = core.getView().layers[0]
+
+                async with await s_telepath.openurl(f'cell://root@{dirn}:*', name=f'*/layer/{layr00.iden}') as layer:
+                    self.eq(layr00.iden, await layer.getIden())
+
+    async def test_telepath_openinfo_unix(self):
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn) as core:
+
+                layr00 = core.getView().layers[0]
+
+                async with await s_telepath.openurl(f'unix://root@{dirn}/sock:*', name=f'*/layer/{layr00.iden}') as layer:
+                    self.eq(layr00.iden, await layer.getIden())
+
     async def test_telepath_sync_genr(self):
 
         foo = Foo()

synapse/tests/utils.py

@@ -987,6 +987,10 @@ test_schema = {
                 'description': 'Foo String',
                 'type': 'string',
             },
+            'key:multi': {
+                'description': 'String or integer',
+                'type': ['string', 'integer'],
+            }
         },
         'type': 'object',
     }

{synapse-2.211.0.dist-info → synapse-2.213.0.dist-info}/METADATA

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