Merge lp:~mandel/desktopcouch/add_windows_keyring into lp:desktopcouch

[Manuel de la Peña]

Provides the windows implementation of the keyring that can be used in windows. Data is stored in the Registry and uses the DPAPI so that it is not viewable by a user that has not been logged as the user that owns the registry (apps running in an other user space)

Provides the windows implementation of the keyring that can be used in windows. Data is stored in the Registry and uses the DPAPI so that it is not viewable by a user that has not been logged as the user that owns the registry (apps running in an other user space)

[Chad Miller (cmiller)]

38 + def __init__(self, make_random_string_fn=make_random_string,
39 + registry=None, crypto=None):
40 +

If you inherit from object, you much call object's __init__().
> super(Keyring, self).__init__()

73 + for index in count():

Very sexy. Thx.

review: Needs Fixing

[lp:~mandel/desktopcouch/add_windows_keyring]

223. By Manuel de la Peña on 2010-11-26

Called missing parent constructor.

[Chad Miller (cmiller)]

review: Approve

[Eric Casteleijn (thisfred)]

Looking good, let's land it!

review: Approve

=== added file 'desktopcouch/application/platform/windows/keyring.py'
--- desktopcouch/application/platform/windows/keyring.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/application/platform/windows/keyring.py	2010-11-26 14:26:35 +0000
@@ -0,0 +1,138 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Manuel de la Pena <[e-mail]>
+"""Keyring  implementation on windows."""
+
+import base64
+
+from itertools import count
+
+from desktopcouch.application.util import make_random_string
+
+
+class Keyring(object):
+    """Implementation to be used on windows.
+
+    Provides the implementation of the keyring operations on windows
+    using the crypto lib and the registry key to store the info.
+    """
+
+    def __init__(self, make_random_string_fn=make_random_string,
+                 registry=None, crypto=None):
+        super(Keyring, self).__init__()
+        # ignore pylint, we might not be on windows
+        # pylint: disable=F0401
+        if registry is None:
+            import _winreg
+            registry = _winreg
+
+        if crypto is None:
+            import win32crypt
+            crypto = win32crypt
+        # pylint: enable=F0401
+
+        self.make_random_string = make_random_string_fn
+        self.registry = registry
+        self.crypto = crypto
+
+    def _registry_value_exists(self, value):
+        """Return if the required key exists in the system."""
+        # ignore the fact that we do not specify the expcetion, we do
+        # this so that the tests can run on linux.
+        # pylint: disable=W0702
+        # try to open it, if not, return false
+        try:
+            access_rights = self.registry.KEY_ALL_ACCESS
+            canonical = self.registry.OpenKey(self.registry.HKEY_CURRENT_USER,
+                'Canonical', 0, access_rights)
+            keyrings = self.registry.OpenKey(canonical,
+                'Keyrings', 0, access_rights)
+            default = self.registry.OpenKey(keyrings,
+                'Default', 0, access_rights)
+            desktopcouch = self.registry.OpenKey(default,
+                'Desktopcouch', 0, access_rights)
+            # enum until we get a exception
+            for index in count():
+                try:
+                    info = self.registry.EnumValue(
+                        desktopcouch, index)
+                    if info[0] == value:
+                        return True
+                except:
+                    return False
+        except:
+            return False
+        # pylint: enable=W0702
+
+    def _open_registry_key(self):
+        """Open the required registry key"""
+        # we need to open the key from the keyring location in the
+        # registry, the easiest way is to open step by step each key
+        # using CreateKey since it will create the key if required
+        canonical_key = self.registry.CreateKey(
+            self.registry.HKEY_CURRENT_USER,
+            'Canonical')
+        keyring_key = self.registry.CreateKey(
+            canonical_key, 'Keyrings')
+        default_key = self.registry.CreateKey(
+            keyring_key, 'Default')
+        return self.registry.CreateKey(
+            default_key, 'Desktopcouch')
+
+    def get_user_name_password(self):
+        """Return the user name and passwd used to access desktopcouch."""
+        admin_username = None
+        admin_password = None
+        data_exists = self._registry_value_exists('basic')
+        key = self._open_registry_key()
+        if data_exists:
+            # read and return it
+            secret = self.registry.QueryValueEx(key, 'basic')
+            secret = base64.b64decode(secret[0])
+            secret = self.crypto.CryptUnprotectData(secret,
+                None, None, None, 0)
+            admin_username, admin_password = secret[1].split(':', 1)
+        else:
+            admin_username = self.make_random_string(10)
+            admin_password = self.make_random_string(10)
+            # encrypt the info before we store it
+            secret = ':'.join([admin_username, admin_password])
+            secret = self.crypto.CryptProtectData(
+                secret, u'basic', None, None, None, 0)
+            secret = base64.b64encode(secret)
+            # store the secured data
+            self.registry.SetValueEx(key, 'basic', 0, self.registry.REG_SZ,
+                secret)
+        return (admin_username, admin_password)
+
+    def get_oauth_data(self):
+        """Return the oauth data used to connect with couchdb."""
+        consumer_key = self.make_random_string(10)
+        consumer_secret = self.make_random_string(10)
+        token = self.make_random_string(10)
+        token_secret = self.make_random_string(10)
+        # Save the new OAuth creds so that 3rd-party apps can
+        # authenticate by accessing the keyring first.  This is
+        # one-way.  We don't read from keyring.
+        key = self._open_registry_key()
+        secret = ':'.join([consumer_key, consumer_secret, token, token_secret])
+        secret = self.crypto.CryptProtectData(secret, u'oauth',
+            None, None, None, 0)
+        secret = base64.b64encode(secret)
+        self.registry.SetValueEx(key, 'oauth', 0, self.registry.REG_SZ,
+            secret)
+        return (consumer_key, consumer_secret, token, token_secret)

=== added directory 'desktopcouch/application/platform/windows/tests'
=== added file 'desktopcouch/application/platform/windows/tests/__init__.py'
--- desktopcouch/application/platform/windows/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/application/platform/windows/tests/__init__.py	2010-11-26 14:26:35 +0000
@@ -0,0 +1,1 @@
+"""Test windows platform code."""

=== added file 'desktopcouch/application/platform/windows/tests/test_keyring.py'
--- desktopcouch/application/platform/windows/tests/test_keyring.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/application/platform/windows/tests/test_keyring.py	2010-11-26 14:26:35 +0000
@@ -0,0 +1,227 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+# desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Manuel de la Pena <[e-mail]>
+"""Test keyring module."""
+import base64
+from mocker import MockerTestCase
+
+from desktopcouch.application.platform.windows.keyring import Keyring
+
+
+class TestKeyring(MockerTestCase):
+    """Test the class that manages the keyring on gnome."""
+
+    def setUp(self):
+        super(TestKeyring, self).setUp()
+        self._random_string_fn = self.mocker.mock()
+        self._registry = self.mocker.mock()
+        self._crypto = self.mocker.mock()
+        self._keyring = Keyring(make_random_string_fn=self._random_string_fn,
+            registry=self._registry, crypto=self._crypto)
+        self._username = 'username'
+        self._password = 'password'
+        self._consumer_key = 'consumer_key'
+        self._consumer_secret = 'consumer_secret'
+        self._token = 'token'
+        self._token_secret = 'token_secret'
+        self._current_user = 'HKCU'
+
+    def test_get_user_name_password_no_key(self):
+        """Test to get the value when the key is not present."""
+        # try to open the key and thorw an exception
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        # pylint: enable=W0104
+        self.mocker.result(0)
+        # pylint: disable=W0104
+        self._registry.KEY_ALL_ACCESS
+        # pylint: enable=W0104
+        self.mocker.result(0)
+        self._registry.OpenKey(0, 'Canonical', 0, 0)
+        self.mocker.throw(Exception('No key'))
+        self._random_string_fn(10)
+        self.mocker.result(self._username)
+        self._random_string_fn(10)
+        self.mocker.result(self._password)
+        # open the key
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        # pylint: enable=W0104
+        self.mocker.result(self._current_user)
+        self._registry.CreateKey(self._current_user,
+            'Canonical')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Keyrings')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Default')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Desktopcouch')
+        self.mocker.result(self._registry)
+        # store the key
+        self._crypto.CryptProtectData(
+            ':'.join([self._username, self._password]),
+            u'basic', None, None, None, 0)
+        self.mocker.result('secret')
+        # pylint: disable=W0104
+        self._registry.REG_SZ
+        # pylint: enable=W0104
+        self.mocker.result(0)
+        self._registry.SetValueEx(self._registry, 'basic', 0,
+            0, base64.b64encode('secret'))
+        self.mocker.replay()
+        username, password = self._keyring.get_user_name_password()
+        self.assertEqual(username, self._username)
+        self.assertEqual(password, self._password)
+
+    def test_get_user_name_password_no_value(self):
+        """Test to get the value when it is no present in the key."""
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        self.mocker.result(0)
+        self._registry.KEY_ALL_ACCESS
+        self.mocker.result(0)
+        self._registry.OpenKey(0, 'Canonical', 0, 0)
+        self.mocker.result(self._registry)
+        self._registry.OpenKey(self._registry, 'Keyrings', 0, 0)
+        self.mocker.result(self._registry)
+        self._registry.OpenKey(self._registry, 'Default', 0, 0)
+        self.mocker.result(self._registry)
+        self._registry.OpenKey(self._registry, 'Desktopcouch', 0, 0)
+        self.mocker.result(self._registry)
+        # pylint: enable=W0104
+        self._registry.EnumValue(self._registry, 0)
+        self.mocker.throw(Exception('No values'))
+        self._random_string_fn(10)
+        self.mocker.result(self._username)
+        self._random_string_fn(10)
+        self.mocker.result(self._password)
+        # open the key
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        # pylint: enable=W0104
+        self.mocker.result(self._current_user)
+        self._registry.CreateKey(self._current_user,
+            'Canonical')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Keyrings')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Default')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Desktopcouch')
+        self.mocker.result(self._registry)
+        # store the key
+        self._crypto.CryptProtectData(
+            ':'.join([self._username, self._password]),
+            u'basic', None, None, None, 0)
+        self.mocker.result('secret')
+        # pylint: disable=W0104
+        self._registry.REG_SZ
+        # pylint: enable=W0104
+        self.mocker.result(0)
+        self._registry.SetValueEx(self._registry, 'basic', 0,
+            0, base64.b64encode('secret'))
+        self.mocker.replay()
+        username, password = self._keyring.get_user_name_password()
+        self.assertEqual(username, self._username)
+        self.assertEqual(password, self._password)
+
+    def test_get_user_name_password(self):
+        """Test get the data when it is present."""
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        self.mocker.result(0)
+        self._registry.KEY_ALL_ACCESS
+        self.mocker.result(0)
+        self._registry.OpenKey(0, 'Canonical', 0, 0)
+        self.mocker.result(self._registry)
+        self._registry.OpenKey(self._registry, 'Keyrings', 0, 0)
+        self.mocker.result(self._registry)
+        self._registry.OpenKey(self._registry, 'Default', 0, 0)
+        self.mocker.result(self._registry)
+        self._registry.OpenKey(self._registry, 'Desktopcouch', 0, 0)
+        self.mocker.result(self._registry)
+        # pylint: enable=W0104
+        self._registry.EnumValue(self._registry, 0)
+        self.mocker.result(['basic'])
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        # pylint: enable=W0104
+        self.mocker.result(self._current_user)
+        self._registry.CreateKey(self._current_user,
+            'Canonical')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Keyrings')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Default')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Desktopcouch')
+        self.mocker.result(self._registry)
+        # get the data from the key
+        self._registry.QueryValueEx(self._registry, 'basic')
+        self.mocker.result([base64.b64encode('secret')])
+        self._crypto.CryptUnprotectData('secret', None, None, None, 0)
+        self.mocker.result([0, ':'.join([self._username, self._password])])
+        self.mocker.replay()
+        username, password = self._keyring.get_user_name_password()
+        self.assertEqual(username, self._username)
+        self.assertEqual(password, self._password)
+
+    def test_get_oauth_data(self):
+        """Test get the oauth data."""
+        secret_data = ':'.join([self._consumer_key,
+                                self._consumer_secret,
+                                self._token,
+                                self._token_secret])
+        self._random_string_fn(10)
+        self.mocker.result(self._consumer_key)
+        self._random_string_fn(10)
+        self.mocker.result(self._consumer_secret)
+        self._random_string_fn(10)
+        self.mocker.result(self._token)
+        self._random_string_fn(10)
+        self.mocker.result(self._token_secret)
+        # open the key
+        # pylint: disable=W0104
+        self._registry.HKEY_CURRENT_USER
+        # pylint: enable=W0104
+        self.mocker.result(self._current_user)
+        self._registry.CreateKey(self._current_user,
+            'Canonical')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Keyrings')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Default')
+        self.mocker.result(self._registry)
+        self._registry.CreateKey(self._registry, 'Desktopcouch')
+        self.mocker.result(self._registry)
+        # store the key
+        self._crypto.CryptProtectData(secret_data,
+            'oauth', None, None, None, 0)
+        self.mocker.result('secret')
+        # pylint: disable=W0104
+        self._registry.REG_SZ
+        # pylint: enable=W0104
+        self.mocker.result(0)
+        self._registry.SetValueEx(self._registry, 'oauth', 0, 0,
+            base64.b64encode('secret'))
+        self.mocker.replay()
+        consumer_key, consumer_secret, token, token_secret = \
+            self._keyring.get_oauth_data()
+        self.assertEqual(self._consumer_key, consumer_key)
+        self.assertEqual(self._consumer_secret, consumer_secret)
+        self.assertEqual(self._token, token)
+        self.assertEqual(self._token_secret, token_secret)