enable HMAC message signing by default in kernels

add session_aliases and session_flags to consolidate these settings

use new consolidated flags in parallel apps as well

add default_secure() function for use in apps where the default
behavior should be to enable HMAC signatures.

IPython/frontend/qt/console/qtconsoleapp.py

@@ -50,7 +50,7 b' from IPython.zmq.ipkernel import ('
     aliases as ipkernel_aliases,
     IPKernelApp
 )
-from IPython.zmq.session import Session
+from IPython.zmq.session import Session, default_secure
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 
 
@@ -551,6 +551,7 b' class IPythonQtConsoleApp(BaseIPythonApplication):'
     def initialize(self, argv=None):
         super(IPythonQtConsoleApp, self).initialize(argv)
         self.init_connection_file()
+        default_secure(self.config)
         self.init_ssh()
         self.init_kernel_manager()
         self.init_qt_elements()

IPython/parallel/apps/ipcontrollerapp.py

@@ -27,7 +27,6 b' import os'
 import socket
 import stat
 import sys
-import uuid
 
 from multiprocessing import Process
 
@@ -36,7 +35,6 b' from zmq.devices import ProcessMonitoredQueue'
 from zmq.log.handlers import PUBHandler
 from zmq.utils import jsonapi as json
 
-from IPython.config.application import boolean_flag
 from IPython.core.profiledir import ProfileDir
 
 from IPython.parallel.apps.baseapp import (
@@ -47,8 +45,10 b' from IPython.parallel.apps.baseapp import ('
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Instance, Unicode, Bool, List, Dict
 
-# from IPython.parallel.controller.controller import ControllerFactory
-from IPython.zmq.session import Session
+from IPython.zmq.session import (
+    Session, session_aliases, session_flags, default_secure
+)
+
 from IPython.parallel.controller.heartmonitor import HeartMonitor
 from IPython.parallel.controller.hub import HubFactory
 from IPython.parallel.controller.scheduler import TaskScheduler,launch_scheduler
@@ -109,20 +109,13 b' flags.update({'
                     'reuse existing json connection files')
 })
 
-flags.update(boolean_flag('secure', 'IPControllerApp.secure',
-    "Use HMAC digests for authentication of messages.",
-    "Don't authenticate messages."
-))
+flags.update(session_flags)
+
 aliases = dict(
-    secure = 'IPControllerApp.secure',
     ssh = 'IPControllerApp.ssh_server',
     enginessh = 'IPControllerApp.engine_ssh_server',
     location = 'IPControllerApp.location',
 
-    ident = 'Session.session',
-    user = 'Session.username',
-    keyfile = 'Session.keyfile',
-
     url = 'HubFactory.url',
     ip = 'HubFactory.ip',
     transport = 'HubFactory.transport',
@@ -134,6 +127,7 b' aliases = dict('
     hwm = 'TaskScheduler.hwm',
 )
 aliases.update(base_aliases)
+aliases.update(session_aliases)
 
 
 class IPControllerApp(BaseParallelApplication):
@@ -151,9 +145,6 b' class IPControllerApp(BaseParallelApplication):'
     reuse_files = Bool(False, config=True,
         help='Whether to reuse existing json connection files.'
     )
-    secure = Bool(True, config=True,
-        help='Whether to use HMAC digests for extra message authentication.'
-    )
     ssh_server = Unicode(u'', config=True,
         help="""ssh url for clients to use when connecting to the Controller
         processes. It should be of the form: [user@]server[:port]. The
@@ -225,6 +216,7 b' class IPControllerApp(BaseParallelApplication):'
     def load_config_from_json(self):
         """load config from existing json connector files."""
         c = self.config
+        self.log.debug("loading config from JSON")
         # load from engine config
         with open(os.path.join(self.profile_dir.security_dir, self.engine_json_file)) as f:
             cfg = json.loads(f.read())
@@ -249,28 +241,23 b' class IPControllerApp(BaseParallelApplication):'
             self.ssh_server = cfg['ssh']
         assert int(ports) == c.HubFactory.regport, "regport mismatch"
     
+    def load_secondary_config(self):
+        """secondary config, loading from JSON and setting defaults"""
+        if self.reuse_files:
+            try:
+                self.load_config_from_json()
+            except (AssertionError,IOError) as e:
+                self.log.error("Could not load config from JSON: %s" % e)
+                self.reuse_files=False
+        # switch Session.key default to secure
+        default_secure(self.config)
+        self.log.debug("Config changed")
+        self.log.debug(repr(self.config))
+        
     def init_hub(self):
         c = self.config
         
         self.do_import_statements()
-        reusing = self.reuse_files
-        if reusing:
-            try:
-                self.load_config_from_json()
-            except (AssertionError,IOError):
-                reusing=False
-        # check again, because reusing may have failed:
-        if reusing:
-            pass
-        elif self.secure:
-            key = str(uuid.uuid4())
-            # keyfile = os.path.join(self.profile_dir.security_dir, self.exec_key)
-            # with open(keyfile, 'w') as f:
-            #     f.write(key)
-            # os.chmod(keyfile, stat.S_IRUSR|stat.S_IWUSR)
-            c.Session.key = asbytes(key)
-        else:
-            key = c.Session.key = b''
         
         try:
             self.factory = HubFactory(config=c, log=self.log)
@@ -280,10 +267,10 b' class IPControllerApp(BaseParallelApplication):'
             self.log.error("Couldn't construct the Controller", exc_info=True)
             self.exit(1)
         
-        if not reusing:
+        if not self.reuse_files:
             # save to new json config files
             f = self.factory
-            cdict = {'exec_key' : key,
+            cdict = {'exec_key' : f.session.key,
                     'ssh' : self.ssh_server,
                     'url' : "%s://%s:%s"%(f.client_transport, f.client_ip, f.regport),
                     'location' : self.location
@@ -397,11 +384,11 b' class IPControllerApp(BaseParallelApplication):'
             handler.setLevel(self.log_level)
             self.log.addHandler(handler)
             self._log_handler = handler
-    # #
     
     def initialize(self, argv=None):
         super(IPControllerApp, self).initialize(argv)
         self.forward_logging()
+        self.load_secondary_config()
         self.init_hub()
         self.init_schedulers()
     

IPython/parallel/apps/ipengineapp.py

@@ -36,9 +36,12 b' from IPython.parallel.apps.baseapp import ('
     base_flags,
 )
 from IPython.zmq.log import EnginePUBHandler
+from IPython.zmq.session import (
+    Session, session_aliases, session_flags
+)
 
 from IPython.config.configurable import Configurable
-from IPython.zmq.session import Session
+
 from IPython.parallel.engine.engine import EngineFactory
 from IPython.parallel.engine.streamkernel import Kernel
 from IPython.parallel.util import disambiguate_url, asbytes
@@ -113,10 +116,6 b' aliases = dict('
     c = 'IPEngineApp.startup_command',
     s = 'IPEngineApp.startup_script',
 
-    ident = 'Session.session',
-    user = 'Session.username',
-    keyfile = 'Session.keyfile',
-
     url = 'EngineFactory.url',
     ssh = 'EngineFactory.sshserver',
     sshkey = 'EngineFactory.sshkey',
@@ -131,7 +130,10 b' aliases = dict('
 
 )
 aliases.update(base_aliases)
-
+aliases.update(session_aliases)
+flags = {}
+flags.update(base_flags)
+flags.update(session_flags)
 
 class IPEngineApp(BaseParallelApplication):
 
@@ -172,6 +174,7 b' class IPEngineApp(BaseParallelApplication):'
         logging to a central location.""")
 
     aliases = Dict(aliases)
+    flags = Dict(flags)
 
     # def find_key_file(self):
     #     """Set the key file.
@@ -214,12 +217,9 b' class IPEngineApp(BaseParallelApplication):'
         with open(self.url_file) as f:
             d = json.loads(f.read())
         
-        try:
-            config.Session.key
-        except AttributeError:
-            if d['exec_key']:
-                config.Session.key = asbytes(d['exec_key'])
-                
+        if 'exec_key' in d:
+            config.Session.key = asbytes(d['exec_key'])
+        
         try:
             config.EngineFactory.location
         except AttributeError:

IPython/zmq/kernelapp.py

@@ -38,7 +38,9 b' from IPython.utils.importstring import import_item'
 from IPython.zmq.entry_point import write_connection_file
 from IPython.zmq.heartbeat import Heartbeat
 from IPython.zmq.parentpoller import ParentPollerUnix, ParentPollerWindows
-from IPython.zmq.session import Session
+from IPython.zmq.session import (
+    Session, session_flags, session_aliases, default_secure,
+)
 
 
 #-----------------------------------------------------------------------------
@@ -68,6 +70,11 b' kernel_flags.update({'
             "redirect stderr to the null device"),
 })
 
+# inherit flags&aliases for Sessions
+kernel_aliases.update(session_aliases)
+kernel_flags.update(session_flags)
+
+
 
 #-----------------------------------------------------------------------------
 # Application class for starting a Kernel
@@ -186,7 +193,7 b' class KernelApp(BaseIPythonApplication):'
             self.connection_file = "kernel-%s.json"%os.getpid()
         
         self.load_connection_file()
-
+    
     def init_sockets(self):
         # Create a context, a session, and the kernel sockets.
         self.log.info("Starting the kernel at pid: %i", os.getpid())
@@ -228,6 +235,7 b' class KernelApp(BaseIPythonApplication):'
 
     def init_session(self):
         """create our session object"""
+        default_secure(self.config)
         self.session = Session(config=self.config, username=u'kernel')
 
     def init_blackhole(self):

IPython/zmq/session.py

@@ -43,6 +43,7 b' from zmq.utils import jsonapi'
 from zmq.eventloop.ioloop import IOLoop
 from zmq.eventloop.zmqstream import ZMQStream
 
+from IPython.config.application import Application, boolean_flag
 from IPython.config.configurable import Configurable, LoggingConfigurable
 from IPython.utils.importstring import import_item
 from IPython.utils.jsonutil import extract_dates, squash_dates, date_default
@@ -71,6 +72,7 b' def squash_unicode(obj):'
 #-----------------------------------------------------------------------------
 # globals and defaults
 #-----------------------------------------------------------------------------
+
 key = 'on_unknown' if jsonapi.jsonmod.__name__ == 'jsonlib' else 'default'
 json_packer = lambda obj: jsonapi.dumps(obj, **{key:date_default})
 json_unpacker = lambda s: extract_dates(jsonapi.loads(s))
@@ -81,9 +83,43 b' pickle_unpacker = pickle.loads'
 default_packer = json_packer
 default_unpacker = json_unpacker
 
-
 DELIM=b"<IDS|MSG>"
 
+
+#-----------------------------------------------------------------------------
+# Mixin tools for apps that use Sessions
+#-----------------------------------------------------------------------------
+
+session_aliases = dict(
+    ident = 'Session.session',
+    user = 'Session.username',
+    keyfile = 'Session.keyfile',
+)
+
+session_flags  = {
+    'secure' : ({'Session' : { 'key' : str_to_bytes(str(uuid.uuid4())),
+                            'keyfile' : '' }},
+        """Use HMAC digests for authentication of messages.
+        Setting this flag will generate a new UUID to use as the HMAC key.
+        """),
+    'no-secure' : ({'Session' : { 'key' : b'', 'keyfile' : '' }},
+        """Don't authenticate messages."""),
+}
+
+def default_secure(cfg):
+    """Set the default behavior for a config environment to be secure.
+    
+    If Session.key/keyfile have not been set, set Session.key to
+    a new random UUID.
+    """
+    
+    if 'Session' in cfg:
+        if 'key' in cfg.Session or 'keyfile' in cfg.Session:
+            return
+    # key/keyfile not specified, generate new UUID:
+    cfg.Session.key = str_to_bytes(str(uuid.uuid4()))
+
+
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
@@ -256,6 +292,7 b' class Session(Configurable):'
         help="""Username for the Session. Default is your system username.""")
 
     # message signature related traits:
+    
     key = CBytes(b'', config=True,
         help="""execution key, for extra authentication.""")
     def _key_changed(self, name, old, new):
@@ -272,6 +309,8 b' class Session(Configurable):'
         with open(new, 'rb') as f:
             self.key = f.read().strip()
 
+    # serialization traits:
+    
     pack = Any(default_packer) # the actual packer function
     def _pack_changed(self, name, old, new):
         if not callable(new):