Symfony 将有状态应用程序与无状态JWT相结合

我们有一个FOSUserBundle登录系统，通过LDAP和fr3d LDAP包进行身份验证。它的行为类似于使用会话的普通多页应用程序。我们还有几个使用FOSRestbundle和普通会话进行身份验证的RESTful端点。但是，我们需要与外部应用程序共享一些端点

我们设法使用Lexik包实现了JWT。它会返回一个令牌。然而，我不知道让用户使用我们的登录表单来获取这个令牌的最佳方法，这样他们的请求就可以在头或会话中传递它。我的问题是，如何允许用户以有状态的方式登录到我们的应用程序，同时也接收JWT并在ajax请求时将其传递给服务器。通过这种方式，我可以允许外部客户端直接连接到API。下面是我的symfony2安全配置security.yml：

security:

    #erase_credentials: false

    encoders:
        FOS\UserBundle\Model\UserInterface: bcrypt

    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: [ROLE_USER, ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]

    providers:
        chain_provider:
            chain:
                providers: [my_user_provider, fr3d_ldapbundle]

        in_memory:
            memory:
                users:
                    admin: { password: secret, roles: 'ROLE_ADMIN' }

        my_user_provider:
            id: app.custom_user_provider

        fos_userbundle:
            id: fos_user.user_provider.username

        fr3d_ldapbundle:
            id: fr3d_ldap.security.user.provider

    access_control:
        - { path: ^/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/register, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/resetting, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/, role: IS_AUTHENTICATED_FULLY }
        - { path: ^/api, role: IS_AUTHENTICATED_FULLY }
        - { path: ^/api/login, role: IS_AUTHENTICATED_ANONYMOUSLY }

    firewalls:
        dev:
            pattern: ^/(_(profiler|wdt)|css|images|js)/
            security: false

        api_login:
            pattern: ^/api/login
            fr3d_ldap:  ~
            provider: chain_provider
            anonymous: true
            stateless: false
            form_login:
                check_path: /api/login_check
                username_parameter: username
                password_parameter: password
                require_previous_session: false
                success_handler: lexik_jwt_authentication.handler.authentication_success
                failure_handler: lexik_jwt_authentication.handler.authentication_failure

        api:
            pattern:   ^/api
            provider: chain_provider
            stateless: false 
            lexik_jwt:
                throw_exceptions: true
                create_entry_point: true

        main:
            pattern: ^/
            fr3d_ldap:  ~
            form_login:
                # provider: fos_userbundle
                provider: chain_provider
                always_use_default_target_path: true
                default_target_path: /
                csrf_provider: security.csrf.token_manager
            logout: true
            anonymous: true
            switch_user: { role: ROLE_LIMS-BIOINFO}

编辑：

根据Kévin的回答，我决定实现一个自定义的细枝扩展，以便在每次页面加载时为登录用户获取令牌：

AppBundle/Extension/JsonWebToken.php：

<?php 

namespace AppBundle\Extension;

use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTManagerInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;

class JsonWebToken extends \Twig_Extension
{
    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var JWTManagerInterface
     */
    private $jwt;

    public function __construct(ContainerInterface $container, JWTManagerInterface $jwt)
    {
        $this->container = $container;
        $this->jwt = $jwt;
    }

    public function getName()
    {
        return 'json_web_token';
    }

    public function getFunctions()
    {
        return [
            'json_web_token' => new \Twig_Function_Method($this, 'getToken')
        ];
    }

    public function getToken()
    {
        $user = $this->container->get('security.token_storage')->getToken()->getUser();
        $token = $this->jwt->create($user);

        return $token;
    }
}

app/Resources/views/layout.html.twig

<script>window.jsonWebToken = '{{ json_web_token() }}';</script>

---

到目前为止，这似乎运作良好。它让我的外部API用户和内部应用程序用户共享相同的身份验证方法

由于JWT令牌必须存储在客户端（而不是存储在cookie中以防止CSRF攻击），因此您可以使用LexikJWTAuthenticationBundle提供的

lexik_JWT_authentication.JWT_manager

服务的

create

方法在登录后生成令牌，然后在生成的HTML中的

标记中注入这个令牌。

嘿，我最近遇到了同样的情况。 为了生成JWT，我创建了一个重定向侦听器

class RedirectListener implements EventSubscriberInterface
{
    //the private variables go up here

    public function __construct(\Twig_Environment $twig, TokenStorageInterface $sam, EntityManagerInterface $em, JWTTokenManagerInterface $JWTTokenManager)
    {
        $this->twig = $twig;
        $this->sam = $sam;
        $this->em = $em;
        $this->JWTTokenManager = $JWTTokenManager;
    }

    public function kernelRequest(GetResponseEvent $event)
    {
        $request = $event->getRequest();
        $route = $request->get('_route');
        $routeParams = $request->get('_route_params');
        $pathInfo = $request->getPathInfo();
        $matchApp = preg_match('/\/app/', $pathInfo);

        if ($event->isMasterRequest()) {
            if ($matchApp) {
                $token = $this->sam->getToken();
                if ($token) {
                    /** @var User $user */
                    $user = $token->getUser();
                    if($user instanceof User){
                        $token = $this->JWTTokenManager->create($user);
                        $this->twig->addGlobal('jwt', $token);
                    }
                }
            }
        }
        return $event;
    }
}

这帮助我将JWT添加到我的小树枝模板中（我使用我的基本模板来确保它出现在每个页面上）

接下来，服务器现在可以通过JWT从JS接收消息

 public function __construct(ContainerInterface $container)
{

    $router = new Router();
    $realm = "realm1";

    $router->addInternalClient(new Pusher($realm, $router->getLoop()));
    $router->addTransportProvider(new RatchetTransportProvider("0.0.0.0", 8080));
    try{
        $router->start();
    } catch (\Exception $exception){
        var_dump($exception->getMessage());
    }

}

我现在需要为路由器注册一个模块，该模块将充当侦听器，并将消息发送回已注册的主题（JWT）

---

我还没有100%做到这一点，所以如果有任何建议，我将不胜感激，并且我会在进行过程中不断更新。

谢谢，这很有意义。我将在接下来的几天内对此进行一次尝试，如果它有效的话，我将接受你的答案。将令牌注入脚本标记中不会是一个安全问题吗？例如，如果用户在登录后保存其页面，它将在html中包含其jwt标记。然后，他可以在不知道自己在共享令牌的情况下共享保存的页面。

class RedirectListener implements EventSubscriberInterface
{
    //the private variables go up here

    public function __construct(\Twig_Environment $twig, TokenStorageInterface $sam, EntityManagerInterface $em, JWTTokenManagerInterface $JWTTokenManager)
    {
        $this->twig = $twig;
        $this->sam = $sam;
        $this->em = $em;
        $this->JWTTokenManager = $JWTTokenManager;
    }

    public function kernelRequest(GetResponseEvent $event)
    {
        $request = $event->getRequest();
        $route = $request->get('_route');
        $routeParams = $request->get('_route_params');
        $pathInfo = $request->getPathInfo();
        $matchApp = preg_match('/\/app/', $pathInfo);

        if ($event->isMasterRequest()) {
            if ($matchApp) {
                $token = $this->sam->getToken();
                if ($token) {
                    /** @var User $user */
                    $user = $token->getUser();
                    if($user instanceof User){
                        $token = $this->JWTTokenManager->create($user);
                        $this->twig->addGlobal('jwt', $token);
                    }
                }
            }
        }
        return $event;
    }
}

    {% if jwt is defined %}
        <span class="hidden" id="jwt" data-jwt="{{ jwt ? jwt : 'null' }}"></span>
    {% endif %}

let jwt = $('#jwt').data('jwt');
let connection = new Connection({url:"ws://127.0.0.1:8080/ws", realm:"realm1"});
connection.onopen = (session) => {
    function onevent(args) {
        console.log("Event:", args[0])
    }
    session.subscribe(jwt, onevent);
}
connection.open();

 public function __construct(ContainerInterface $container)
{

    $router = new Router();
    $realm = "realm1";

    $router->addInternalClient(new Pusher($realm, $router->getLoop()));
    $router->addTransportProvider(new RatchetTransportProvider("0.0.0.0", 8080));
    try{
        $router->start();
    } catch (\Exception $exception){
        var_dump($exception->getMessage());
    }

}