Comment mettre en œuvre FosOAuthServerBundle pour sécuriser une API REST?

J'ai également constaté que la documentation peut être un peu déroutant. Mais après de nombreuses heures de l'essayer, j'ai tout compris, avec l'aide de ce blog (mise à jour - le blog n'existe plus, changé à l'Internet Archive). Dans votre cas, vous n'avez pas besoin d'un pare-feu entrée pour ^/oauth/v2/auth parce que c'est pour la page d'autorisation. Vous devez vous rappeler ce que oAuth est capable de le faire... il est utilisé pour plus que juste une api REST. Mais si une api REST est ce que vous souhaitez protéger, vous n'en avez pas besoin. voici un exemple de config du pare-feu à partir de mon application:

firewalls:

    oauth_token:
        pattern:    ^/oauth/v2/token
        security:   false

    api_firewall:
        pattern: ^/api/.*
        fos_oauth: true
        stateless: true
        anonymous: false

    secure_area:
        pattern:    ^/
        fos_oauth: true
        form_login:
            provider: user_provider 
            check_path: /oauth/v2/auth_login_check
            login_path: /oauth/v2/auth_login
        logout:
            path:   /logout
            target: /
        anonymous: ~

access_control:
    - { path: ^/oauth/v2/auth_login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
    - { path: ^/, roles: IS_AUTHENTICATED_FULLY }

Avis que vous avez besoin de définir un utilisateur du fournisseur. Si vous utiliser FOSUserBundle, il y a un utilisateur fournisseur déjà créé pour vous. Dans mon cas, j'ai fait mon propre et de créer un service hors de lui.

Et dans ma config.yml:

fos_oauth_server:
    db_driver: orm
    client_class:        BB\AuthBundle\Entity\Client
    access_token_class:  BB\AuthBundle\Entity\AccessToken
    refresh_token_class: BB\AuthBundle\Entity\RefreshToken
    auth_code_class:     BB\AuthBundle\Entity\AuthCode
    service:
        user_provider: platform.user.provider
        options:
            supported_scopes: user

Je dois aussi mentionner que les tables que vous créez dans la base de données (access_token, client, auth_code, refresh_token) sont tenus d'avoir plus de champs que de ce qui est indiqué dans les docs...

Jeton d'accès de la Table: id(int), client_id(int), user_id(int), jeton(chaîne de caractères), la portée(string), expires_at(int)

Client de la Table: id(int), random_id(string), secret(string), redirect_urls(string), allowed_grant_types(string)

Auth Code de la Table: id(int), client_id(int), user_id(int)

Jeton d'actualisation de la Table: id(int), client_id(int), user_id(int), jeton(string), expires_at(int), la portée(string)

Ces tableaux de stocker les informations nécessaires pour oAuth, afin de mettre à jour votre Doctrine entités afin qu'elles correspondent à la db tables comme ci-dessus.

Et puis vous avez besoin d'un moyen de générer le secret et client_id, alors c'est la "Création d'un Client" section de la documentation vient, mais il n'est pas très utile...

Créer un fichier à /src/My/AuthBundle/Command/CreateClientCommand.php (vous en aurez besoin pour créer le dossier Command) Ce code est à partir de l'article que j'ai lié ci-dessus, et montre un exemple de ce que vous pouvez mettre dans ce fichier:

<?php
# src/Acme/DemoBundle/Command/CreateClientCommand.php
namespace Acme\DemoBundle\Command;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
class CreateClientCommand extends ContainerAwareCommand
{
protected function configure()
{
$this
->setName('acme:oauth-server:client:create')
->setDescription('Creates a new client')
->addOption(
'redirect-uri',
null,
InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
'Sets redirect uri for client. Use this option multiple times to set multiple redirect URIs.',
null
)
->addOption(
'grant-type',
null,
InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
'Sets allowed grant type for client. Use this option multiple times to set multiple grant types..',
null
)
->setHelp(
<<<EOT
The <info>%command.name%</info>command creates a new client.
<info>php %command.full_name% [--redirect-uri=...] [--grant-type=...] name</info>
EOT
);
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$clientManager = $this->getContainer()->get('fos_oauth_server.client_manager.default');
$client = $clientManager->createClient();
$client->setRedirectUris($input->getOption('redirect-uri'));
$client->setAllowedGrantTypes($input->getOption('grant-type'));
$clientManager->updateClient($client);
$output->writeln(
sprintf(
'Added a new client with public id <info>%s</info>, secret <info>%s</info>',
$client->getPublicId(),
$client->getSecret()
)
);
}
}

Ensuite pour créer le client_id et secret, exécuter cette commande à partir de la ligne de commande (ce sera à insérer dans la base de données de la nécessaire id et d'autres trucs):

php app/console acme:oauth-server:client:create --redirect-uri="http://clinet.local/" --grant-type="password" --grant-type="refresh_token" --grant-type="client_credentials"

avis que le acme:oauth-server:client:create peut être tout ce que vous avez réellement nom de votre commande dans le CreateClientCommand.php fichier avec $this->setName('acme:oauth-server:client:create').

Une fois que vous avez le client_id et secret, vous êtes prêt à s'authentifier. Faites une demande à votre navigateur et qui est quelque chose comme ceci:

http://example.com/oauth/v2/token?client_id=[CLIENT_ID_YOU GENERATED]&client_secret=[SECRET_YOU_GENERATED]&grant_type=password&username=[USERNAME]&password=[PASSWORD]

Espérons que cela fonctionne pour vous. Il y a certainement beaucoup de choses à configurer, il suffit d'essayer de prendre une étape à la fois.

J'ai aussi écrit une simple classe PHP pour appeler mon Symfony api REST en utilisant oAuth, si vous pensez que ce serait utile, faites le moi savoir et je peux le transmettre.

Mise à JOUR

En réponse à vos autres questions:

Le "client" est décrite sur le même blog, juste un autre article. Lire la Les Clients et les champs l'article ici, il convient de clarifier pour vous ce qu'est un client. Comme mentionné dans l'article, vous n'avez pas besoin d'un client pour chaque utilisateur. Vous pourriez avoir un client unique pour toutes vos utilisateurs, si vous le souhaitez.

Je suis également à l'aide de la classique de Symfony authentification pour mon frontend du site, mais cela peut changer dans l'avenir. Donc, il est toujours bon de garder ces choses dans le dos de votre esprit, mais je ne dirais pas que c'est étrange de combiner les deux méthodes.

La refresh_token est utilisé lorsque l'access_token a expiré et vous souhaitez demander une nouvelle access_token sans renvoyer les informations d'identification utilisateur. au lieu de cela, vous envoyer le jeton d'actualisation et d'obtenir un nouveau access_token. Ce n'est pas vraiment nécessaire pour une API REST, car une seule demande ne sera probablement pas prendre suffisamment longtemps pour que l'access_token le point d'expirer.

oAuth1 et oAuth2 sont très différents, donc, je suppose que la méthode que vous utilisez ne fonctionne pas, mais je n'ai jamais essayé avec qui. Mais juste pour le test, vous pouvez faire un normal requête GET ou POST, aussi longtemps que vous passez le access_token=[ACCESS_TOKEN] dans la chaîne de requête GET (pour tous les types de demandes, en fait).

Mais de toute façon, ici, c'est ma classe. J'ai utilisé un fichier de configuration pour stocker des variables, et je n'ai pas implémenté la possibilité de SUPPRIMER, mais ce n'est pas trop dur.

class RestRequest{
private $token_url;
private $access_token;
private $refresh_token;
private $client_id;
private $client_secret;
public function __construct(){
include 'config.php';
$this->client_id = $conf['client_id'];
$this->client_secret = $conf['client_secret']; 
$this->token_url = $conf['token_url'];
$params = array(
'client_id'=>$this->client_id,
'client_secret'=>$this->client_secret,
'username'=>$conf['rest_user'],
'password'=>$conf['rest_pass'],
'grant_type'=>'password'
);
$result = $this->call($this->token_url, 'GET', $params);
$this->access_token = $result->access_token;
$this->refresh_token = $result->refresh_token;
}
public function getToken(){
return $this->access_token;
}
public function refreshToken(){
$params = array(
'client_id'=>$this->client_id,
'client_secret'=>$this->client_secret,
'refresh_token'=>$this->refresh_token,
'grant_type'=>'refresh_token'
);
$result = $this->call($this->token_url, "GET", $params);
$this->access_token = $result->access_token;
$this->refresh_token = $result->refresh_token;
return $this->access_token;
}
public function call($url, $method, $getParams = array(), $postParams = array()){
ob_start();
$curl_request = curl_init();
curl_setopt($curl_request, CURLOPT_HEADER, 0); //don't include the header info in the output
curl_setopt($curl_request, CURLOPT_RETURNTRANSFER, 1); //don't display the output on the screen
$url = $url."?".http_build_query($getParams);
switch(strtoupper($method)){
case "POST": //Set the request options for POST requests (create)
curl_setopt($curl_request, CURLOPT_URL, $url); //request URL
curl_setopt($curl_request, CURLOPT_POST, 1); //set request type to POST
curl_setopt($curl_request, CURLOPT_POSTFIELDS, http_build_query($postParams)); //set request params
break;
case "GET": //Set the request options for GET requests (read)
curl_setopt($curl_request, CURLOPT_URL, $url); //request URL and params
break;
case "PUT": //Set the request options for PUT requests (update)
curl_setopt($curl_request, CURLOPT_URL, $url); //request URL
curl_setopt($curl_request, CURLOPT_CUSTOMREQUEST, "PUT"); //set request type
curl_setopt($curl_request, CURLOPT_POSTFIELDS, http_build_query($postParams)); //set request params
break;
case "DELETE":
break;
default:
curl_setopt($curl_request, CURLOPT_URL, $url);
break;
}
$result = curl_exec($curl_request); //execute the request
if($result === false){
$result = curl_error($curl_request);
}
curl_close($curl_request);
ob_end_flush();
return json_decode($result);
}
}

Puis d'utiliser la classe, tout:

$request = new RestRequest();
$insertUrl = "http://example.com/api/users";
$postParams = array(
"username"=>"test",
"is_active"=>'false',
"other"=>"3g12g53g5gg4g246542g542g4"
);
$getParams = array("access_token"=>$request->getToken());
$response = $request->call($insertUrl, "POST", $getParams, $postParams);