| # Copyright 2015 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """The DRM Keys Provisioning Server (DKPS) implementation.""" |
| |
| # TODO(littlecvr): Implement "without filter mode", which lets OEM encrypts DRM |
| # keys directly with ODM's public key, and the key server |
| # merely stores them without knowing anything about them. |
| |
| from __future__ import print_function |
| |
| import argparse |
| import hashlib |
| import imp |
| import json |
| import logging |
| import logging.config |
| import os |
| import shutil |
| import SimpleXMLRPCServer |
| import sqlite3 |
| import textwrap |
| |
| import gnupg |
| |
| |
| SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__)) |
| FILTERS_DIR = os.path.join(SCRIPT_DIR, 'filters') |
| PARSERS_DIR = os.path.join(SCRIPT_DIR, 'parsers') |
| CREATE_DATABASE_SQL_FILE_PATH = os.path.join( |
| SCRIPT_DIR, 'sql', 'create_database.sql') |
| |
| DEFAULT_BIND_ADDR = '0.0.0.0' # all addresses |
| DEFAULT_BIND_PORT = 5438 |
| |
| DEFAULT_DATABASE_FILE_NAME = 'dkps.db' |
| DEFAULT_GNUPG_DIR_NAME = 'gnupg' |
| DEFAULT_LOG_FILE_NAME = 'dkps.log' |
| |
| DEFAULT_LOGGING_CONFIG = { |
| 'version': 1, |
| 'formatters': { |
| 'default': { |
| 'format': '%(asctime)s:%(levelname)s:%(funcName)s:' |
| '%(lineno)d:%(message)s'}}, |
| 'handlers': { |
| 'file': { |
| 'class': 'logging.handlers.RotatingFileHandler', |
| 'formatter': 'default', |
| 'filename': DEFAULT_LOG_FILE_NAME, |
| 'maxBytes': 1024 * 1024, # 1M |
| 'backupCount': 3}, |
| 'console': { |
| 'class': 'logging.StreamHandler', |
| 'formatter': 'default', |
| 'stream': 'ext://sys.stdout'}}, |
| 'root': { |
| 'level': 'INFO', |
| # only log to file by default, but also log to console if invoked |
| # directly from the command line |
| 'handlers': ['file'] + ['console'] if __name__ == '__main__' else []}} |
| |
| |
| class ProjectNotFoundException(ValueError): |
| """Raised when no project was found in the database.""" |
| pass |
| |
| |
| class InvalidUploaderException(ValueError): |
| """Raised when the signature of the uploader can't be verified.""" |
| pass |
| |
| |
| class InvalidRequesterException(ValueError): |
| """Raised when the signature of the requester can't be verified.""" |
| pass |
| |
| |
| def GetSQLite3Connection(database_file_path): |
| """Returns a tuple of SQLite3's (connection, cursor) to database_file_path. |
| |
| If the connection has been created before, it is returned directly. If it's |
| not, this function creates the connection, ensures that the foreign key |
| constraint is enabled, and returns. |
| |
| Args: |
| database_file_path: path to the SQLite3 database file. |
| """ |
| database_file_path = os.path.realpath(database_file_path) |
| |
| # Return if the connection to database_file_path has been created before. |
| try: |
| connection = GetSQLite3Connection.connection_dict[database_file_path] |
| return (connection, connection.cursor()) |
| except KeyError: |
| pass |
| except AttributeError: |
| GetSQLite3Connection.connection_dict = {} |
| |
| # Create connection. |
| connection = sqlite3.connect(database_file_path) |
| connection.row_factory = sqlite3.Row |
| cursor = connection.cursor() |
| |
| # Enable foreign key constraint since SQLite3 disables it by default. |
| cursor.execute('PRAGMA foreign_keys = ON') |
| # Check if foreign key constraint is enabled. |
| cursor.execute('PRAGMA foreign_keys') |
| if cursor.fetchone()[0] != 1: |
| raise RuntimeError('Failed to enable SQLite3 foreign key constraint') |
| |
| GetSQLite3Connection.connection_dict[database_file_path] = connection |
| |
| return (connection, cursor) |
| |
| |
| class DRMKeysProvisioningServer(object): |
| """The DRM Keys Provisioning Server (DKPS) class.""" |
| |
| def __init__(self, database_file_path, gnupg_homedir): |
| """DKPS constructor. |
| |
| Args: |
| database_file_path: path to the SQLite3 database file. |
| gnupg_homedir: path to the GnuPG home directory. |
| """ |
| self.database_file_path = database_file_path |
| self.gnupg_homedir = gnupg_homedir |
| |
| if not os.path.isdir(self.gnupg_homedir): |
| self.gpg = None |
| else: |
| self.gpg = gnupg.GPG(gnupghome=self.gnupg_homedir) |
| |
| if not os.path.isfile(self.database_file_path): |
| self.db_connection, self.db_cursor = (None, None) |
| else: |
| self.db_connection, self.db_cursor = GetSQLite3Connection( |
| self.database_file_path) |
| |
| def Initialize(self, gpg_gen_key_args_dict=None, server_key_file_path=None): |
| """Creates the SQLite3 database and GnuPG home, and imports, or generates a |
| GPG key for the server to use. |
| |
| Args: |
| gpg_gen_key_args_dict: will be passed directly as the keyword arguments to |
| python-gnupg's gen_key() function if server_key_file_path is None. |
| Can be used to customize the key generator process, such as key_type, |
| key_length, etc. See python-gnupg's doc for what can be customized. |
| server_key_file_path: path to the server key to use. If not None, the |
| system will simply import this key and use it as the server key; if |
| None, the system will generate a new key. |
| |
| Raises: |
| RuntimeError is the database and GnuPG home have already been initialized. |
| """ |
| # Create GPG instance and database connection. |
| self.gpg = gnupg.GPG(gnupghome=self.gnupg_homedir) |
| self.db_connection, self.db_cursor = GetSQLite3Connection( |
| self.database_file_path) |
| |
| # If any key exists, the system has already been initialized. |
| if self.gpg.list_keys(): |
| raise RuntimeError('Already initialized') |
| |
| if server_key_file_path: # use existing key |
| # TODO(littlecvr): make sure the server key doesn't have passphrase. |
| server_key_fingerprint, _ = self._ImportGPGKey(server_key_file_path) |
| else: # generate a new GPG key |
| if gpg_gen_key_args_dict is None: |
| gpg_gen_key_args_dict = {} |
| if 'name_real' not in gpg_gen_key_args_dict: |
| gpg_gen_key_args_dict['name_real'] = 'DKPS Server' |
| if 'name_email' not in gpg_gen_key_args_dict: |
| gpg_gen_key_args_dict['name_email'] = 'chromeos-factory-dkps@google.com' |
| if 'name_comment' not in gpg_gen_key_args_dict: |
| gpg_gen_key_args_dict['name_comment'] = 'DRM Keys Provisioning Server' |
| key_input_data = self.gpg.gen_key_input(**gpg_gen_key_args_dict) |
| server_key_fingerprint = self.gpg.gen_key(key_input_data).fingerprint |
| |
| # Create and set up the schema of the database. |
| with open(CREATE_DATABASE_SQL_FILE_PATH) as f: |
| create_database_sql = f.read() |
| with self.db_connection: |
| self.db_cursor.executescript(create_database_sql) |
| |
| # Record the server key fingerprint. |
| with self.db_connection: |
| self.db_cursor.execute( |
| 'INSERT INTO settings (key, value) VALUES (?, ?)', |
| ('server_key_fingerprint', server_key_fingerprint)) |
| |
| def Destroy(self): |
| """Destroys the database and GnuPG home directory. |
| |
| This is the opposite of Initialize(). It essentially removes the SQLite3 |
| database file and GnuPG home directory. |
| """ |
| # Remove database. |
| if self.db_connection: |
| self.db_connection.close() |
| if os.path.exists(self.database_file_path): |
| os.remove(self.database_file_path) |
| |
| # Remove GnuPG home. |
| if self.gpg: |
| self.gpg = None |
| if os.path.exists(self.gnupg_homedir): |
| shutil.rmtree(self.gnupg_homedir) |
| |
| def AddProject(self, name, uploader_key_file_path, requester_key_file_path, |
| parser_module_file_name, filter_module_file_name=None): |
| """Adds a project. |
| |
| Args: |
| name: name of the project, must be unique. |
| uploader_key_file_path: path to the OEM's public key file. |
| requester_key_file_path: path to the ODM's public key file. |
| parser_module_file_name: file name of the parser python module. |
| filter_module_file_name: file name of the filter python module. |
| |
| Raises: |
| ValueError if either the uploader's or requester's key are imported (which |
| means they are used by another project). |
| """ |
| # Try to load the parser and filter modules. |
| self._LoadParserModule(parser_module_file_name) |
| if filter_module_file_name is not None: |
| self._LoadFilterModule(filter_module_file_name) |
| |
| # Try to import uploader and requester keys and add project info into the |
| # database, if failed at any step, delete imported keys. |
| uploader_key_fingerprint, requester_key_fingerprint = (None, None) |
| uploader_key_already_exists, requester_key_already_exists = (False, False) |
| try: |
| uploader_key_fingerprint, uploader_key_already_exists = ( |
| self._ImportGPGKey(uploader_key_file_path)) |
| if uploader_key_already_exists: |
| raise ValueError('Uploader key already exists') |
| requester_key_fingerprint, requester_key_already_exists = ( |
| self._ImportGPGKey(requester_key_file_path)) |
| if requester_key_already_exists: |
| raise ValueError('Requester key already exists') |
| with self.db_connection: |
| self.db_cursor.execute( |
| 'INSERT INTO projects (' |
| ' name, uploader_key_fingerprint, requester_key_fingerprint, ' |
| ' parser_module_file_name, filter_module_file_name) ' |
| 'VALUES (?, ?, ?, ?, ?)', |
| (name, uploader_key_fingerprint, requester_key_fingerprint, |
| parser_module_file_name, filter_module_file_name)) |
| except BaseException: |
| if not uploader_key_already_exists and uploader_key_fingerprint: |
| self.gpg.delete_keys(uploader_key_fingerprint) |
| if not requester_key_already_exists and requester_key_fingerprint: |
| self.gpg.delete_keys(requester_key_fingerprint) |
| raise |
| |
| def UpdateProject(self, name, uploader_key_file_path=None, |
| requester_key_file_path=None, filter_module_file_name=None): |
| """Updates a project. |
| |
| Args: |
| name: name of the project, must be unique. |
| uploader_key_file_path: path to the OEM's public key file. |
| requester_key_file_path: path to the ODM's public key file. |
| filter_module_file_name: file name of the filter python module. |
| |
| Raises: |
| RuntimeError if SQLite3 can't update the project row (for any reason). |
| """ |
| # Try to load the filter module. |
| if filter_module_file_name is not None: |
| self._LoadFilterModule(filter_module_file_name) |
| |
| project = self._FetchProjectByName(name) |
| |
| # Try to import uploader and requester keys and add project info into the |
| # database, if failed at any step, delete any newly imported keys. |
| uploader_key_fingerprint, requester_key_fingerprint = (None, None) |
| old_uploader_key_fingerprint = project['uploader_key_fingerprint'] |
| old_requester_key_fingerprint = project['requester_key_fingerprint'] |
| same_uploader_key, same_requester_key = (True, True) |
| try: |
| sql_set_clause_list = ['filter_module_file_name = ?'] |
| sql_parameters = [filter_module_file_name] |
| |
| if uploader_key_file_path: |
| uploader_key_fingerprint, same_uploader_key = self._ImportGPGKey( |
| uploader_key_file_path) |
| sql_set_clause_list.append('uploader_key_fingerprint = ?') |
| sql_parameters.append(uploader_key_fingerprint) |
| |
| if requester_key_file_path: |
| requester_key_fingerprint, same_requester_key = self._ImportGPGKey( |
| uploader_key_file_path) |
| sql_set_clause_list.append('requester_key_fingerprint = ?') |
| sql_parameters.append(requester_key_fingerprint) |
| |
| sql_set_clause = ','.join(sql_set_clause_list) |
| sql_parameters.append(name) |
| with self.db_connection: |
| self.db_cursor.execute( |
| 'UPDATE projects SET %s WHERE name = ?' % sql_set_clause, |
| tuple(sql_parameters)) |
| if self.db_cursor.rowcount != 1: |
| raise RuntimeError('Failed to update project %s' % name) |
| except BaseException: |
| if not same_uploader_key and uploader_key_fingerprint: |
| self.gpg.delete_keys(uploader_key_fingerprint) |
| if not same_requester_key and requester_key_fingerprint: |
| self.gpg.delete_keys(requester_key_fingerprint) |
| raise |
| |
| if not same_uploader_key: |
| self.gpg.delete_keys(old_uploader_key_fingerprint) |
| if not same_requester_key: |
| self.gpg.delete_keys(old_requester_key_fingerprint) |
| |
| def RemoveProject(self, name): |
| """Removes a project. |
| |
| Args: |
| name: the name of the project specified when added. |
| """ |
| project = self._FetchProjectByName(name) |
| |
| self.gpg.delete_keys(project['uploader_key_fingerprint']) |
| self.gpg.delete_keys(project['requester_key_fingerprint']) |
| |
| with self.db_connection: |
| self.db_cursor.execute( |
| 'DELETE FROM drm_keys WHERE project_name = ?', (name,)) |
| self.db_cursor.execute('DELETE FROM projects WHERE name = ?', (name,)) |
| |
| def ListProjects(self): |
| """Lists all projects.""" |
| self.db_cursor.execute('SELECT * FROM projects ORDER BY name ASC') |
| return self.db_cursor.fetchall() |
| |
| def Upload(self, encrypted_serialized_drm_keys): |
| """Uploads a list of DRM keys to the server. This is an atomic operation. It |
| will either succeed and save all the keys, or fail and save no keys. |
| |
| Args: |
| encrypted_serialized_drm_keys: the serialized DRM keys signed by the |
| uploader and encrypted by the server's public key. |
| |
| Raises: |
| InvalidUploaderException if the signature of the uploader can not be |
| verified. |
| """ |
| decrypted_obj = self.gpg.decrypt(encrypted_serialized_drm_keys) |
| project = self._FetchProjectByUploaderKeyFingerprint( |
| decrypted_obj.fingerprint) |
| serialized_drm_keys = decrypted_obj.data |
| |
| # Pass to the parse function. |
| parser_module = self._LoadParserModule(project['parser_module_file_name']) |
| drm_key_list = parser_module.Parse(serialized_drm_keys) |
| |
| drm_key_hash_list = [] |
| for drm_key in drm_key_list: |
| drm_key_hash_list.append(hashlib.sha1(json.dumps(drm_key)).hexdigest()) |
| |
| # Pass to the filter function if needed. |
| if project['filter_module_file_name']: # filter module can be null |
| filter_module = self._LoadFilterModule(project['filter_module_file_name']) |
| filtered_drm_key_list = filter_module.Filter(drm_key_list) |
| else: |
| # filter module is optional |
| filtered_drm_key_list = drm_key_list |
| |
| # Fetch server key for signing. |
| server_key_fingerprint = self._FetchServerKeyFingerprint() |
| |
| # Sign and encrypt each key by server's private key and requester's public |
| # key, respectively. |
| encrypted_serialized_drm_key_list = [] |
| requester_key_fingerprint = project['requester_key_fingerprint'] |
| for drm_key in filtered_drm_key_list: |
| encrypted_obj = self.gpg.encrypt( |
| json.dumps(drm_key), requester_key_fingerprint, |
| always_trust=True, sign=server_key_fingerprint) |
| encrypted_serialized_drm_key_list.append(encrypted_obj.data) |
| |
| # Insert into the database. |
| with self.db_connection: |
| self.db_cursor.executemany( |
| 'INSERT INTO drm_keys (' |
| ' project_name, drm_key_hash, encrypted_drm_key) ' |
| 'VALUES (?, ?, ?)', |
| zip([project['name']] * len(encrypted_serialized_drm_key_list), |
| drm_key_hash_list, encrypted_serialized_drm_key_list)) |
| |
| def AvailableKeyCount(self, requester_signature): |
| """Queries the number of remaining keys. |
| |
| Args: |
| requester_signature: a message signed by the requester. Since the server |
| doesn't need any additional info from the requester, the requester can |
| simply sign a random string and send it here. |
| |
| Returns: |
| The number of remaining keys that can be requested. |
| |
| Raises: |
| InvalidRequesterException if the signature of the requester can not be |
| verified. |
| """ |
| verified = self.gpg.verify(requester_signature) |
| if not verified: |
| raise InvalidRequesterException( |
| 'Invalid requester, check your signing key') |
| |
| project = self._FetchProjectByRequesterKeyFingerprint(verified.fingerprint) |
| |
| self.db_cursor.execute( |
| 'SELECT COUNT(*) AS available_key_count FROM drm_keys ' |
| 'WHERE project_name = ? AND device_serial_number IS NULL', |
| (project['name'],)) |
| return self.db_cursor.fetchone()['available_key_count'] |
| |
| def Request(self, encrypted_device_serial_number): |
| """Requests a DRM key by device serial number. |
| |
| Args: |
| encrypted_device_serial_number: the device serial number signed by the |
| requester and encrypted by the server's public key. |
| |
| Raises: |
| InvalidRequesterException if the signature of the requester can not be |
| verified. RuntimeError if no available keys left in the database. |
| """ |
| decrypted_obj = self.gpg.decrypt(encrypted_device_serial_number) |
| project = self._FetchProjectByRequesterKeyFingerprint( |
| decrypted_obj.fingerprint) |
| device_serial_number = decrypted_obj.data |
| |
| def FetchDRMKeyByDeviceSerialNumber(project_name, device_serial_number): |
| self.db_cursor.execute( |
| 'SELECT * FROM drm_keys WHERE project_name = ? AND ' |
| 'device_serial_number = ?', |
| (project_name, device_serial_number)) |
| return self.db_cursor.fetchone() |
| |
| row = FetchDRMKeyByDeviceSerialNumber(project['name'], device_serial_number) |
| if row: # the SN has already paired |
| return row['encrypted_drm_key'] |
| |
| # Find an unpaired key. |
| with self.db_connection: |
| # SQLite3 does not support using LIMIT clause in UPDATE statement by |
| # default, unless SQLITE_ENABLE_UPDATE_DELETE_LIMIT flag is defined during |
| # compilation. Since this script may be deployed on partner's computer, |
| # we'd better assume they don't have this flag on. |
| self.db_cursor.execute( |
| 'UPDATE drm_keys SET device_serial_number = ? ' |
| 'WHERE id = (SELECT id FROM drm_keys WHERE project_name = ? AND ' |
| ' device_serial_number IS NULL LIMIT 1)', |
| (device_serial_number, project['name'])) |
| if self.db_cursor.rowcount != 1: # insufficient keys |
| raise RuntimeError( |
| 'Insufficient DRM keys, ask for the OEM to upload more') |
| |
| row = FetchDRMKeyByDeviceSerialNumber(project['name'], device_serial_number) |
| if row: |
| return row['encrypted_drm_key'] |
| else: |
| raise RuntimeError('Failed to find paired DRM key') |
| |
| def ListenForever(self, ip, port): |
| """Starts the XML RPC server waiting for commands. |
| |
| Args: |
| ip: IP to bind. |
| port: port to bind. |
| """ |
| class Server(SimpleXMLRPCServer.SimpleXMLRPCServer): |
| def _dispatch(self, method, params): |
| # Catch exceptions and log them. Without this, SimpleXMLRPCServer simply |
| # output the error message to stdout, and we won't be able to see what |
| # happened in the log file. |
| logging.info('%s called', method) |
| try: |
| result = SimpleXMLRPCServer.SimpleXMLRPCServer._dispatch( |
| self, method, params) |
| return result |
| except BaseException as e: |
| logging.exception(e) |
| raise |
| |
| server = Server((ip, port), allow_none=True) |
| |
| server.register_introspection_functions() |
| server.register_function(self.AvailableKeyCount) |
| server.register_function(self.Upload) |
| server.register_function(self.Request) |
| |
| server.serve_forever() |
| |
| def _ImportGPGKey(self, key_file_path): |
| """Imports a GPG key from a file. |
| |
| Args: |
| key_file_path: path to the GPG key file. |
| |
| Returns: |
| A tuple (key_fingerprint, key_already_exists). The 1st element is the |
| imported key's fingerprint, and the 2nd element is True if the key was |
| already in the database before importing, False otherwise. |
| """ |
| with open(key_file_path) as f: |
| import_results = self.gpg.import_keys(f.read()) |
| key_already_exists = (import_results.imported == 0) |
| key_fingerprint = import_results.fingerprints[0] |
| return (key_fingerprint, key_already_exists) |
| |
| def _LoadFilterModule(self, filter_module_file_name): |
| """Loads the filter module. |
| |
| Args: |
| filter_module_file_name: file name of the filter module in FILTERS_DIR. |
| |
| Returns: |
| The loaded filter module on success. |
| |
| Raises: |
| Exception if failed, see imp.load_source()'s doc for what could be raised. |
| """ |
| return imp.load_source( |
| 'filter_module', os.path.join(FILTERS_DIR, filter_module_file_name)) |
| |
| def _LoadParserModule(self, parser_module_file_name): |
| """Loads the parser module. |
| |
| Args: |
| parser_module_file_name: file name of the parser module in PARSERS_DIR. |
| |
| Returns: |
| The loaded parser module on success. |
| |
| Raises: |
| Exception if failed, see imp.load_source()'s doc for what could be raised. |
| """ |
| return imp.load_source( |
| 'parser_module', os.path.join(PARSERS_DIR, parser_module_file_name)) |
| |
| def _FetchServerKeyFingerprint(self): |
| """Returns the server GPG key's fingerprint.""" |
| self.db_cursor.execute( |
| "SELECT * FROM settings WHERE key = 'server_key_fingerprint'") |
| row = self.db_cursor.fetchone() |
| if not row: |
| raise ValueError('Server key fingerprint not exists') |
| return row['value'] |
| |
| def _FetchOneProject(self, name=None, |
| uploader_key_fingerprint=None, |
| requester_key_fingerprint=None, |
| exception_type=None, error_msg=None): |
| """Fetches the project by name, uploader key fingerprint, or requester key |
| fingerprint. |
| |
| This function combines the name, uploader_key_fingerprint, |
| requester_key_fingerprint conditions (if not None) with the AND operator, |
| and tries to fetch one project from the database. |
| |
| Args: |
| name: name of the project. |
| uploader_key_fingerprint: uploader key fingerprint of the project. |
| requester_key_fingerprint: requester key fingerprint of the project. |
| exception_type: if no project was found and exception_type is not None, |
| raise exception_type with error_msg. |
| error_msg: if no project was found and exception_type is not None, raise |
| exception_type with error_msg. |
| |
| Returns: |
| A project that matches the name, uploader_key_fingerprint, and |
| requester_key_fingerprint conditiions. |
| |
| Raises: |
| exception_type with error_msg if not project was found. |
| """ |
| # pylint: disable=unused-argument |
| where_clause_list = [] |
| params = [] |
| local_vars = locals() |
| for param_name in ['name', 'uploader_key_fingerprint', |
| 'requester_key_fingerprint']: |
| if local_vars[param_name] is not None: |
| where_clause_list.append('%s = ?' % param_name) |
| params.append(locals()[param_name]) |
| if not where_clause_list: |
| raise ValueError('No conditions given to fetch the project') |
| where_clause = 'WHERE ' + ' AND '.join(where_clause_list) |
| |
| self.db_cursor.execute( |
| 'SELECT * FROM projects %s' % where_clause, tuple(params)) |
| project = self.db_cursor.fetchone() |
| |
| if not project and exception_type: |
| raise exception_type(error_msg) |
| |
| return project |
| |
| def _FetchProjectByName(self, name): |
| return self._FetchOneProject( |
| name=name, exception_type=ProjectNotFoundException, |
| error_msg=('Project %s not found' % name)) |
| |
| def _FetchProjectByUploaderKeyFingerprint(self, uploader_key_fingerprint): |
| return self._FetchOneProject( |
| uploader_key_fingerprint=uploader_key_fingerprint, |
| exception_type=InvalidUploaderException, |
| error_msg='Invalid uploader, check your signing key') |
| |
| def _FetchProjectByRequesterKeyFingerprint(self, requester_key_fingerprint): |
| return self._FetchOneProject( |
| requester_key_fingerprint=requester_key_fingerprint, |
| exception_type=InvalidRequesterException, |
| error_msg='Invalid requester, check your signing key') |
| |
| |
| def _ParseArguments(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| '-d', '--database_file_path', |
| default=os.path.join(SCRIPT_DIR, DEFAULT_DATABASE_FILE_NAME), |
| help='path to the SQLite3 database file, default to "dkps.db" in the ' |
| 'same directory of this script') |
| parser.add_argument( |
| '-g', '--gnupg_homedir', |
| default=os.path.join(SCRIPT_DIR, DEFAULT_GNUPG_DIR_NAME), |
| help='path to the GnuGP home directory, default to "gnupg" in the same ' |
| 'directory of this script') |
| parser.add_argument( |
| '-l', '--log_file_path', |
| default=os.path.join(SCRIPT_DIR, DEFAULT_LOG_FILE_NAME), |
| help='path to the log file, default to "dkps.log" in the same directory ' |
| 'of this script') |
| subparsers = parser.add_subparsers(dest='command') |
| |
| parser_add = subparsers.add_parser('add', help='adds a new project') |
| parser_add.add_argument('-n', '--name', required=True, |
| help='name of the new project') |
| parser_add.add_argument('-u', '--uploader_key_file_path', required=True, |
| help="path to the uploader's public key file") |
| parser_add.add_argument('-r', '--requester_key_file_path', required=True, |
| help="path to the requester's public key file") |
| parser_add.add_argument('-p', '--parser_module_file_name', required=True, |
| help='file name of the parser module') |
| parser_add.add_argument('-f', '--filter_module_file_name', default=None, |
| help='file name of the filter module') |
| |
| subparsers.add_parser('destroy', help='destroys the database') |
| |
| parser_update = subparsers.add_parser('update', |
| help='updates an existing project') |
| parser_update.add_argument('-n', '--name', required=True, |
| help='name of the project') |
| parser_update.add_argument('-u', '--uploader_key_file_path', default=None, |
| help="path to the uploader's public key file") |
| parser_update.add_argument('-r', '--requester_key_file_path', default=None, |
| help="path to the requester's public key file") |
| parser_update.add_argument('-f', '--filter_module_file_name', default=None, |
| help='file name of the filter module') |
| |
| parser_init = subparsers.add_parser('init', help='initializes the database') |
| parser_init.add_argument( |
| '-g', '--gpg_gen_key_args', action='append', nargs=2, default={}, |
| help='arguments to use when generating GPG key for server') |
| parser_init.add_argument( |
| '-s', '--server_key_file_path', default=None, |
| help="path to the server's private key file") |
| |
| subparsers.add_parser('list', help='lists all projects') |
| |
| parser_listen = subparsers.add_parser( |
| 'listen', help='starts the server, waiting for upload or request keys') |
| parser_listen.add_argument( |
| '--ip', default=DEFAULT_BIND_ADDR, |
| help='IP to bind, default to %s' % DEFAULT_BIND_ADDR) |
| parser_listen.add_argument( |
| '--port', type=int, default=DEFAULT_BIND_PORT, |
| help='port to listen, default to %s' % DEFAULT_BIND_PORT) |
| |
| parser_rm = subparsers.add_parser('rm', help='removes an existing project') |
| parser_rm.add_argument('-n', '--name', required=True, |
| help='name of the project to remove') |
| |
| return parser.parse_args() |
| |
| |
| def main(): |
| args = _ParseArguments() |
| |
| logging_config = DEFAULT_LOGGING_CONFIG |
| logging_config['handlers']['file']['filename'] = args.log_file_path |
| logging.config.dictConfig(logging_config) |
| |
| dkps = DRMKeysProvisioningServer(args.database_file_path, args.gnupg_homedir) |
| if args.command == 'init': |
| # Convert from command line arguments to a dict. |
| gpg_gen_key_args_dict = {} |
| for pair in args.gpg_gen_key_args: |
| gpg_gen_key_args_dict[pair[0]] = pair[1] |
| dkps.Initialize(gpg_gen_key_args_dict, args.server_key_file_path) |
| elif args.command == 'destroy': |
| message = ( |
| 'This action will remove all projects and keys information and is NOT ' |
| 'recoverable! Are you sure? (y/N)') |
| answer = raw_input(textwrap.fill(message, 80) + ' ') |
| if answer.lower() != 'y' and answer.lower() != 'yes': |
| print('OK, nothing will be removed.') |
| else: |
| print('Removing all projects and keys information...', end=' ') |
| dkps.Destroy() |
| print('done.') |
| elif args.command == 'listen': |
| dkps.ListenForever(args.ip, args.port) |
| elif args.command == 'list': |
| print(dkps.ListProjects()) |
| elif args.command == 'add': |
| dkps.AddProject( |
| args.name, args.uploader_key_file_path, args.requester_key_file_path, |
| args.parser_module_file_name, args.filter_module_file_name) |
| elif args.command == 'update': |
| dkps.UpdateProject( |
| args.name, args.uploader_key_file_path, args.requester_key_file_path, |
| args.filter_module_file_name) |
| elif args.command == 'rm': |
| dkps.RemoveProject(args.name) |
| else: |
| raise ValueError('Unknown command %s' % args.command) |
| |
| |
| if __name__ == '__main__': |
| main() |
