OAuth2 : c'est fini

class: center, middle

# OAuth2 : c'est fini

Lee Johnson (LEEJO / leejo / lee@humanstate.com)

???
Y a-t-il quelqu’un qui ne connais pas OAuth2 ou n’en a jamais entendu parler ?

---
# OAuth2

.middle[.center[![Login With Buttons](img/bootstrap-social.png)]]

???
Pas tous les services utilisent OAuth2, par exemple twitter utilise OAuth1
---
# « C'est fini » ?

### [Net::OAuth2::AuthorizationServer](https://metacpan.org/release/Net-OAuth2-AuthorizationServer)
--

- Supporte les quatre flux d’OAuth2
--

- Offre une base pour créer aisément des plugins
--

- Peut aussi être utilisé tel quel
--

- Fonctionne sans modification à l'aide d'une simple configuration
--

- Offre un contrôle complet à l'aide de callbacks
--

- Fourni Plugins pour Mojolicious et Dancer2
--

- Beaucoup beaucoup des tests
--

- Nécessite d'un peu refactorisation (spécialement pour le plugin Dancer2)
--

- Révision du code par au moins une autre personne 
--

???
Je suis l'auteur du plugin Mojolicious mais pas de celui pour Dancer2

Le plugin Dancer2 est le résultat d'un fork antérieur à mes derniers changements

Merci à Martin Renvoize pour son travail

---
# Les RFCs

- https://tools.ietf.org/html/rfc6749 - The OAuth 2.0 Authorization Framework, 76 pages

« MAY » x 29

« SHOULD » x 51
???
C'est compliqué, peu clair

- https://tools.ietf.org/html/rfc6819 - OAuth 2.0 Threat Model and Security Considerations, 71 pages

???
Presque aussi long !

--
- https://tools.ietf.org/html/rfc7521 - Assertion Framework for OAuth 2.0, 20 pages

???
Je ne comprends  pas la raison pour laquelle ce document existe
---
# Les flux

- Authorization Code Grant
--

- Implicit Grant
--

- Resource Owner Password Credentials Grant

--
- Client Credentials Grant

???
Il y a quatre flux, mais aussi ...

--
- Extension Grants

4.5.  Extension Grants

The client uses an extension grant type by specifying the grant type
   using an absolute URI (defined by the authorization server) as the
   value of the "grant_type" parameter of the token endpoint, and by
   adding any additional parameters necessary.

???
Extension Grants - Le « n'importe quoi » du grant

Donc, la question est: lequel utiliser et comment ?

---
# Authorization Code Grant

- Très populaire

???
Comme nous l'avons vu, utilisé par Google, Facebook, et al
--
- Utilisé par les "Login with" que vous trouvez sur le web

???
à l'exception de OAuth1
--
- Généralement pour des clients en navigateur internet (pas d'"apps")

--
- Le flux le plus sûr

--
- Aussi le plus compliqué :(

???
Un peu frustrant a mettre en place

--
- Mais, plus facile avec des plugins

--
- La sécurité est basée sur une liste de clients sûrs et leurs ‘secrets’

--
- Le client s'identifie grâce à un POST en arrière-plan pour obtenir un token d'accès

???
Le token d'accès n'est pas connu de l'utilisateur

---
# Authorization Code Grant

<pre>
   +----------+
   | Resource |
   |   Owner  |
   +----------+
        ^
        |
   +----|-----+        Client Identifier     +---------------+
   |         -+--(A)-- & Redirection URI --->|               |
   |  User-   |                              | Authorization |
   |  Agent  -+--(B)-- User authenticates -->|     Server    |
   |          |                              |               |
   |         -+--(C)-- Authorization Code --<|               |
   +-|----|---+                              +---------------+
     |    |                                      ^      v
    (A)  (C)                                     |      |
     |    |                                      |      |
     ^    v                                      |      |
   +---------+                                   |      |
   |         |>-(D)-- Authorization Code --------'      |
   |  Client |        & Redirection URI                 |
   |         |                                          |
   |         |<-(E)----- Access Token ------------------'
   +---------+       (w/ Optional Refresh Token)
</pre>

???
Resource owner - c'est vous

Authorization Server - c'est Google/Facebook

Client - c'est le site web qui dit "Login with Facebook"

---
# Authorization Code Grant

Un exemple de configuration Dancer2 :

```yml
plugins:
	"OAuth2::Server":
		jwt_secret: super_secret_jwt_secret
		clients:
			client_identifier:
				client_secret: super_secret_client_secret
				scopes:
					read_posts: 1
					post_to_wall: 0
```

Dans l'app :

```perl
use Dancer2::Plugin::OAuth2::Server;
 
get '/protected' => oauth_scopes 'read_posts' => sub { ... }
```

---
# Authorization Code Grant

```perl
my $ua  = ...
my $uri = URI->new( '/authorize' );
$uri->query_param( client_id     => 'client_identifier' );
$uri->query_param( redirect_uri  => 'http://localhost/callback' );
$uri->query_param( response_type => 'code' );
$uri->query_param( scope         => 'read_posts' );
```

```perl
# get an auth code
my $response = $ua->request( HTTP::Request->new( GET => $uri ) );
$uri = URI->new( $response->header('location') );
my $auth_code = $uri->query_param( 'code' );
```

---
# Authorization Code Grant

```perl
# get the access token
$request = POST '/access_token', Content => [
	client_id     => 'client_identifier',
    client_secret => 'super_secret_client_secret',
    grant_type    => 'authorization_code',
    code          => $auth_code,
    redirect_uri  => 'http://localhost/callback'
];

my $access_token = from_json( $ua->request($request)->content )->{access_token};
```

```perl
# call API with access token
$request = HTTP::Request->new( GET => '/protected' );
$request->header( Authorization => "Bearer $access_token");
```

---
# Implicit Grant

- Aussi très populaire
--

- Utilisé par les "Login with" trouvés dans les *apps*

--
- Généralement utilisé par les apps (portable, iPad, etc)

--
- Raisonnablement sûr

--
- Raisonnablement simple

--
- La sécurité est basée sur une liste de clients sûrs et leurs adresses (URLs) de *redirection*

--
- Token d'accès retourné par l'adresse de redirection dans un fragment

--
- Le token d'accès peut être connu d'utilisateur

???
Vulnérable à des attaques de type "man in the middle" ?

---
# Implicit Grant

---
# Implicit Grant

Exemple d'une configuration Mojolicious :

```perl
$self->plugin( 'OAuth2::Server' => {
	jwt_secret => $jwt_secret
	clients    => {
		client_identifier => {
			redirect_uri => 'https://client/cb',
			scopes       => {
				 read_posts   => 1,
				 post_to_wall => 0,
			}
		}
	}
} );
```

Dans le contrôleur :

```perl
if ( my $oauth_details = $c->oauth( qw/required scopes/ ) ) {
	... # do something, user_id, client_id, etc, available in $oauth_details
} else {
	return $c->render( status => 401, text => 'Unauthorized' );
}
```

???
example Mojolicious, "required scopes" n'est pas necessaire

---
# Implicit Grant

Contact du serveur avec l'identificateur client et l'URL de redirection :

```
curl -v 'https://foo.com/oauth/authorize
	?client_id=client_identifier
	&redirect_uri=https://client/cb
	&response_type=token'
```

Token d'accès retourné par l'URL de redirection dans un fragment

```
< Location: https://client/cb#access_token=ABCDEFG&token_type=bearer&expires_in=3600
```

Utilisation de l'API avec le token d'accès :

```
curl -v -H"Authorization: Bearer ABCDEFG" 'https://foo.com/api/v1.0/me' | jq

{
  ...
}

```

---
# Resource Owner Password Credentials Grant

- Rare
--

- En fait, pas recommandé
--

- Ne l'utilisez jamais ailleurs que dans contexte client / serveur privé
--

- Et uniquement si vous avez une totale confiance dans le client, le serveur et le réseau qui les lies

---
# Resource Owner Password Credentials Grant

---
# Resource Owner Password Credentials Grant

Exemple d'un script serveur simple

```perl
my $Server = Net::OAuth2::AuthorizationServer->new;
my $Grant  = $Server->password_grant(
	jwt_secret => 'weeeeee',
	clients => {
		bob => {
			client_secret => 'foo',
		},
	},
	users => {
		sue => 'letmein',
	}
);

```

???

Dans cet exemple, le client est la ligne de command

C'est un problème car nous donnons notre mot de passe au client

C'est aller à l'encontre d'OAuth2 ! Mais, il est possible de limiter les permissions

---
# Resource Owner Password Credentials Grant

```perl
my ( $is_valid,$error,$scopes ) = $Grant->verify_user_password(
	client_id     => $opts->{'client-id'}     // '',
	client_secret => $opts->{'client-secret'} // '',
	username      => $opts->{'username'}      // '',
	password      => $opts->{'password'}      // '',
);

die $error if ! $is_valid;

say $Grant->token(
	client_id       => $opts->{'client-id'} // '',
	scopes          => undef,
	type            => 'access',
);
```

???
Observez que le tocken d'accès n'es pas stocké

```sh
 > perl examples/password_credentials_grant.pl -c bob -s foo -u sue -p letmein
```

```sh
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOm51bGwsImNsaWVudCI6ImJvYiIsIm \
V4cCI6MTQ5NDY3NTczMSwiaWF0IjoxNDk0NjcyMTMxLCJqdGkiOiIyQUxUZzc2dENnbkl5SlJSc \
XJhTnRKUExNbk1JaEhwdiIsInNjb3BlcyI6bnVsbCwidHlwZSI6ImFjY2VzcyIsInVzZXJfaWQi \
Om51bGx9.L-dpho5QTNKtWkm2lQ76ljHufx2onBUJ_6MELs3mMMI
```

---
# Resource Owner Password Credentials Grant

```perl
if ( my $access_token = $opts->{'access-token'} ) {

my ( $is_valid,$error ) = $Grant->verify_access_token(
		access_token     => $access_token,
		is_refresh_token => 0,
	);

die $error if ! $is_valid;

say "Welcome";

}
```

???
Ceci pourrait être un processus/script complètement différent

Le JWT est persistant et contient tous les détails nécessaires

Si vous n'utilisez pas un JWT secret c'est une peu plus compliqué - j'y reviens dans une minute

```sh
 > perl examples/password_credentials_grant.pl -a \
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOm51bGwsImNsaWVudCI6ImJvYiIsIm \
V4cCI6MTQ5NDY3NTczMSwiaWF0IjoxNDk0NjcyMTMxLCJqdGkiOiIyQUxUZzc2dENnbkl5SlJSc \
XJhTnRKUExNbk1JaEhwdiIsInNjb3BlcyI6bnVsbCwidHlwZSI6ImFjY2VzcyIsInVzZXJfaWQi \
Om51bGx9.L-dpho5QTNKtWkm2lQ76ljHufx2onBUJ_6MELs3mMMI
```

```sh
Welcome
```

---
# Client Credentials Grant

- Également rare
--

- Seulement pour services internes
--

- Probablement quelque chose à oublier

---
# Client Credentials Grant

---
# Client Credentials Grant

Exemple d'un script CGI.pm:

```perl
use strict;
use warnings;

use Net::OAuth2::AuthorizationServer;
use CGI;

my $Server = Net::OAuth2::AuthorizationServer->new;
my $Grant  = $Server->client_credentials_grant(
	jwt_secret => 'weeeeee',
	clients => {
		bob => {
			client_secret => 'foo',
		},
	}
);
```

???
S'il vous plaît, n'utilisez jamais CGI.pm
---
# Client Credentials Grant

```perl
my $query = CGI->new;

my $client_id     = $query->param( 'client-id' )     // '';
my $client_secret = $query->param( 'client-secret' ) // '';

my ( $is_valid,$error,$scopes ) = $Grant->verify_client(
	client_id     => $client_id,
	client_secret => $client_secret,
);

print $query->header('application/json');
print "\"$error\"" if ! $is_valid; # JSON
exit( 1 )          if ! $is_valid;

print '{ "access_token":"' . $Grant->token(
	client_id       => $client_id,
	scopes          => undef,
	type            => 'access',
) . '" }';
```

---
# Client Credentials Grant

```perl
if ( my $access_token = $query->param( 'access-token' ) ) {

my ( $is_valid,$error ) = $Grant->verify_access_token(
		access_token     => $access_token,
		is_refresh_token => 0,
	);

print $query->header;
	print $error if ! $is_valid;
	exit( 1 )    if ! $is_valid;

print "Welcome";

} else {
...
}
```

---
# Client Credentials Grant

```sh
> curl http://127.0.0.1:3000/token -d "client-id=bob" -d "client-secret=foo"
```

```sh
{ "access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOm51bGwsImNsa \
WVudCI6ImJvYiIsImV4cCI6MTQ5NDcxMTkwNSwiaWF0IjoxNDk0NzA4MzA1LCJqdGkiOiJ5UnRZe \
FA3enAyaFVtVXVnNHk2RzlSUm0xWURWV1FFViIsInNjb3BlcyI6bnVsbCwidHlwZSI6ImFjY2Vzc \
yIsInVzZXJfaWQiOm51bGx9.1aKd8YxIz1uVCaO4ZT-JHCJdjyh6RLm1V8A8tYP-hN8" }
```

```sh
> curl -v http://127.0.0.1:3000/token -d "access-token=eyJhbGciOiJIUzI1NiIs \
InR5cCI6IkpXVCJ9.eyJhdWQiOm51bGwsImNsaWVudCI6ImJvYiIsImV4cCI6MTQ5NDcxMTkwNS \
wiaWF0IjoxNDk0NzA4MzA1LCJqdGkiOiJ5UnRZeFA3enAyaFVtVXVnNHk2RzlSUm0xWURWV1FFV \
iIsInNjb3BlcyI6bnVsbCwidHlwZSI6ImFjY2VzcyIsInVzZXJfaWQiOm51bGx9.1aKd8YxIz1u \
VCaO4ZT-JHCJdjyh6RLm1V8A8tYP-hN8"
```

--
```sh
Welcome
```

---
# Overriding Defaults

```perl
my $store_access_token_sub = sub {
  my ( %args ) = @_;

my (
    $obj,$client,$auth_code,$access_token,$refresh_token,
    $expires_in,$scope,$old_refresh_token
  ) = @args{qw/
    mojo_controller client_id auth_code access_token
    refresh_token expires_in scopes old_refresh_token
  / };

...
};
```
???
Si vous voulez faire du sur mesure, sauvegarder les tokens… vous pouvez remplacer les fonctionnalités par défaut

Par exemple, si vous désirez stocker les tokens d’accès quelque part, fournir des callbacks pour modifier une partie du flux, vous devez être conscient que tous les flux ne sont pas composés des mêmes parties

--
```sh
verify_client_cb
login_resource_owner_cb
confirm_by_resource_owner_cb
store_auth_code_cb
verify_auth_code_cb
store_access_token_cb
verify_access_token_cb
```

---
# Questions?

Links:

Blog Posts/Web Stuff

- [OAuth, An Introduction](https://hueniverse.com/introduction-e10f43314db5)
- [OAuth 2.0 - The Good, The Bad & The Ugly](https://code.tutsplus.com/articles/oauth-20-the-good-the-bad-the-ugly--net-33216)
- [OAuth 2.0 - Looking Back and Moving On](https://vimeo.com/52882780)

CPAN

- [Net::OAuth::AuthorizationServer](https://metacpan.org/release/Net-OAuth2-AuthorizationServer)
- [Net::OAuth2::AuthorizationServer::Manual](https://metacpan.org/release/Net-OAuth2-AuthorizationServer-Manual)
- [Mojolicious::Plugin::OAuth2](https://metacpan.org/release/Mojolicious-Plugin-OAuth2)
- [Mojolicious::Plugin::OAuth2::Server](https://metacpan.org/release/Mojolicious-Plugin-OAuth2-Server)
- [Dancer2::Plugin::Auth::OAuth](https://metacpan.org/pod/Dancer2::Plugin::Auth::OAuth)
- [Dancer2::Plugin::OAuth2::Server](https://metacpan.org/pod/Dancer2::Plugin::OAuth2::Server)
- [CatalystX::OAuth2::Provider](https://metacpan.org/release/CatalystX-OAuth2-Provider)