Printemps de Sécurité et @Async (Utilisateurs Authentifiés mélangé)

Je asynchrone appeler la méthode avec le Printemps, à l'aide de @Asynchrone.Cette méthode appelle d'autres méthode annotée avec @exiger une autorisation préalable, le Printemps de Sécurité de l'Annotation. Pour faire d'autorisation de travaux, je dois mettre en SecurityContextHolder mode de MODE_INHERITABLETHREADLOCAL, afin que l'authentification de l'info est passée à l'appel asynchrone. Tout fonctionne bien jusqu'à présent.

Cependant, quand je vous déconnecter et vous connecter en tant qu'utilisateur différent, dans la méthode asynchrone SecurityContextHolder magasins d'authentification info de l'ancien utilisateur, qui a été déconnecté. Il provoque des cours indésirables AccessDenied exception. Il n'y a pas ce problème avec des appels synchrones.

J'ai défini <task:executor id="executors" pool-size="10"/>, de sorte qu'il peut être un problème qu'une fois le fil dans la exécuteurs de la piscine a été initialisé, il ne sera pas remplacer l'authentification de l'information?

InformationsquelleAutor Lukasz Moren | 2011-03-09

34

Je suppose que MODE_INHERITABLETHREADLOCAL ne fonctionne pas correctement avec le pool de thread.

Comme une solution possible, vous pouvez essayer à la sous-classe ThreadPoolTaskExecutor et de redéfinir ses méthodes pour propager SecurityContext manuellement, et ensuite déclarer que l'exécuteur testamentaire au lieu de <task:executor>, quelque chose comme ceci:
```
public void execute(final Runnable r) {
    final Authentication a = SecurityContextHolder.getContext().getAuthentication();

    super.execute(new Runnable() {
        public void run() {
            try {
                SecurityContext ctx = SecurityContextHolder.createEmptyContext();
                ctx.setAuthentication(a);
                SecurityContextHolder.setContext(ctx);
                r.run();
            } finally {
                SecurityContextHolder.clearContext();
            }
        }
    });
}
```
- Je me demande si il est possible de modifier l'authentification (par exemple, pour ajouter une nouvelle autorité) dans un @méthode Asynchrone.
- Merci beaucoup, mais Dans mon cas, j'ai eu étend le execute(Callable c) (il est mieux de s'étendre " m en tout)
- J'ai essayer ceci mais ne fonctionne pas pour moi. Mon post stackoverflow.com/questions/37214386/... @axtavt
- Consultez la solution de @Ralph ci-dessous de référence utilisation de DelegatingSecurityContextAsyncTaskexecutor
- Veuillez vérifier org.springframework.security.concurrent.DelegatingSecurityContextExecutorService
InformationsquelleAutor axtavt
12

C'est juste une indication que les besoins futurs de l'enquête (je suis trop fatigué, mais peut-être que quelqu'un à trouver cela utile pour les recherches à venir):

Aujourd'hui, je suis tombé sur org.springframework.de sécurité.de la tâche.DelegatingSecurityContextAsyncTaskexecutor voir GitHub.

on dirait que son conçu pour déléguer le contexte de sécurité de sorte qu'il est "adopté" par le biais de la @Async appel.

Aussi avoir un oeil sur ce post: Printemps de Sécurité 3.2 M1 faits Saillants, Servlet 3 prise en charge des API est des sons, comme il est fortement lié.
- Cela a fonctionné pour moi - a créé un ThreadPoolTaskExecutor comme d'habitude et puis passé dans un DelegatingSecurityContextAsyncTaskexecutor.
- Vous l'utilisez comme ceci: @Bean(name = "threadPoolTaskExecutor") public Exécuteur threadPoolTaskExecutor() { return new DelegatingSecurityContextExecutorservice(Exécuteurs testamentaires.newFixedThreadPool(5)); }
- J'ai essayé comme par @nclord les commentaires, mais il ne fonctionne PAS pour moi. Il fonctionne par intermittence.
- Je pense que nclord est droit. Si cela fonctionne "par intermittence", alors il est probable qu'il ne fonctionne pas du tout. Cela sonne comme vous réutiliser des fils à partir d'un pool de threads et si vous êtes chanceux, vous obtenez un thread avec les "attendus" des informations d'identification. Mais pas parce que la sont fixés par DelegatingSecurityContextAsyncTaskExecutor mais parce que le reste d'une utilisation antérieure où ils ne sont pas supprimés par la suite.
InformationsquelleAutor Ralph
6

En utilisant les informations de Ralph et de Chêne -

Si vous souhaitez obtenir @Asynchrone de travail avec la norme exécuteur de tâches balise, vous devez définir votre source XML de config comme ceci
```
<task:annotation-driven executor="_importPool"/>
<task:executor id="_importPool" pool-size="5"/>

<bean id="importPool"
          class="org.springframework.security.task.DelegatingSecurityContextAsyncTaskExecutor">
     <constructor-arg ref="_importPool"/>
</bean>
```
Puis dans votre @méthode Asynchrone, vous devez spécifier la piscine que vous souhaitez utiliser
```
@Async("importPool")
public void run(ImportJob import) {
   ...
}
```
Qui devrait fonctionner ainsi, lorsque chaque fois que vous appelez votre @méthode Asynchrone, le pool de threads thread va utiliser le même contexte de sécurité que le thread appelant

InformationsquelleAutor rince

Basé sur @Ralph réponse on peut atteindre Aync event avec Spring avec threadpooling et délégué à la sécurité à l'aide http://docs.spring.io/autorepo/docs/spring-security/4.0.0.M1/apidocs/org/springframework/security/task/DelegatingSecurityContextAsyncTaskExecutor.html

Exemple de code

<bean id="applicationEventMulticaster"
    class="org.springframework.context.event.SimpleApplicationEventMulticaster">
    <property name="taskExecutor">
        <ref bean="delegateSecurityAsyncThreadPool"/>
    </property>
</bean>

<bean id="threadsPool"
    class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
</bean>


<bean id="delegateSecurityAsyncThreadPool"
    class="org.springframework.security.task.DelegatingSecurityContextTaskExecutor">
    <constructor-arg ref="threadsPool"/>
</bean>

InformationsquelleAutor oak

Jus à ajouter à la réponse de @axtavt, vous aussi, vous voulez remplacer une autre méthode.

@Override
    public <T> Future<T> submit(Callable<T> task) {
        ExecutorService executor = getThreadPoolExecutor();
        final Authentication a = SecurityContextHolder.getContext().getAuthentication();
        try {
            return executor.submit(new Callable<T>() {
                @Override
                public T call() throws Exception {
                    try {
                        SecurityContext ctx = SecurityContextHolder.createEmptyContext();
                        ctx.setAuthentication(a);
                        SecurityContextHolder.setContext(ctx);
                        return task.call();
                    } catch (Exception e) {
                        slf4jLogger.error("error invoking async thread. error details : {}", e);
                        return null;
                    } finally {
                        SecurityContextHolder.clearContext();
                    }
                }
            });
        } catch (RejectedExecutionException ex) {
            throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
        }
    }

InformationsquelleAutor Amit Parashar

Vous devez vous connecter pour publier un commentaire.