Update tlslite to 0.4.6.

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 717 matching lines @@
       # know the user name belonging to the GAIA auth token we received (short
       # of actually talking to GAIA). To address this, we read the username from
       # the policy configuration dictionary, or use a default.
       policy_data.username = policy.get('policy_user', 'user@example.com')
     policy_data.device_id = token_info['device_id']
     signed_data = policy_data.SerializeToString()
 
     response.policy_data = signed_data
     if signing_key:
       response.policy_data_signature = (
-          signing_key['private_key'].hashAndSign(signed_data).tostring())
+          bytes(signing_key['private_key'].hashAndSign(signed_data)))
       if msg.public_key_version != current_key_index + 1:
         response.new_public_key = signing_key['public_key']
 
         # 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
 
         if req_key:
           response.new_public_key_signature = (
-              req_key.hashAndSign(response.new_public_key).tostring())
+              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:
       logging.error('Could not extract domain from username: %s' % username)
       return None
     domain = parsed_username[1]
 
@@ skipping 74 matching lines @@
       for key_path in private_key_paths:
         try:
           key_str = open(key_path).read()
         except IOError:
           print 'Failed to load private key from %s' % key_path
           continue
         try:
           key = tlslite.api.parsePEMKey(key_str, private=True)
         except SyntaxError:
           key = tlslite.utils.python_rsakey.Python_RSAKey._parsePKCS8(
-              tlslite.utils.cryptomath.stringToBytes(key_str))
+              bytearray(key_str))
 
         assert key is not None
         key_info = { 'private_key' : key }
 
         # Now try to read in a signature, if one exists.
         try:
           key_sig = open(key_path + '.sig').read()
           # Create a dictionary with the wildcard domain + signature
           key_info['signatures'] = {'*': key_sig}
         except IOError:
           print 'Failed to read validation signature from %s.sig' % key_path
         self.keys.append(key_info)
     else:
       # Use the canned private keys if none were passed from the command line.
       for signing_key in SIGNING_KEYS:
         decoded_key = base64.b64decode(signing_key['key']);
         key = tlslite.utils.python_rsakey.Python_RSAKey._parsePKCS8(
-            tlslite.utils.cryptomath.stringToBytes(decoded_key))
+            bytearray(decoded_key))
         assert key is not None
         # Grab the signature dictionary for this key and decode all of the
         # signatures.
         signature_dict = signing_key['signatures']
         decoded_signatures = {}
         for domain in signature_dict:
           decoded_signatures[domain] = base64.b64decode(signature_dict[domain])
         self.keys.append({'private_key': key,
                           'signatures': decoded_signatures})
 
@@ skipping 304 matching lines @@
     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())