summaryrefslogtreecommitdiffstats
path: root/ipsilon/providers/openidp.py
blob: a3e1b634b2f6838cb5f11a0c4abc7ad606b701ff (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#!/usr/bin/python
#
# Copyright (C) 2014  Ipsilon project Contributors, for licensee see COPYING

from __future__ import absolute_import

from ipsilon.providers.common import ProviderBase
from ipsilon.providers.common import FACILITY
from ipsilon.providers.openid.auth import OpenID
from ipsilon.providers.openid.extensions.common import LoadExtensions
from ipsilon.util.plugin import PluginObject
from ipsilon.info.common import InfoMapping

from openid.server.server import Server
# TODO: Move this to the database
from openid.store.memstore import MemoryStore


class IdpProvider(ProviderBase):

    def __init__(self):
        super(IdpProvider, self).__init__('openid', 'openid')
        self.mapping = InfoMapping()
        self.page = None
        self.server = None
        self.basepath = None
        self.extensions = None
        self.description = """
Provides OpenID 2.0 authentication infrastructure. """

        self._options = {
            'default email domain': [
                """Default email domain, for users missing email property.""",
                'string',
                'example.com'
            ],
            'endpoint url': [
                """The Absolute URL of the OpenID provider""",
                'string',
                'http://localhost:8080/idp/openid/'
            ],
            'identity url template': [
                """The templated URL where identities are exposed.""",
                'string',
                'http://localhost:8080/idp/openid/id/%(username)s'
            ],
            'trusted roots': [
                """List of trusted relying parties.""",
                'list',
                []
            ],
            'untrusted roots': [
                """List of untrusted relying parties.""",
                'list',
                []
            ],
            'enabled extensions': [
                """List of enabled extensions""",
                'list',
                []
            ],
        }

    @property
    def endpoint_url(self):
        url = self.get_config_value('endpoint url')
        if url.endswith('/'):
            return url
        else:
            return url+'/'

    @property
    def default_email_domain(self):
        return self.get_config_value('default email domain')

    @property
    def identity_url_template(self):
        url = self.get_config_value('identity url template')
        if url.endswith('/'):
            return url
        else:
            return url+'/'

    @property
    def trusted_roots(self):
        return self.get_config_value('trusted roots')

    @property
    def untrusted_roots(self):
        return self.get_config_value('untrusted roots')

    @property
    def enabled_extensions(self):
        return self.get_config_value('enabled extensions')

    def get_tree(self, site):
        self.init_idp()
        self.page = OpenID(site, self)
        # self.admin = AdminPage(site, self)

        # Expose OpenID presence in the root
        headers = site[FACILITY]['root'].default_headers
        headers['X-XRDS-Location'] = self.endpoint_url+'XRDS'

        html_heads = site[FACILITY]['root'].html_heads
        HEAD_LINK = '<link rel="%s" href="%s">'
        openid_heads = [HEAD_LINK % ('openid2.provider', self.endpoint_url),
                        HEAD_LINK % ('openid.server', self.endpoint_url)]
        html_heads['openid'] = openid_heads

        return self.page

    def init_idp(self):
        self.server = Server(MemoryStore(), op_endpoint=self.endpoint_url)
        loader = LoadExtensions(self.enabled_extensions)
        self.extensions = loader.get_extensions()

    def on_enable(self):
        self.init_idp()


class Installer(object):

    def __init__(self):
        self.name = 'openid'
        self.ptype = 'provider'

    def install_args(self, group):
        group.add_argument('--openid', choices=['yes', 'no'], default='yes',
                           help='Configure OpenID Provider')

    def configure(self, opts):
        if opts['openid'] != 'yes':
            return

        proto = 'https'
        if opts['secure'].lower() == 'no':
            proto = 'http'
        url = '%s://%s/%s/openid/' % (
            proto, opts['hostname'], opts['instance'])

        # Add configuration data to database
        po = PluginObject()
        po.name = 'openid'
        po.wipe_data()

        po.wipe_config_values(FACILITY)
        config = {'endpoint url': url,
                  'identity_url_template': '%sid/%%(username)s' % url,
                  'enabled': '1'}
        po.set_config(config)
        po.save_plugin_config(FACILITY)