Match server version of DM API proto.

chrome/browser/policy/test/policy_testserver.py

 # Copyright (c) 2012 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.
 
 """A bare-bones test server for testing cloud policy support.
 
 This implements a simple cloud policy test server that can be used to test
 chrome's device management service client. The policy information is read from
 the file named device_management in the server's data directory. It contains
 enforced and recommended policies for the device and user scope, and a list
@@ skipping 801 matching lines @@
     ids = self.server.ListMatchingComponents('google/chrome/extension')
     for settings_entity_id in ids:
       # Reuse the extension policy request, to trigger the same signature
       # type in the response.
       request.settings_entity_id = settings_entity_id
       fetch_response = response.response.add()
       self.ProcessCloudPolicy(request, token_info, fetch_response, username)
       # Don't do key rotations for these messages.
       fetch_response.ClearField('new_public_key')
       fetch_response.ClearField('new_public_key_signature')
-      fetch_response.ClearField('new_public_key_verification_signature')
+      fetch_response.ClearField(
+          'new_public_key_verification_signature_deprecated')
 
   def ProcessCloudPolicy(self, msg, token_info, response, username=None):
     """Handles a cloud policy request. (New protocol for policy requests.)
 
     Encodes the policy into protobuf representation, signs it and constructs
     the response.
 
     Args:
       msg: The CloudPolicyRequest message received from the client.
       token_info: The token extracted from the request.
@@ skipping 110 matching lines @@
         # Set the verification signature appropriate for the policy domain.
         # TODO(atwilson): Use the enrollment domain for public accounts when
         # we add key validation for ChromeOS (http://crbug.com/328038).
         if 'signatures' in signing_key:
           verification_sig = self.GetSignatureForDomain(
               signing_key['signatures'], policy_data.username)
 
           if verification_sig:
             assert len(verification_sig) == 256, \
                 'bad signature size: %d' % len(verification_sig)
-            response.new_public_key_verification_signature = verification_sig
+            response.new_public_key_verification_signature_deprecated = (
+                verification_sig)
 
         if req_key:
           response.new_public_key_signature = (
               bytes(req_key.hashAndSign(response.new_public_key)))
 
     return (200, response.SerializeToString())
 
   def GetSignatureForDomain(self, signatures, username):
     parsed_username = username.split("@", 1)
     if len(parsed_username) != 2:
@@ skipping 432 matching lines @@
                                   'load multiple keys into the server. If the '
                                   'server has multiple keys, it will rotate '
                                   'through them in at each request in a '
                                   'round-robin fashion. The server will '
                                   'use a canned key if none is specified '
                                   'on the command line. The test server will '
                                   'also look for a verification signature file '
                                   'in the same location: <filename>.sig and if '
                                   'present will add the signature to the '
                                   'policy blob as appropriate via the '
-                                  'new_public_key_verification_signature '
+                             'new_public_key_verification_signature_deprecated '
                                   'field.')
     self.option_parser.add_option('--log-level', dest='log_level',
                                   default='WARN',
                                   help='Log level threshold to use.')
     self.option_parser.add_option('--config-file', dest='config_file',
                                   help='Specify a configuration file to use '
                                   'instead of the default '
                                   '<data_dir>/device_management')
     self.option_parser.add_option('--server-base-url', dest='server_base_url',
                                   help='The server base URL to use when '
                                   'constructing URLs to return to the client.')
 
   def run_server(self):
     logger = logging.getLogger()
     logger.setLevel(getattr(logging, str(self.options.log_level).upper()))
     if (self.options.log_to_console):
       logger.addHandler(logging.StreamHandler())
     if (self.options.log_file):
       logger.addHandler(logging.FileHandler(self.options.log_file))
 
     testserver_base.TestServerRunner.run_server(self)
 
 
 if __name__ == '__main__':
   sys.exit(PolicyServerRunner().main())