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

synapse/lib/stormlib/auth.py

@@ -633,7 +633,7 @@ class UserProfile(s_stormtypes.Prim):
     async def deref(self, name):
         name = await s_stormtypes.tostr(name)
         self.runt.confirm(('auth', 'user', 'get', 'profile', name))
-        return copy.deepcopy(await self.runt.snap.core.getUserProfInfo(self.valu, name))
+        return await self.runt.snap.core.getUserProfInfo(self.valu, name)
 
     async def setitem(self, name, valu):
         name = await s_stormtypes.tostr(name)
@@ -654,7 +654,7 @@ class UserProfile(s_stormtypes.Prim):
 
     async def value(self):
         self.runt.confirm(('auth', 'user', 'get', 'profile'))
-        return copy.deepcopy(await self.runt.snap.core.getUserProfile(self.valu))
+        return await self.runt.snap.core.getUserProfile(self.valu)
 
 @s_stormtypes.registry.registerType
 class UserJson(s_stormtypes.Prim):
@@ -807,7 +807,7 @@ class UserVars(s_stormtypes.Prim):
 
     async def deref(self, name):
         name = await s_stormtypes.tostr(name)
-        return copy.deepcopy(await self.runt.snap.core.getUserVarValu(self.valu, name))
+        return await self.runt.snap.core.getUserVarValu(self.valu, name)
 
     async def setitem(self, name, valu):
         name = await s_stormtypes.tostr(name)
@@ -821,7 +821,7 @@ class UserVars(s_stormtypes.Prim):
 
     async def iter(self):
         async for name, valu in self.runt.snap.core.iterUserVars(self.valu):
-            yield name, copy.deepcopy(valu)
+            yield name, valu
             await asyncio.sleep(0)
 
 @s_stormtypes.registry.registerType
@@ -1596,6 +1596,181 @@ class LibAuth(s_stormtypes.Lib):
         perm = await s_stormtypes.toprim(perm)
         return self.runt.snap.core.getPermDef(perm)
 
+@s_stormtypes.registry.registerType
+class StormUserVarsDict(s_stormtypes.Prim):
+    '''
+    A Storm Primitive that maps the HiveDict interface to a user vars dictionary.
+    '''
+    _storm_locals = (
+        {'name': 'get', 'desc': 'Get the value for a user var.',
+         'type': {'type': 'function', '_funcname': '_get',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the var.', },
+                      {'name': 'default', 'type': 'prim', 'default': None,
+                       'desc': 'The default value to return if not set.', },
+                  ),
+                  'returns': {'type': 'prim', 'desc': 'The requested value.', }}},
+        {'name': 'pop', 'desc': 'Remove a user var value.',
+         'type': {'type': 'function', '_funcname': '_pop',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the var.', },
+                      {'name': 'default', 'type': 'prim', 'default': None,
+                       'desc': 'The default value to return if not set.', },
+                  ),
+                  'returns': {'type': 'prim', 'desc': 'The requested value.', }}},
+        {'name': 'set', 'desc': 'Set a user var value.',
+         'type': {'type': 'function', '_funcname': '_set',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the var to set.', },
+                      {'name': 'valu', 'type': 'prim', 'desc': 'The value to store.', },
+                  ),
+                  'returns': {'type': ['null', 'prim'],
+                              'desc': 'Old value of the var if it was previously set, or none.', }}},
+        {'name': 'list', 'desc': 'List the vars and their values.',
+         'type': {'type': 'function', '_funcname': '_list',
+                  'returns': {'type': 'list', 'desc': 'A list of tuples containing var, value pairs.', }}},
+    )
+    _storm_typename = 'user:vars:dict'
+    _ismutable = True
+
+    def __init__(self, runt, valu, path=None):
+        s_stormtypes.Prim.__init__(self, valu, path=path)
+        self.runt = runt
+        self.locls.update(self.getObjLocals())
+
+    def getObjLocals(self):
+        return {
+            'get': self._get,
+            'pop': self._pop,
+            'set': self._set,
+            'list': self._list,
+        }
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _get(self, name, default=None):
+        name = await s_stormtypes.tostr(name)
+        return await self.runt.snap.core.getUserVarValu(self.valu, name, default=default)
+
+    async def _pop(self, name, default=None):
+        name = await s_stormtypes.tostr(name)
+        return await self.runt.snap.core.popUserVarValu(self.valu, name, default=default)
+
+    async def _set(self, name, valu):
+        if not isinstance(name, str):
+            mesg = 'The name of a variable must be a string.'
+            raise s_exc.StormRuntimeError(mesg=mesg, name=name)
+
+        name = await s_stormtypes.tostr(name)
+        oldv = await self.runt.snap.core.getUserVarValu(self.valu, name)
+
+        valu = await s_stormtypes.toprim(valu)
+
+        await self.runt.snap.core.setUserVarValu(self.valu, name, valu)
+        return oldv
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _list(self):
+        valu = await self.value()
+        return list(valu.items())
+
+    async def iter(self):
+        async for name, valu in self.runt.snap.core.iterUserVars(self.valu):
+            yield name, valu
+            await asyncio.sleep(0)
+
+    async def value(self):
+        varz = {}
+        async for key, valu in self.runt.snap.core.iterUserVars(self.valu):
+            varz[key] = valu
+            await asyncio.sleep(0)
+
+        return varz
+
+@s_stormtypes.registry.registerType
+class StormUserProfileDict(s_stormtypes.Prim):
+    '''
+    A Storm Primitive that maps the HiveDict interface to a user profile dictionary.
+    '''
+    _storm_locals = (
+        {'name': 'get', 'desc': 'Get a user profile value.',
+         'type': {'type': 'function', '_funcname': '_get',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the user profile value.', },
+                      {'name': 'default', 'type': 'prim', 'default': None,
+                       'desc': 'The default value to return if not set.', },
+                  ),
+                  'returns': {'type': 'prim', 'desc': 'The requested value.', }}},
+        {'name': 'pop', 'desc': 'Remove a user profile value.',
+         'type': {'type': 'function', '_funcname': '_pop',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the user profile value.', },
+                      {'name': 'default', 'type': 'prim', 'default': None,
+                       'desc': 'The default value to return if not set.', },
+                  ),
+                  'returns': {'type': 'prim', 'desc': 'The requested value.', }}},
+        {'name': 'set', 'desc': 'Set a user profile value.',
+         'type': {'type': 'function', '_funcname': '_set',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the user profile value to set.', },
+                      {'name': 'valu', 'type': 'prim', 'desc': 'The value to store.', },
+                  ),
+                  'returns': {'type': ['null', 'prim'],
+                              'desc': 'Old value if it was previously set, or none.', }}},
+        {'name': 'list', 'desc': 'List the user profile vars and their values.',
+         'type': {'type': 'function', '_funcname': '_list',
+                  'returns': {'type': 'list', 'desc': 'A list of tuples containing var, value pairs.', }}},
+    )
+    _storm_typename = 'user:profile:dict'
+    _ismutable = True
+
+    def __init__(self, runt, valu, path=None):
+        s_stormtypes.Prim.__init__(self, valu, path=path)
+        self.runt = runt
+        self.locls.update(self.getObjLocals())
+
+    def getObjLocals(self):
+        return {
+            'get': self._get,
+            'pop': self._pop,
+            'set': self._set,
+            'list': self._list,
+        }
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _get(self, name, default=None):
+        name = await s_stormtypes.tostr(name)
+        return await self.runt.snap.core.getUserProfInfo(self.valu, name, default=default)
+
+    async def _pop(self, name, default=None):
+        name = await s_stormtypes.tostr(name)
+        return await self.runt.snap.core.popUserProfInfo(self.valu, name, default=default)
+
+    async def _set(self, name, valu):
+        if not isinstance(name, str):
+            mesg = 'The name of a variable must be a string.'
+            raise s_exc.StormRuntimeError(mesg=mesg, name=name)
+
+        name = await s_stormtypes.tostr(name)
+        oldv = await self.runt.snap.core.getUserProfInfo(self.valu, name)
+
+        valu = await s_stormtypes.toprim(valu)
+
+        await self.runt.snap.core.setUserProfInfo(self.valu, name, valu)
+        return oldv
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _list(self):
+        valu = await self.value()
+        return list(valu.items())
+
+    async def iter(self):
+        async for name, valu in self.runt.snap.core.iterUserProfInfo(self.valu):
+            yield name, valu
+            await asyncio.sleep(0)
+
+    async def value(self):
+        return await self.runt.snap.core.getUserProfile(self.valu)
+
 @s_stormtypes.registry.registerLib
 class LibUser(s_stormtypes.Lib):
     '''
@@ -1614,10 +1789,10 @@ class LibUser(s_stormtypes.Lib):
                   ),
                   'returns': {'type': 'boolean',
                               'desc': 'True if the user has the requested permission, false otherwise.', }}},
-        {'name': 'vars', 'desc': "Get a Hive dictionary representing the current user's persistent variables.",
-         'type': 'hive:dict', },
-        {'name': 'profile', 'desc': "Get a Hive dictionary representing the current user's profile information.",
-         'type': 'hive:dict', },
+        {'name': 'vars', 'desc': "Get a dictionary representing the current user's persistent variables.",
+         'type': 'auth:user:vars', },
+        {'name': 'profile', 'desc': "Get a dictionary representing the current user's profile information.",
+         'type': 'auth:user:profile', },
         {'name': 'iden', 'desc': 'The user GUID for the current storm user.', 'type': 'str'},
     )
     _storm_lib_path = ('user', )
@@ -1632,9 +1807,9 @@ class LibUser(s_stormtypes.Lib):
     def addLibFuncs(self):
         super().addLibFuncs()
         self.locls.update({
-            'vars': s_stormtypes.StormHiveDict(self.runt, self.runt.user.vars),
+            'vars': StormUserVarsDict(self.runt, self.runt.user.iden),
             'json': UserJson(self.runt, self.runt.user.iden),
-            'profile': s_stormtypes.StormHiveDict(self.runt, self.runt.user.profile),
+            'profile': StormUserProfileDict(self.runt, self.runt.user.iden),
         })
 
     @s_stormtypes.stormfunc(readonly=True)

synapse/lib/stormlib/cortex.py

@@ -20,8 +20,21 @@ stormcmds = [
         'storm': '''
         $apis = $lib.cortex.httpapi.list()
         if $apis {
-            $header = 'order iden                             owner                auth  runas  path'
-            $lib.print($header)
+            $config = (({
+                "separators": {
+                    'data:row': ''
+                },
+                "columns": [
+                    {'name': 'order', 'width': 5},
+                    {'name': 'iden', 'width': 32},
+                    {'name': 'owner', 'width': 20},
+                    {'name': 'auth', 'width': 5},
+                    {'name': 'runas', 'width': 6},
+                    {'name': 'path'},
+                ]
+            }))
+            $printer = $lib.tabular.printer($config)
+            $lib.print($printer.header())
             for ($n, $api) in $lib.iters.enum($apis) {
                 try {
                     $user = $api.owner.name
@@ -29,9 +42,7 @@ stormcmds = [
                     $user = `No user found ({$err.info.user})`
                 }
                 $auth = `{$api.authenticated}`
-                $order = `{$n}`
-                $mesg=`{$order.ljust(5)} {$api.iden} {$user.ljust(20)} {$auth.ljust(5)} {$api.runas.ljust(6)} {$api.path}`
-                $lib.print($mesg)
+                $lib.print($printer.row(($n, $api.iden, $user, $auth, $api.runas, $api.path)))
             }
         } else {
             $lib.print('No Extended HTTP API endpoints are registered.')

synapse/lib/stormlib/gen.py

@@ -136,6 +136,34 @@ class LibGen(s_stormtypes.Lib):
                       {'name': 'name', 'type': 'str', 'desc': 'The name of the place.'},
                   ),
                   'returns': {'type': 'node', 'desc': 'A geo:place node with the given name.'}}},
+        {'name': 'fileBytesBySha256',
+         'desc': 'Returns a file:bytes node by SHA256, adding the node if it does not exist.',
+         'type': {'type': 'function', '_funcname': '_storm_query',
+                  'args': (
+                      {'name': 'sha256', 'type': ['str', 'hash:sha256'], 'desc': 'The SHA256 fingerprint for the file:bytes node.'},
+                      {'name': 'try', 'type': 'boolean', 'default': False,
+                       'desc': 'Type normalization will fail silently instead of raising an exception.'},
+                  ),
+                  'returns': {'type': 'node', 'desc': 'A file:bytes node with the given SHA256.'}}},
+        {'name': 'cryptoX509CertBySha256',
+         'desc': 'Returns a crypto:x509:cert node by SHA256, adding the node if it does not exist.',
+         'type': {'type': 'function', '_funcname': '_storm_query',
+                  'args': (
+                      {'name': 'sha256', 'type': ['str', 'hash:sha256'], 'desc': 'The SHA256 fingerprint for the certificate.'},
+                      {'name': 'try', 'type': 'boolean', 'default': False,
+                       'desc': 'Type normalization will fail silently instead of raising an exception.'},
+                  ),
+                  'returns': {'type': 'node', 'desc': 'A crypto:x509:cert node with the given SHA256.'}}},
+        {'name': 'inetTlsServerCertByServerAndSha256',
+         'desc': 'Returns an inet:tls:servercert node by server and SHA256, adding the node if it does not exist.',
+         'type': {'type': 'function', '_funcname': '_storm_query',
+                  'args': (
+                      {'name': 'server', 'type': ['str', 'inet:server'], 'desc': 'The server associated with the x509 certificate.'},
+                      {'name': 'sha256', 'type': ['str', 'hash:sha256'], 'desc': 'The SHA256 fingerprint for the certificate.'},
+                      {'name': 'try', 'type': 'boolean', 'default': False,
+                       'desc': 'Type normalization will fail silently instead of raising an exception.'},
+                  ),
+                  'returns': {'type': 'node', 'desc': 'An inet:tls:servercert node with the given server and SHA256.'}}},
     )
     _storm_lib_path = ('gen',)
 
@@ -425,6 +453,58 @@ class LibGen(s_stormtypes.Lib):
             [ geo:place=(gen, name, $geoname) :name=$geoname ]
             return($node)
         }
+
+        function fileBytesBySha256(sha256, try=$lib.false) {
+            ($ok, $sha256) = $__maybeCast($try, hash:sha256, $sha256)
+            if (not $ok) { return() }
+
+            file:bytes=$sha256
+            return($node)
+
+            file:bytes:sha256=$sha256
+            return($node)
+
+            [ file:bytes=$sha256 ]
+            return($node)
+        }
+
+        function cryptoX509CertBySha256(sha256, try=$lib.false) {
+            ($ok, $sha256) = $__maybeCast($try, hash:sha256, $sha256)
+            if (not $ok) { return() }
+
+            $guid = $lib.guid(valu=$sha256)
+
+            // Try to lift crypto:x509:cert by guid
+            crypto:x509:cert=$guid
+            return($node)
+
+            // Try to lift crypto:x509:cert by sha256
+            crypto:x509:cert:sha256=$sha256
+            return($node)
+
+            // Try to lift crypto:x509:cert by file
+            file:bytes:sha256=$sha256 -> crypto:x509:cert:file
+            { -:sha256 [ :sha256 = $sha256 ] }
+            return($node)
+
+            // Create a new crypto:x509:cert with file and sha256
+            [ crypto:x509:cert=$guid
+                :file = $fileBytesBySha256($sha256)
+                :sha256 = $sha256
+            ]
+            return($node)
+        }
+
+        function inetTlsServerCertByServerAndSha256(server, sha256, try=$lib.false) {
+            ($ok, $server) = $__maybeCast($try, inet:server, $server)
+            if (not $ok) { return() }
+
+            $crypto = $cryptoX509CertBySha256($sha256, try=$try)
+            if (not $crypto) { return() }
+
+            [ inet:tls:servercert=($server, $crypto) ]
+            return($node)
+        }
     '''
 
 stormcmds = (

synapse/lib/stormlib/imap.py

@@ -50,6 +50,8 @@ class ImapLib(s_stormtypes.Lib):
                      'desc': 'The time to wait for all commands on the server to execute.'},
                     {'type': 'bool', 'name': 'ssl', 'default': True,
                      'desc': 'Use SSL to connect to the IMAP server.'},
+                    {'type': 'bool', 'name': 'ssl_verify', 'default': True,
+                     'desc': 'Perform SSL/TLS verification.'},
                 ),
                 'returns': {
                     'type': 'inet:imap:server',
@@ -69,17 +71,19 @@ class ImapLib(s_stormtypes.Lib):
             'connect': self.connect,
         }
 
-    async def connect(self, host, port=993, timeout=30, ssl=True):
+    async def connect(self, host, port=993, timeout=30, ssl=True, ssl_verify=True):
 
         self.runt.confirm(('storm', 'inet', 'imap', 'connect'))
 
         ssl = await s_stormtypes.tobool(ssl)
         host = await s_stormtypes.tostr(host)
         port = await s_stormtypes.toint(port)
+        ssl_verify = await s_stormtypes.tobool(ssl_verify)
         timeout = await s_stormtypes.toint(timeout, noneok=True)
 
         if ssl:
-            imap_cli = aioimaplib.IMAP4_SSL(host=host, port=port, timeout=timeout)
+            ctx = self.runt.snap.core.getCachedSslCtx(opts=None, verify=ssl_verify)
+            imap_cli = aioimaplib.IMAP4_SSL(host=host, port=port, timeout=timeout, ssl_context=ctx)
         else:
             imap_cli = aioimaplib.IMAP4(host=host, port=port, timeout=timeout)
 

synapse/lib/stormlib/model.py

@@ -919,8 +919,63 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                        'desc': 'Do not copy nodedata to the risk:vulnerable node.'},
                  ),
                  'returns': {'type': 'list', 'desc': 'A list of idens for the risk:vulnerable nodes.'}}},
+        {'name': 'inetSslCertToTlsServerCert', 'desc': '''
+            Create a inet:tls:servercert node from the provided inet:ssl:cert node.
+
+            Edits will be made to the inet:tls:servercert node in the current write layer.
+
+            Tags, tag properties, edges, and node data will be copied
+            to the inet:tls:servercert node. However, existing tag properties and
+            node data will not be overwritten.
+        ''',
+        'type': {'type': 'function', '_funcname': '_storm_query',
+                 'args': (
+                      {'name': 'n', 'type': 'node', 'desc': 'The inet:ssl:cert node to migrate.'},
+                      {'name': 'nodata', 'type': 'bool', 'default': False,
+                       'desc': 'Do not copy nodedata to the inet:tls:servercert node.'},
+                 ),
+                 'returns': {'type': 'node', 'desc': 'The newly created inet:tls:servercert node.'}}},
+
     )
     _storm_lib_path = ('model', 'migration', 's')
+    _storm_query = '''
+        function inetSslCertToTlsServerCert(n, nodata=$lib.false) {
+            $form = $n.form()
+            if ($form != 'inet:ssl:cert') {
+                $mesg = `$lib.model.migration.s.inetSslCertToTlsServerCert() only accepts inet:ssl:cert nodes, not {$form}`
+                $lib.raise(BadArg, $mesg)
+            }
+
+            $server = $n.props.server
+            $sha256 = { yield $n -> file:bytes -> hash:sha256 }
+
+            if $sha256 {
+
+                yield $lib.gen.inetTlsServerCertByServerAndSha256($server, $sha256)
+
+            } else {
+
+                // File doesn't have a :sha256, try to lift/create a crypto:x509:node based on the file link
+                $crypto = { yield $n -> file:bytes -> crypto:x509:cert:file }
+                if (not $crypto) {
+                    $crypto = {[ crypto:x509:cert=($n.props.file,) :file=$n.props.file ]}
+                }
+
+                [ inet:tls:servercert=($server, $crypto) ]
+
+            }
+
+            [ .seen ?= $n.props.".seen" ]
+
+            $lib.model.migration.copyTags($n, $node, overwrite=$lib.false)
+            $lib.model.migration.copyEdges($n, $node)
+            if (not $nodata) {
+                $lib.model.migration.copyData($n, $node, overwrite=$lib.false)
+            }
+
+            return($node)
+        }
+    '''
 
     def getObjLocals(self):
         return {

synapse/lib/stormlib/modelext.py

@@ -77,6 +77,27 @@ class LibModelExt(s_stormtypes.Lib):
                       {'name': 'model', 'type': 'dict', 'desc': 'A model dictionary from getExtModel().', },
                   ),
                   'returns': {'type': 'boolean'}}},
+        {'name': 'addEdge', 'desc': 'Add an extended edge definition to the data model.',
+         'type': {'type': 'function', '_funcname': 'addEdge',
+                  'args': (
+                      {'name': 'n1form', 'type': 'str',
+                       'desc': 'The form of the n1 node. May be "*" or null to specify "any".'},
+                      {'name': 'verb', 'type': 'str', 'desc': 'The edge verb, which must begin with "_".'},
+                      {'name': 'n2form', 'type': 'str',
+                       'desc': 'The form of the n2 node. May be "*" or null to specify "any".'},
+                      {'name': 'edgeinfo', 'type': 'dict', 'desc': 'A Synapse edge info dictionary.'},
+                  ),
+                  'returns': {'type': 'null'}}},
+        {'name': 'delEdge', 'desc': 'Remove an extended edge definition from the data model.',
+         'type': {'type': 'function', '_funcname': 'delEdge',
+                  'args': (
+                      {'name': 'n1form', 'type': 'str',
+                       'desc': 'The form of the n1 node. May be "*" or null to specify "any".'},
+                      {'name': 'verb', 'type': 'str', 'desc': 'The edge verb, which must begin with "_".'},
+                      {'name': 'n2form', 'type': 'str',
+                       'desc': 'The form of the n2 node. May be "*" or null to specify "any".'},
+                  ),
+                  'returns': {'type': 'null'}}},
     )
     _storm_lib_path = ('model', 'ext')
 
@@ -92,6 +113,8 @@ class LibModelExt(s_stormtypes.Lib):
             'delTagProp': self.delTagProp,
             'getExtModel': self.getExtModel,
             'addExtModel': self.addExtModel,
+            'addEdge': self.addEdge,
+            'delEdge': self.delEdge,
         }
 
     # TODO type docs in the new convention
@@ -163,3 +186,40 @@ class LibModelExt(s_stormtypes.Lib):
     async def addExtModel(self, model):
         model = await s_stormtypes.toprim(model)
         return await self.runt.snap.core.addExtModel(model)
+
+    async def addEdge(self, n1form, verb, n2form, edgeinfo):
+        verb = await s_stormtypes.tostr(verb)
+        n1form = await s_stormtypes.tostr(n1form, noneok=True)
+        n2form = await s_stormtypes.tostr(n2form, noneok=True)
+        edgeinfo = await s_stormtypes.toprim(edgeinfo)
+
+        if not (s_grammar.isEdgeVerb(verb) and verb.islower()):
+            mesg = f'Invalid edge verb {verb}'
+            raise s_exc.BadEdgeDef(mesg=mesg, n1form=n1form, verb=verb, n2form=n2form)
+
+        if n1form == '*':
+            n1form = None
+
+        if n2form == '*':
+            n2form = None
+
+        s_stormtypes.confirm(('model', 'edge', 'add'))
+        await self.runt.snap.core.addEdge((n1form, verb, n2form), edgeinfo)
+
+    async def delEdge(self, n1form, verb, n2form):
+        verb = await s_stormtypes.tostr(verb)
+        n1form = await s_stormtypes.tostr(n1form, noneok=True)
+        n2form = await s_stormtypes.tostr(n2form, noneok=True)
+
+        if not (s_grammar.isEdgeVerb(verb) and verb.islower()):
+            mesg = f'Invalid edge verb {verb}'
+            raise s_exc.BadEdgeDef(mesg=mesg, n1form=n1form, verb=verb, n2form=n2form)
+
+        if n1form == '*':
+            n1form = None
+
+        if n2form == '*':
+            n2form = None
+
+        s_stormtypes.confirm(('model', 'edge', 'del'))
+        await self.runt.snap.core.delEdge((n1form, verb, n2form))

synapse/lib/stormlib/smtp.py

@@ -96,6 +96,8 @@ class SmtpMessage(s_stormtypes.StormType):
                         'desc': 'Use the STARTTLS directive with the SMTP server.'},
                     {'name': 'timeout', 'type': 'int', 'default': 60,
                         'desc': 'The timeout (in seconds) to wait for message delivery.'},
+                    {'type': 'bool', 'name': 'ssl_verify', 'default': True,
+                     'desc': 'Perform SSL/TLS verification.'},
                   ),
                   'returns': {'type': 'list', 'desc': 'An ($ok, $valu) tuple.'}}},
 
@@ -148,7 +150,8 @@ class SmtpMessage(s_stormtypes.StormType):
     async def _getEmailHtml(self):
         return self.bodyhtml
 
-    async def send(self, host, port=25, user=None, passwd=None, usetls=False, starttls=False, timeout=60):
+    async def send(self, host, port=25, user=None, passwd=None, usetls=False, starttls=False, timeout=60,
+                   ssl_verify=True):
 
         self.runt.confirm(('storm', 'inet', 'smtp', 'send'))
 
@@ -161,6 +164,7 @@ class SmtpMessage(s_stormtypes.StormType):
             port = await s_stormtypes.toint(port)
             usetls = await s_stormtypes.tobool(usetls)
             starttls = await s_stormtypes.tobool(starttls)
+            ssl_verify = await s_stormtypes.tobool(ssl_verify)
 
             if usetls and starttls:
                 raise s_exc.BadArg(mesg='usetls and starttls are mutually exclusive arguments.')
@@ -183,6 +187,10 @@ class SmtpMessage(s_stormtypes.StormType):
 
             recipients = [await s_stormtypes.tostr(e) for e in self.recipients]
 
+            ctx = None
+            if usetls or starttls:
+                ctx = self.runt.snap.core.getCachedSslCtx(opts=None, verify=ssl_verify)
+
             futu = aiosmtplib.send(message,
                                    port=port,
                                    hostname=host,
@@ -191,7 +199,9 @@ class SmtpMessage(s_stormtypes.StormType):
                                    use_tls=usetls,
                                    start_tls=starttls,
                                    username=user,
-                                   password=passwd)
+                                   password=passwd,
+                                   tls_context=ctx,
+                                   )
 
             await s_common.wait_for(futu, timeout=timeout)