synapse 2.173.1__py311-none-any.whl → 2.175.0__py311-none-any.whl

synapse/lib/storm.py

@@ -14,6 +14,7 @@ import synapse.datamodel as s_datamodel
 import synapse.lib.ast as s_ast
 import synapse.lib.base as s_base
 import synapse.lib.chop as s_chop
+import synapse.lib.coro as s_coro
 import synapse.lib.node as s_node
 import synapse.lib.snap as s_snap
 import synapse.lib.time as s_time
@@ -3491,13 +3492,18 @@ class DiffCmd(Cmd):
         // Lift the nodes with the tag #cno.mal.redtree added in the top layer.
 
         diff --tag cno.mal.redtree
+
+        // Lift nodes by multiple tags (results are uniqued)
+
+        diff --tag cno.mal.redtree rep.vt
     '''
     name = 'diff'
     readonly = True
 
     def getArgParser(self):
         pars = Cmd.getArgParser(self)
-        pars.add_argument('--tag', default=None, help='Lift only nodes with the given tag in the top layer.')
+        pars.add_argument('--tag', default=None, nargs='*',
+                          help='Lift only nodes with the given tag (or tags) in the top layer.')
         pars.add_argument('--prop', default=None, help='Lift nodes with changes to the given property the top layer.')
         return pars
 
@@ -3516,10 +3522,11 @@ class DiffCmd(Cmd):
 
         if self.opts.tag:
 
-            tagname = await s_stormtypes.tostr(self.opts.tag)
+            tagnames = [await s_stormtypes.tostr(tag) for tag in self.opts.tag]
 
             layr = runt.snap.view.layers[0]
-            async for _, buid, sode in layr.liftByTag(tagname):
+
+            async for _, buid, sode in layr.liftByTags(tagnames):
                 node = await self.runt.snap._joinStorNode(buid, {layr.iden: sode})
                 if node is not None:
                     yield node, runt.initPath(node)
@@ -3765,73 +3772,76 @@ class MergeCmd(Cmd):
     def _getPropFilter(self):
         if self.opts.include_props:
 
+            _include_props = set(self.opts.include_props)
+
             def propfilter(prop):
-                if prop in self.opts.include_props:
-                    return False
-                return True
+                return prop not in _include_props
 
             return propfilter
 
         if self.opts.exclude_props:
 
+            _exclude_props = set(self.opts.exclude_props)
+
             def propfilter(prop):
-                if prop in self.opts.exclude_props:
-                    return True
-                return False
+                return prop in _exclude_props
 
             return propfilter
 
         return None
 
-    async def _checkNodePerms(self, node, sode, runt):
+    async def _checkNodePerms(self, node, sode, runt, allows):
 
         layr0 = runt.snap.view.layers[0].iden
         layr1 = runt.snap.view.layers[1].iden
 
-        if sode.get('valu') is not None:
+        if not allows['forms'] and sode.get('valu') is not None:
             runt.confirm(('node', 'del', node.form.name), gateiden=layr0)
             runt.confirm(('node', 'add', node.form.name), gateiden=layr1)
 
-        for name, (valu, stortype) in sode.get('props', {}).items():
-            prop = node.form.prop(name)
-            runt.confirmPropDel(prop, layriden=layr0)
-            runt.confirmPropSet(prop, layriden=layr1)
+        if not allows['props']:
+            for name in sode.get('props', {}).keys():
+                prop = node.form.prop(name)
+                runt.confirmPropDel(prop, layriden=layr0)
+                runt.confirmPropSet(prop, layriden=layr1)
+
+        if not allows['tags']:
+
+            tags = []
+            tagadds = []
+            for tag, valu in sode.get('tags', {}).items():
+                if valu != (None, None):
+                    tagadds.append(tag)
+                    tagperm = tuple(tag.split('.'))
+                    runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
+                    runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
+                else:
+                    tags.append((len(tag), tag))
+
+            for _, tag in sorted(tags, reverse=True):
+                look = tag + '.'
+                if any([tagadd.startswith(look) for tagadd in tagadds]):
+                    continue
 
-        tags = []
-        tagadds = []
-        for tag, valu in sode.get('tags', {}).items():
-            if valu != (None, None):
                 tagadds.append(tag)
                 tagperm = tuple(tag.split('.'))
                 runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
                 runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
-            else:
-                tags.append((len(tag), tag))
-
-        for _, tag in sorted(tags, reverse=True):
-            look = tag + '.'
-            if any([tagadd.startswith(look) for tagadd in tagadds]):
-                continue
-
-            tagadds.append(tag)
-            tagperm = tuple(tag.split('.'))
-            runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
-            runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
 
-        for tag, tagdict in sode.get('tagprops', {}).items():
-            for prop, (valu, stortype) in tagdict.items():
+            for tag in sode.get('tagprops', {}).keys():
                 tagperm = tuple(tag.split('.'))
                 runt.confirm(('node', 'tag', 'del') + tagperm, gateiden=layr0)
                 runt.confirm(('node', 'tag', 'add') + tagperm, gateiden=layr1)
 
-        async for name in runt.snap.view.layers[0].iterNodeDataKeys(node.buid):
-            runt.confirm(('node', 'data', 'pop', name), gateiden=layr0)
-            runt.confirm(('node', 'data', 'set', name), gateiden=layr1)
+        if not allows['ndata']:
+            async for name in runt.snap.view.layers[0].iterNodeDataKeys(node.buid):
+                runt.confirm(('node', 'data', 'pop', name), gateiden=layr0)
+                runt.confirm(('node', 'data', 'set', name), gateiden=layr1)
 
-        async for edge in runt.snap.view.layers[0].iterNodeEdgesN1(node.buid):
-            verb = edge[0]
-            runt.confirm(('node', 'edge', 'del', verb), gateiden=layr0)
-            runt.confirm(('node', 'edge', 'add', verb), gateiden=layr1)
+        if not allows['edges']:
+            async for verb in runt.snap.view.layers[0].iterNodeEdgeVerbsN1(node.buid):
+                runt.confirm(('node', 'edge', 'del', verb), gateiden=layr0)
+                runt.confirm(('node', 'edge', 'add', verb), gateiden=layr1)
 
     async def execStormCmd(self, runt, genr):
 
@@ -3841,12 +3851,31 @@ class MergeCmd(Cmd):
 
         notags = self.opts.no_tags
         onlytags = self.opts.only_tags
+        doapply = self.opts.apply
 
         tagfilter = self._getTagFilter()
         propfilter = self._getPropFilter()
 
-        layr0 = runt.snap.view.layers[0].iden
-        layr1 = runt.snap.view.layers[1].iden
+        layr0 = runt.snap.view.layers[0]
+        layr1 = runt.snap.view.layers[1]
+
+        doperms = doapply and not (runt.isAdmin(gateiden=layr0.iden) and runt.isAdmin(gateiden=layr1.iden))
+
+        if doperms:
+            allows = {
+                'forms': runt.user.allowed(('node', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'add'), gateiden=layr1.iden, deepdeny=True),
+                'props': runt.user.allowed(('node', 'prop', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'prop', 'set'), gateiden=layr1.iden, deepdeny=True),
+                'tags': runt.user.allowed(('node', 'tag', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                        runt.user.allowed(('node', 'tag', 'add'), gateiden=layr1.iden, deepdeny=True),
+                'ndata': runt.user.allowed(('node', 'data', 'pop'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'data', 'set'), gateiden=layr1.iden, deepdeny=True),
+                'edges': runt.user.allowed(('node', 'edge', 'del'), gateiden=layr0.iden, deepdeny=True) and
+                         runt.user.allowed(('node', 'edge', 'add'), gateiden=layr1.iden, deepdeny=True),
+            }
+
+            doperms = not all(allows.values())
 
         if self.opts.diff:
 
@@ -3854,7 +3883,7 @@ class MergeCmd(Cmd):
                 yield node, path
 
             async def diffgenr():
-                async for buid, sode in runt.snap.view.layers[0].getStorNodes():
+                async for buid, sode in layr0.getStorNodes():
                     node = await runt.snap.getNodeByBuid(buid)
                     if node is not None:
                         yield node, runt.initPath(node)
@@ -3873,33 +3902,19 @@ class MergeCmd(Cmd):
                 sodes = await node.getStorNodes()
                 sode = sodes[0]
 
-                if self.opts.apply:
+                if doapply:
                     editor = s_snap.SnapEditor(snap)
 
                 subs = []
 
-                async def sync():
-
-                    if not self.opts.apply:
-                        subs.clear()
-                        return
-
-                    addedits = editor.getNodeEdits()
-                    if addedits:
-                        await runt.snap.view.parent.storNodeEdits(addedits, meta=meta)
-
-                    if subs:
-                        subedits = [(node.buid, node.form.name, subs)]
-                        await runt.snap.view.storNodeEdits(subedits, meta=meta)
-                        subs.clear()
-
                 # check all node perms first
-                if self.opts.apply:
-                    await self._checkNodePerms(node, sode, runt)
+                if doperms:
+                    await self._checkNodePerms(node, sode, runt, allows)
 
                 form = node.form.name
                 if form == 'syn:tag':
                     if notags:
+                        await asyncio.sleep(0)
                         continue
                 else:
                     # avoid merging a tag if the node won't exist below us
@@ -3908,6 +3923,7 @@ class MergeCmd(Cmd):
                             if undr.get('valu') is not None:
                                 break
                         else:
+                            await asyncio.sleep(0)
                             continue
 
                 protonode = None
@@ -3916,23 +3932,24 @@ class MergeCmd(Cmd):
                     valu = sode.get('valu')
                     if valu is not None:
 
-                        if tagfilter and form == 'syn:tag' and tagfilter(valu[0]):
+                        if tagfilter is not None and form == 'syn:tag' and tagfilter(valu[0]):
+                            await asyncio.sleep(0)
                             continue
 
-                        if not self.opts.apply:
+                        if not doapply:
                             valurepr = node.form.type.repr(valu[0])
                             await runt.printf(f'{nodeiden} {form} = {valurepr}')
                         else:
                             delnode = True
                             protonode = await editor.addNode(form, valu[0])
 
-                    elif self.opts.apply:
+                    elif doapply:
                         protonode = await editor.addNode(form, node.ndef[1], norminfo={})
 
                     for name, (valu, stortype) in sode.get('props', {}).items():
 
                         prop = node.form.prop(name)
-                        if propfilter:
+                        if propfilter is not None:
                             if name[0] == '.':
                                 if propfilter(name):
                                     continue
@@ -3942,7 +3959,7 @@ class MergeCmd(Cmd):
 
                         if prop.info.get('ro'):
                             if name == '.created':
-                                if self.opts.apply:
+                                if doapply:
                                     protonode.props['.created'] = valu
                                     subs.append((s_layer.EDIT_PROP_DEL, (name, valu, stortype), ()))
                                 continue
@@ -3952,8 +3969,8 @@ class MergeCmd(Cmd):
                                 props = undr.get('props')
                                 if props is not None:
                                     curv = props.get(name)
-                                    if curv is not None and curv[0] != valu:
-                                        isset = True
+                                    if curv is not None:
+                                        isset = curv[0] != valu
                                         break
 
                             if isset:
@@ -3963,24 +3980,23 @@ class MergeCmd(Cmd):
                                 await runt.snap.warn(mesg)
                                 continue
 
-                        if not self.opts.apply:
+                        if not doapply:
                             valurepr = prop.type.repr(valu)
                             await runt.printf(f'{nodeiden} {form}:{name} = {valurepr}')
                         else:
                             await protonode.set(name, valu)
                             subs.append((s_layer.EDIT_PROP_DEL, (name, valu, stortype), ()))
 
-                if self.opts.apply and protonode is None:
+                if doapply and protonode is None:
                     protonode = await editor.addNode(form, node.ndef[1], norminfo={})
 
                 if not notags:
                     for tag, valu in sode.get('tags', {}).items():
 
-                        if tagfilter and tagfilter(tag):
+                        if tagfilter is not None and tagfilter(tag):
                             continue
 
-                        tagperm = tuple(tag.split('.'))
-                        if not self.opts.apply:
+                        if not doapply:
                             valurepr = ''
                             if valu != (None, None):
                                 tagrepr = runt.model.type('ival').repr(valu)
@@ -3992,12 +4008,11 @@ class MergeCmd(Cmd):
 
                     for tag, tagdict in sode.get('tagprops', {}).items():
 
-                        if tagfilter and tagfilter(tag):
+                        if tagfilter is not None and tagfilter(tag):
                             continue
 
                         for prop, (valu, stortype) in tagdict.items():
-                            tagperm = tuple(tag.split('.'))
-                            if not self.opts.apply:
+                            if not doapply:
                                 valurepr = repr(valu)
                                 await runt.printf(f'{nodeiden} {form}#{tag}:{prop} = {valurepr}')
                             else:
@@ -4006,31 +4021,33 @@ class MergeCmd(Cmd):
 
                 if not onlytags or form == 'syn:tag':
 
-                    layr = runt.snap.view.layers[0]
-                    async for name, valu in layr.iterNodeData(node.buid):
-                        if not self.opts.apply:
+                    async for name, valu in s_coro.pause(layr0.iterNodeData(node.buid)):
+                        if not doapply:
                             valurepr = repr(valu)
                             await runt.printf(f'{nodeiden} {form} DATA {name} = {valurepr}')
                         else:
                             await protonode.setData(name, valu)
                             subs.append((s_layer.EDIT_NODEDATA_DEL, (name, valu), ()))
-                            if len(subs) >= 1000:
-                                await asyncio.sleep(0)
 
-                    async for edge in layr.iterNodeEdgesN1(node.buid):
+                    async for edge in s_coro.pause(layr0.iterNodeEdgesN1(node.buid)):
                         name, dest = edge
-                        if not self.opts.apply:
+                        if not doapply:
                             await runt.printf(f'{nodeiden} {form} +({name})> {dest}')
                         else:
                             await protonode.addEdge(name, dest)
                             subs.append((s_layer.EDIT_EDGE_DEL, edge, ()))
-                            if len(subs) >= 1000:
-                                await asyncio.sleep(0)
 
                 if delnode:
                     subs.append((s_layer.EDIT_NODE_DEL, valu, ()))
 
-                await sync()
+                if doapply:
+                    addedits = editor.getNodeEdits()
+                    if addedits:
+                        await runt.snap.view.parent.storNodeEdits(addedits, meta=meta)
+
+                    if subs:
+                        subedits = [(node.buid, node.form.name, subs)]
+                        await runt.snap.view.storNodeEdits(subedits, meta=meta)
 
                 runt.snap.clearCachedNode(node.buid)
                 yield await runt.snap.getNodeByBuid(node.buid), path

synapse/lib/stormsvc.py

@@ -4,6 +4,7 @@ import logging
 import synapse.telepath as s_telepath
 
 import synapse.lib.base as s_base
+import synapse.lib.hashitem as s_hashitem
 
 logger = logging.getLogger(__name__)
 
@@ -139,32 +140,50 @@ class StormSvcClient(s_base.Base):
         self.core.svcsbysvcname[self.svcname] = self
 
         await self.core.feedBeholder('svc:set', {'name': self.name, 'iden': self.iden, 'svcname': self.svcname, 'version': self.svcvers})
+        # if the old service is the same as the new service, just skip
 
-        try:
-            await self.core._delStormSvcPkgs(self.iden)
-
-        except asyncio.CancelledError:  # pragma: no cover  TODO:  remove once >= py 3.8 only
-            raise
-
-        except Exception:
-            logger.exception(f'_delStormSvcPkgs failed for service {self.name} ({self.iden})')
+        oldpkgs = self.core.getStormSvcPkgs(self.iden)
+        byname = {}
+        done = set()
+        for pdef in oldpkgs:
+            iden = s_hashitem.hashitem(pdef)
+            byname[pdef.get('name')] = iden
 
         # Register new packages
         for pdef in self.info.get('pkgs', ()):
-
             try:
-                # push the svciden in the package metadata for later reference.
                 pdef['svciden'] = self.iden
                 await self.core._normStormPkg(pdef)
+            except Exception:
+                name = pdef.get('name')
+                logger.exception(f'normStormPkg ({name}) failed for service {self.name} ({self.iden})')
+                continue
+
+            name = pdef.get('name')
+            iden = s_hashitem.hashitem(pdef)
+
+            done.add(name)
+            if name in byname:
+                if byname[name] != iden:
+                    await self.core._delStormPkg(name)  # we're updating an old package, so delete the old and then re-add
+                else:
+                    continue  # pkg unchanged. Can skip.
+
+            try:
+                # push the svciden in the package metadata for later reference.
                 await self.core._addStormPkg(pdef)
 
             except asyncio.CancelledError:  # pragma: no cover  TODO:  remove once >= py 3.8 only
                 raise
 
             except Exception:
-                name = pdef.get('name')
                 logger.exception(f'addStormPkg ({name}) failed for service {self.name} ({self.iden})')
 
+        # clean up any packages that no longer exist
+        for name in byname.keys():
+            if name not in done:
+                await self.core._delStormPkg(name)
+
         # Set events and fire as needed
         evts = self.info.get('evts')
         try:

synapse/lib/stormtypes.py

@@ -18,7 +18,6 @@ import calendar
 import functools
 import contextlib
 import collections
-from typing import Any
 
 import synapse.exc as s_exc
 import synapse.common as s_common
@@ -8440,7 +8439,9 @@ class Trigger(Prim):
 
     async def set(self, name, valu):
         trigiden = self.valu.get('iden')
-        viewiden = self.runt.snap.view.iden
+        viewiden = self.valu.get('view')
+
+        view = self.runt.snap.core.reqView(viewiden)
 
         name = await tostr(name)
         if name in ('async', 'enabled', ):
@@ -8449,11 +8450,11 @@ class Trigger(Prim):
             valu = await tostr(valu)
 
         if name == 'user':
-            self.runt.user.confirm(('trigger', 'set', 'user'))
+            self.runt.confirm(('trigger', 'set', 'user'))
         else:
-            self.runt.user.confirm(('trigger', 'set', name), gateiden=viewiden)
+            self.runt.confirm(('trigger', 'set', name), gateiden=viewiden)
 
-        await self.runt.snap.view.setTriggerInfo(trigiden, name, valu)
+        await view.setTriggerInfo(trigiden, name, valu)
 
         self.valu[name] = valu
 
@@ -8825,6 +8826,8 @@ class LibCron(Lib):
          'desc': 'Permits a user to create a cron job.'},
         {'perm': ('cron', 'del'), 'gate': 'cronjob',
          'desc': 'Permits a user to remove a cron job.'},
+        {'perm': ('cron', 'kill'), 'gate': 'cronjob',
+         'desc': 'Controls the ability to terminate a running cron job.'},
         {'perm': ('cron', 'get'), 'gate': 'cronjob',
          'desc': 'Permits a user to list cron jobs.'},
         {'perm': ('cron', 'set'), 'gate': 'cronjob',
@@ -9276,14 +9279,19 @@ class CronJob(Prim):
                       {'name': 'valu', 'type': 'any', 'desc': 'The value to set on the definition.', },
                   ),
                   'returns': {'type': 'cronjob', 'desc': 'The ``cronjob``', }}},
+
+        {'name': 'kill', 'desc': 'If the job is currently running, terminate the task.',
+         'type': {'type': 'function', '_funcname': '_methCronJobKill',
+                  'returns': {'type': 'boolean', 'desc': 'A boolean value which is true if the task was terminated.'}}},
+
         {'name': 'pack', 'desc': 'Get the Cronjob definition.',
          'type': {'type': 'function', '_funcname': '_methCronJobPack',
-                  'returns': {'type': 'dict', 'desc': 'The definition.', }}},
+                  'returns': {'type': 'dict', 'desc': 'The definition.'}}},
         {'name': 'pprint', 'desc': 'Get a dictionary containing user friendly strings for printing the CronJob.',
          'type': {'type': 'function', '_funcname': '_methCronJobPprint',
                   'returns':
                       {'type': 'dict',
-                       'desc': 'A dictionary containing structured data about a cronjob for display purposes.', }}},
+                       'desc': 'A dictionary containing structured data about a cronjob for display purposes.'}}},
     )
     _storm_typename = 'cronjob'
     _ismutable = False
@@ -9300,10 +9308,16 @@ class CronJob(Prim):
     def getObjLocals(self):
         return {
             'set': self._methCronJobSet,
+            'kill': self._methCronJobKill,
             'pack': self._methCronJobPack,
             'pprint': self._methCronJobPprint,
         }
 
+    async def _methCronJobKill(self):
+        iden = self.valu.get('iden')
+        self.runt.confirm(('cron', 'kill'), gateiden=iden)
+        return await self.runt.snap.core.killCronTask(iden)
+
     async def _methCronJobSet(self, name, valu):
         name = await tostr(name)
         valu = await toprim(valu)
@@ -9312,9 +9326,9 @@ class CronJob(Prim):
         if name == 'creator':
             # this permission must be granted cortex wide
             # to prevent abuse...
-            self.runt.user.confirm(('cron', 'set', 'creator'))
+            self.runt.confirm(('cron', 'set', 'creator'))
         else:
-            self.runt.user.confirm(('cron', 'set', name), gateiden=iden)
+            self.runt.confirm(('cron', 'set', name), gateiden=iden)
 
         self.valu = await self.runt.snap.core.editCronJob(iden, name, valu)
 

synapse/lib/trigger.py

@@ -522,10 +522,6 @@ class Trigger:
                 logger.warning(f'Skipping trigger execution because user {self.user.iden} is locked')
             return
 
-        tag = self.tdef.get('tag')
-        cond = self.tdef.get('cond')
-        form = self.tdef.get('form')
-        prop = self.tdef.get('prop')
         storm = self.tdef.get('storm')
 
         query = await self.view.core.getStormQuery(storm)

synapse/lib/types.py

@@ -1402,7 +1402,7 @@ class Loc(Type):
 
 class Ndef(Type):
 
-    stortype = s_layer.STOR_TYPE_MSGP
+    stortype = s_layer.STOR_TYPE_NDEF
 
     def postTypeInit(self):
         self.setNormFunc(list, self._normPyTuple)

synapse/lib/version.py

@@ -223,6 +223,6 @@ def reqVersion(valu, reqver,
 ##############################################################################
 # The following are touched during the release process by bumpversion.
 # Do not modify these directly.
-version = (2, 173, 1)
+version = (2, 175, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '06b04fd5f58964b7897442d4c88cbfed145093d9'
+commit = 'c331c50ef1e7b2234be997c4b791fb8b8bed7cf2'

synapse/lib/view.py

@@ -1518,6 +1518,8 @@ class View(s_nexus.Pusher):  # type: ignore
         elif self.triggers.get(iden) is not None:
             raise s_exc.DupIden(mesg='A trigger with this iden already exists')
 
+        tdef['view'] = self.iden
+
         root = await self.core.auth.getUserByName('root')
 
         tdef.setdefault('created', s_common.now())

synapse/models/crypto.py

@@ -371,31 +371,53 @@ class CryptoModule(s_module.CoreModule):
                 ('crypto:algorithm', {}, ()),
 
                 ('crypto:key', {}, (
+
                     ('algorithm', ('crypto:algorithm', {}), {
                         'ex': 'aes256',
                         'doc': 'The cryptographic algorithm which uses the key material.'}),
+
                     ('mode', ('str', {'lower': True, 'onespace': True}), {
                         'doc': 'The algorithm specific mode in use.'}),
+
                     ('iv', ('hex', {}), {
                         'doc': 'The hex encoded initialization vector.'}),
+
+                    ('iv:text', ('it:dev:str', {}), {
+                        'doc': 'Set only if the :iv property decodes to ASCII.'}),
+
                     ('public', ('hex', {}), {
                         'doc': 'The hex encoded public key material if the algorithm has a public/private key pair.'}),
+
+                    ('public:text', ('it:dev:str', {}), {
+                        'doc': 'Set only if the :public property decodes to ASCII.'}),
+
                     ('public:md5', ('hash:md5', {}), {
                         'doc': 'The MD5 hash of the public key in raw binary form.'}),
+
                     ('public:sha1', ('hash:sha1', {}), {
                         'doc': 'The SHA1 hash of the public key in raw binary form.'}),
+
                     ('public:sha256', ('hash:sha256', {}), {
                         'doc': 'The SHA256 hash of the public key in raw binary form.'}),
+
                     ('private', ('hex', {}), {
                         'doc': 'The hex encoded private key material. All symmetric keys are private.'}),
+
+                    ('private:text', ('it:dev:str', {}), {
+                        'doc': 'Set only if the :private property decodes to ASCII.'}),
+
                     ('private:md5', ('hash:md5', {}), {
                         'doc': 'The MD5 hash of the private key in raw binary form.'}),
+
                     ('private:sha1', ('hash:sha1', {}), {
                         'doc': 'The SHA1 hash of the private key in raw binary form.'}),
+
                     ('private:sha256', ('hash:sha256', {}), {
                         'doc': 'The SHA256 hash of the private key in raw binary form.'}),
+
                     ('seed:passwd', ('inet:passwd', {}), {
                         'doc': 'The seed password used to generate the key material.'}),
+
                     ('seed:algorithm', ('crypto:algorithm', {}), {
                         'ex': 'pbkdf2',
                         'doc': 'The algorithm used to generate the key from the seed password.'})