Support subdomain matching in trial tokens

tools/origin_trials/generate_token.py

 #!/usr/bin/env python
 # Copyright (c) 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Utility for generating experimental API tokens
 
 usage: generate_token.py [-h] [--key-file KEY_FILE]
                          [--expire-days EXPIRE_DAYS |
                           --expire-timestamp EXPIRE_TIMESTAMP]
+                         [--is_subdomain | --no-subdomain]
                          origin trial_name
 
 Run "generate_token.py -h" for more help on usage.
 """
 import argparse
 import base64
 from datetime import datetime
 import json
 import re
 import os
@@ skipping 57 matching lines @@
   if not port:
     port = {"https": 443, "http": 80}[origin.scheme]
   # Strip any extra components and return the origin URL:
   return "{0}://{1}:{2}".format(origin.scheme, origin.hostname, port)
 
 def ExpiryFromArgs(args):
   if args.expire_timestamp:
     return int(args.expire_timestamp)
   return (int(time.time()) + (int(args.expire_days) * 86400))
 
-def GenerateTokenData(origin, api_name, expiry):
-  return json.dumps({"origin": origin,
-                     "feature": api_name,
-                     "expiry": expiry}).encode('utf-8')
+def GenerateTokenData(origin, is_subdomain, feature_name, expiry):
+  data = {"origin": origin,
+          "feature": feature_name,
+          "expiry": expiry}
+  if is_subdomain is not None:

[iclelland, 2016/10/13 15:51:23]

Could this be just
    if is_subdomain:
?
(Is there any need to store false values in the token?)

[chasej, 2016/10/13 16:05:42]

There isn't an obvious need - I debated back and forth. For testing purposes, I
wanted the ability to explicitly set it to false. Same reason for having the
--no-subdomain flag - unlikely it will be used for production tokens.

[iclelland, 2016/10/13 16:06:46]

sgtm

+    data["isSubdomain"] = is_subdomain
+  return json.dumps(data).encode('utf-8')
 
 def GenerateDataToSign(version, data):
   return version + struct.pack(">I",len(data)) + data
 
 def Sign(private_key, data):
   return ed25519.signature(data, private_key[:32], private_key[32:])
 
 def FormatToken(version, signature, data):
   return base64.b64encode(version + signature +
                           struct.pack(">I",len(data)) + data)
 
 def main():
   default_key_file_absolute = os.path.join(script_dir, DEFAULT_KEY_FILE)
 
   parser = argparse.ArgumentParser(
-      description="Generate tokens for enabling experimental APIs")
+      description="Generate tokens for enabling experimental features")
   parser.add_argument("origin",
-                      help="Origin for which to enable the API. This can be "
-                           "either a hostname (default scheme HTTPS, default "
-                           "port 443) or a URL.",
+                      help="Origin for which to enable the feature. This can "
+                           "be either a hostname (default scheme HTTPS, "
+                           "default port 443) or a URL.",
                       type=OriginFromArg)
   parser.add_argument("trial_name",
                       help="Feature to enable. The current list of "
                            "experimental feature trials can be found in "
                            "RuntimeFeatures.in")
   parser.add_argument("--key-file",
                       help="Ed25519 private key file to sign the token with",
                       default=default_key_file_absolute)
+
+  subdomain_group = parser.add_mutually_exclusive_group()
+  subdomain_group.add_argument("--is-subdomain",
+                               help="Token will enable the feature for all "
+                                    "subdomains that match the origin",
+                               dest="is_subdomain",
+                               action="store_true")
+  subdomain_group.add_argument("--no-subdomain",
+                               help="Token will only match the specified "
+                                    "origin (default behavior)",
+                               dest="is_subdomain",
+                               action="store_false")
+  parser.set_defaults(is_subdomain=None)
+
   expiry_group = parser.add_mutually_exclusive_group()
   expiry_group.add_argument("--expire-days",
-                            help="Days from now when the token should exipire",
+                            help="Days from now when the token should expire",
                             type=int,
                             default=42)
   expiry_group.add_argument("--expire-timestamp",
                             help="Exact time (seconds since 1970-01-01 "
-                                 "00:00:00 UTC) when the token should exipire",
+                                 "00:00:00 UTC) when the token should expire",
                             type=int)
 
   args = parser.parse_args()
   expiry = ExpiryFromArgs(args)
 
   key_file = open(os.path.expanduser(args.key_file), mode="rb")
   private_key = key_file.read(64)
 
   # Validate that the key file read was a proper Ed25519 key -- running the
   # publickey method on the first half of the key should return the second
   # half.
   if (len(private_key) < 64 or
     ed25519.publickey(private_key[:32]) != private_key[32:]):
     print("Unable to use the specified private key file.")
     sys.exit(1)
 
-  token_data = GenerateTokenData(args.origin, args.trial_name, expiry)
+  token_data = GenerateTokenData(args.origin, args.is_subdomain,
+                                 args.trial_name, expiry)
   data_to_sign = GenerateDataToSign(VERSION, token_data)
   signature = Sign(private_key, data_to_sign)
 
   # Verify that that the signature is correct before printing it.
   try:
     ed25519.checkvalid(signature, data_to_sign, private_key[32:])
   except Exception, exc:
     print "There was an error generating the signature."
     print "(The original error was: %s)" % exc
     sys.exit(1)
 
 
   # Output the token details
   print "Token details:"
   print " Origin: %s" % args.origin
+  print " Is Subdomain: %s" % args.is_subdomain
   print " Feature: %s" % args.trial_name
   print " Expiry: %d (%s UTC)" % (expiry, datetime.utcfromtimestamp(expiry))
   print
 
   # Output the properly-formatted token.
   print FormatToken(VERSION, signature, token_data)
 
 if __name__ == "__main__":
   main()