[LNT] Request authentization for lnt submit command via secret_key in lnt.cfg file.

[marxin]

Summary

If I see correctly secret_key value in lnt.cfg is unused. I'm planning to install a new LNT instance and I would like to restrict machines which can actually do submissions.
I hope adding argument (--secret-key) to submit command can provide that.

Thoughts?

[cmatthews]

Secret key is used. That is the value that Flask is using to encrypt the cookies flask uses for sessions. It is also very secret, so we don't want it showing up outside the server config file.

Would make more sense to to use the api_auth_token that we use for other write operations. A config file option could be set to make that key needed on submissions as well.

[MatzeB]

I'd also recommend using the api_auth_token. Actually if you look at the Rest API you can see it supporting submissions only with api_auth_token set. I just never wanted to introduce this to the /submitRun pages to remain compatible with old clients.

About LNT authentication in general: api_auth_token is a very simple/poor mechanism. At the same time I'd really like to avoid for LNT to get into the game of authentication and the complexity that comes with it. How hard is it to do the authentication on the server level i.e. apache/nginx modules (either by setting them up as proxy servers or running the python app inside them)? Maybe the thing we should do is give some tips for this in the documentation and not implement any authentication inside LNT.

[marxin]

@MatzeB: Agree with you, restricting methods will be the easiest way how to achieve that:

https://httpd.apache.org/docs/2.4/mod/mod_allowmethods.html

docs/importing_data.rst

 test suite you are submitting to.
 
 Example::
 
     echo -n "foo.exec 25\nbar.score 24.2\nbar/baz.size 110.0\n" > results.txt
     lnt importreport --machine=my-machine-name --order=1234 --testsuite=nts results.txt report.json
     lnt submit http://mylnt.com/db_default/submitRun report.json
 
+LNT server can request authentization when ``secret_key`` is set in LNT config file.
+Auth token can be set via ``--secret-key=mykey`` option.
+
 .. _json_format:
 
 LNT Report File Format
 ----------------------
 
 The lnt importreport tool is an easy way to import data into LNTs test format.
 You can also create LNTs report data directly for additional flexibility.
 

lnt/lnttool/common.py

 from lnt.util import logger
 import click
 import logging
 
 
 def submit_options(func):
     func = click.option("--commit", type=int, help="deprecated/ignored option",
                         expose_value=False)(func)
     func = click.option("--select-machine", default='match',
                         type=click.Choice(['match', 'update', 'split']),
                         help="How to select and create missing machine")(func)
     func = click.option("--merge", default="replace", show_default=True,
                         type=click.Choice(['reject', 'replace', 'append']),
                         help="Merge strategy when run already exists")(func)
+    func = click.option("--secret-key",
+                        help="Secret key of the LNT server if secret_key is " \
+                                "set in LNT config")(func)
     return func
 
 
 def init_logger(loglevel, show_sql=False, stream=None):
     handler = logging.StreamHandler(stream)
     handler.setLevel(loglevel)
     handler.setFormatter(logging.Formatter(
         '%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S'))
     logger.addHandler(handler)
     logger.setLevel(loglevel)
 
     # Enable full SQL logging, if requested.
     if show_sql:
         sa_logger = logging.getLogger("sqlalchemy")
         sa_logger.setLevel(loglevel)
         sa_logger.addHandler(handler)

lnt/lnttool/main.py

 
 
 @click.command("submit")
 @click.argument("url")
 @click.argument("files", nargs=-1, type=click.Path(exists=True), required=True)
 @submit_options
 @click.option("--verbose", "-v", is_flag=True,
               help="show verbose test results")
-def action_submit(url, files, select_machine, merge, verbose):
+def action_submit(url, files, select_machine, merge, secret_key, verbose):
     """submit a test report to the server"""
     from lnt.util import ServerUtil
     import lnt.util.ImportData
 
     results = ServerUtil.submitFiles(url, files, verbose,
                                      select_machine=select_machine,
-                                     merge_run=merge)
+                                     merge_run=merge, secret_key=secret_key)
     for submitted_file in results:
         if verbose:
             lnt.util.ImportData.print_report_result(
                 submitted_file, sys.stdout, sys.stderr, True)
         _print_result_url(submitted_file, verbose)
     if len(files) != len(results):
         sys.exit(1)
 

lnt/server/ui/views.py

 def index():
     return render_template("index.html")
 
 
 ###
 # Database Actions
 def _do_submit():
     assert request.method == 'POST'
+
+    token = request.headers.get("AuthToken", None)
+    if current_app.old_config.secretKey \
+            and token != current_app.old_config.secretKey:
+                abort(401, "Auth Token must be passed in AuthToken header, "
+                        "and must match secret_key in LNT config.")
+
     input_file = request.files.get('file')
     input_data = request.form.get('input_data')
     if 'select_machine' not in request.form and \
             'update_machine' in request.form:
         # Compatibility with old clients
         update_machine = int(request.form.get('update_machine', 0)) != 0
         select_machine = 'update' if update_machine else 'match'
     else:

lnt/util/ServerUtil.py

except ValueError:
         print "error: {}".format(reply)
         return
     sys.stderr.write("error: lnt server: {}\n".format(error.get('error')))
     message = error.get('message', '')
     if message:
         sys.stderr.write(message + '\n')
 
 
-def submitFileToServer(url, file, select_machine=None, merge_run=None):
+def submitFileToServer(url, file, select_machine=None, merge_run=None,
+        secret_key=None):
     with open(file, 'rb') as f:
         values = {
             'input_data': f.read(),
             'commit': "1",  # compatibility with old servers.
         }
         if select_machine is not None:
             values['select_machine'] = select_machine
         if merge_run is not None:
             values['merge'] = merge_run
     headers = {'Accept': 'application/json'}
+    if secret_key:
+        headers['AuthToken'] = secret_key
     data = urllib.urlencode(values)
     try:
         response = urllib2.urlopen(urllib2.Request(url, data, headers=headers))
     except urllib2.HTTPError as e:
         _show_json_error(e.read())
         return
     except urllib2.URLError as e:
         sys.stderr.write("error: could not resolve '%s': %s\n" %
with contextlib.closing(config.get_database(db_name)) as db:
         if db is None:
             raise ValueError("no default database in instance: %r" % (path,))
         session = db.make_session()
         return lnt.util.ImportData.import_and_report(
             config, db_name, db, session, file, format='<auto>', ts_name='nts',
             select_machine=select_machine, merge_run=merge_run)
 
 
-def submitFile(url, file, verbose, select_machine=None, merge_run=None):
+def submitFile(url, file, verbose, select_machine=None, merge_run=None,
+        secret_key=None):
     # If this is a real url, submit it using urllib.
     if '://' in url:
-        result = submitFileToServer(url, file, select_machine, merge_run)
+        result = submitFileToServer(url, file, select_machine, merge_run,
+                secret_key)
     else:
         result = submitFileToInstance(url, file, select_machine, merge_run)
     return result
 
 
-def submitFiles(url, files, verbose, select_machine=None, merge_run=None):
+def submitFiles(url, files, verbose, select_machine=None, merge_run=None,
+        secret_key=None):
     results = []
     for file in files:
         result = submitFile(url, file, verbose, select_machine=select_machine,
-                            merge_run=merge_run)
+                            merge_run=merge_run, secret_key=secret_key)
         if result:
             results.append(result)
     return results