1

# encoding: utf-8

     2

     3

import datetime

     4

import werkzeug

     5

import werkzeug.urls

     6

     7

import pvl.web

     8

import pvl.web.response

     9

    10

from pvl.login import pubtkt

    11

from pvl.web import urls, html

    12

    13

import logging; log = logging.getLogger('pvl.login.server')

    14

    15

class Handler (pvl.web.Handler) :

    16

    # Bootstrap

    17

    DOCTYPE = 'html'

    18

    HTML_XMLNS = None

    19

    HTML_LANG = 'en'

    20

    CSS = (

    21

            '//netdna.bootstrapcdn.com/bootstrap/3.0.3/css/bootstrap.min.css',

    22

    )

    23

    JS = (

    24

            '//code.jquery.com/jquery.js',

    25

            '//netdna.bootstrapcdn.com/bootstrap/3.0.3/js/bootstrap.min.js',

    26

    )

    27

    28

    def redirect (self, *url, **params) :

    29

        return pvl.web.response.redirect(self.url(*url, **params))

    30

    35

    def process_cookie (self) :

    36

        """

    37

            Reverse the urlencoding used for the cookie...

    38

        """

    39

    40

        log.debug("cookies: %s", self.request.cookies)

    41

    42

        cookie = self.request.cookies.get(self.app.cookie_name)

    43

    47

        log.debug("cookie %s=%s", self.app.cookie_name, cookie)

    48

    50

    51

        log.debug("cookie decoded: %s", cookie)

    52

    66

    67

class Index (Handler) :

    68

    TITLE = u"Päivölä Network Login"

    69

    70

    def process (self) :

    72

    73

        if not self.pubtkt :

    74

            return self.redirect(Login)

    75

    76

    def render_valid (self, valid) :

    77

        seconds = valid.seconds + valid.days * (24 * 60 * 60)

    78

    79

        minutes, seconds = divmod(seconds, 60)

    80

        hours, minutes = divmod(minutes, 60)

    81

    82

        return "%2d:%02d:%02d" % (hours, minutes, seconds)

    83

    97

    def render_pubtkt_fields (self, pubtkt) :

    98

        """

    99

            Yield (glyphicon, text) to render as fields for ticket.

   100

        """

   101

   103

   106

   121

   122

        if pubtkt.cip :

   124

   125

        if pubtkt.udata :

   127

   128

        for token in pubtkt.tokens :

   130

   131

        if pubtkt.bauth :

   133

   134

    def render_pubtkt (self, pubtkt) :

   138

            html.div(class_='panel-heading')("Login: {pubtkt.uid}".format(pubtkt=self.pubtkt)),

   139

            html.ul(class_='list-group')(

   141

                    html.span(class_='glyphicon glyphicon-{glyphicon}'.format(glyphicon=icon)) if icon else None,

   142

                    info,

   144

            ),

   145

            html.div(class_='panel-footer')(

   157

                    html.button(type='submit', class_='btn btn-warning')("Logout"),

   158

                ),

   159

            ),

   160

        )

   161

   162

    def render_info (self) :

   163

        if self.cookie_error :

   164

            return (

   165

                    html.h2("Invalid cookie"),

   166

                    html.p(self.cookie_error),

   167

            )

   168

   169

        return self.render_pubtkt(self.pubtkt)

   170

   171

    def render (self) :

   172

   173

        return html.div(class_='container')(

   174

                self.render_info(),

   175

        )

   176

   177

class Login (Handler) :

   178

    TITLE = "Login"

   179

   180

    STYLE = """

   181

form#login {

   182

    max-width:  50%;

   183

    padding:    1em;

   184

    margin:     0 auto;

   185

}

   186

   187

    """

   188

   191

   192

        if self.request.method == 'POST' :

   193

            back = self.app.login_server

   194

            username = self.request.form.get('username')

   195

            password = self.request.form.get('username')

   196

   197

            if username and password :

   198

                # preprocess

   199

                username = username.strip().lower()

   200

   201

                try :

   203

   204

                except pubtkt.Error as ex :

   205

                    self.auth_errors = ex

   210

   213

   217

   228

   229

    def render (self) :

   235

        domain = self.app.login_domain

   236

   237

        return html.div(class_='container')(

   238

            html.form(action=self.url(), method='POST', id='login')(

   239

                html.fieldset(

   240

                    html.legend("Log in"),

   241

   242

                    html.div(class_='form-group')(

   243

                        html.div(class_='input-group')(

   244

                            html.label(for_='username', class_='sr-only')("Username"),

   246

                            html.span(class_='input-group-addon')("@{domain}".format(domain=domain)),

   247

                        ),

   248

   249

                        html.label(for_='password', class_='sr-only')("Password"),

   250

                        html.input(name='password', type='password', class_='form-control', placeholder="Password", required=True),

   251

                    ),

   252

   253

                    html.button(type='submit', class_='btn btn-primary')("Login"),

   254

                )

   255

            )

   256

        )

   257

   258

class Logout (Handler) :

   259

    TITLE = "Logout"

   260

   261

    def process (self) :

   263

   264

        if not self.pubtkt :

   265

            return self.redirect(Index)

   266

   267

        if self.request.method == 'POST' :

   268

            back = self.app.login_server

   269

   270

            response = pvl.web.response.redirect(back)

   271

   272

            response.set_cookie(self.app.cookie_name, '',

   273

                    expires = 0,

   274

                    domain      = self.app.cookie_domain,

   275

                    secure      = self.app.cookie_secure,

   276

                    httponly    = self.app.cookie_httponly,

   277

            )

   278

   279

            return response

   280

   281

    def render (self) :

   282

        return html.div(class_='container')(

   283

            html.form(action=self.url(), method='post')(

   284

                html.fieldset(

   285

                    html.legend("Logout {pubtkt.uid}".format(pubtkt=self.pubtkt)),

   286

   287

                    html.button(type='submit', class_='btn btn-warning')("Logout"),

   288

                )

   289

            )

   290

        )

   291

   292

class LoginApplication (pvl.web.Application) :

   293

    URLS = urls.Map((

   294

        urls.rule('/',              Index),

   295

        urls.rule('/login',         Login),

   296

        urls.rule('/logout',        Logout),

   297

    ))

   298

   299

    PUBLIC_KEY = 'etc/login/public.pem'

   300

    PRIVATE_KEY = 'etc/login/private.pem'

   301

   302

    login_domain = 'test.paivola.fi'

   303

    login_server = 'https://login.test.paivola.fi/'

   305

   306

    cookie_name = 'auth_pubtkt'

   307

    cookie_domain = 'test.paivola.fi'

   308

    cookie_secure = True

   309

    cookie_httponly = True

   310

   311

    def __init__ (self, public_key=PUBLIC_KEY, private_key=PRIVATE_KEY, **opts) :

   312

        super(LoginApplication, self).__init__(**opts)

   313

   314

        self.server_keys = pubtkt.ServerKeys.config(

   315

                public_key  = public_key,

   316

                private_key = private_key,

   317

        )

   318

   319

    def load (self, cookie) :

   320

        """

   321

            Load a pubtkt from a cookie, and verify it.

   322

        """

   323

   324

        return pubtkt.PubTkt.load(cookie, self.server_keys.public)

   325

   326

    def auth (self, username, password) :

   327

        """

   328

            Perform authentication, returning a PubTkt, signed

   329

        """

   330

   331

        return pubtkt.PubTkt.new(username,

   332

                expiry  = self.login_expire,

   333

        )

   334

   335

    def sign (self, pubtkt) :

   336

        """

   337

            Create a cookie by signing the given pubtkt.

   338

        """

   339

   340

        return pubtkt.sign(self.server_keys.private)

   341