Discussion :

[scandinave]

Bonjour,

Je suis contraint d'utiliser le serveur d'application JOnAS 5.2 et j'essaie de mettre en place un système d'autorisation via ACL.

Jusque là tout va bien, sauf que ce serveur n'embarque apparamment pas le package sun.security contenu dans le JDK. Du coup, j'ai droit à un ClassNotFoundException.

Quelqu'un aurait-il une idée sur comment trouver ce package en dehors du JDK pour l'ajouter à mon projet ?
Ou encore mieux comment faire pour que JOnAS l'intègre, des fois que j'aurais oublié une configuration.

Merci d'avance pour votre aide.

[tchize_]

pourquoi en as-tu besoin? En général, les classes en com.sun.* correspondent à l'implémentation et ne font pas partie du standard. Pas de garantie d'être troujours présentes d'une jvm à l'autre.

[scandinave]

Quel implémentation utilise jonas pour les Acl alors? je n'est pas entendu qu'il existait d'autres implémentations pour les ACL.

[tchize_]

Si tu regarde ce qui se trouve dans la spec de JAAS (je suppose qu'on parle de cela), tu verra ici

http://docs.oracle.com/javase/1.5.0/...uide/security/

que toutes les classes dans com.sun.security implémentent des interface de java.security. Dans ton code tu ne dois travailler qu'avec ce qui se trouve dans les package java (java.* / javax.*) et laisser le conteneur, comme un grand, choisir quelle implémentation de jaas il veux utiliser.

[scandinave]

je comprend bien le problème mais quel est l'implémentation q'utilise jonas?

eclise ne me propose que sun.security.acl et com.sun.corba.se.impl.corba

Edit : Dans la doc sur java.security.acl, il est marqué

The classes and interfaces in this package have been superseded by classes in the java.security package.

En gros je fais fausse route

[tchize_]

Si tu commençais par nous montrer ton code?

[scandinave]

En gros j'ai deux filtres, le premier check si l'utilisateur est loggué, et le suivant check les autorisations.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
/**
* Servlet Filter implementation class AuthorizationFilter
*/
public class AuthorizationFilter implements Filter {
       private static final Logger LOGGER = Logger.getLogger(AuthorizationFilter.class);
       @EJB
       private IRoleService roleService;
       @EJB
       private IUtilisateurService utilisateurService;
       @EJB
       private IUrlService urlService;
       private List<Url> urls = new ArrayList<Url>();
 
       private Acl acl;
    /**
     * Default constructor.
     */
    public AuthorizationFilter() {
    }
 
       /**
       * @see Filter#destroy()
       */
       public void destroy() {
             // TODO Auto-generated method stub
       }
 
       /**
       * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
       */
       public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
             HttpServletRequest req = (HttpServletRequest) request;
             HttpSession session = req.getSession(false);
             Utilisateur util = (Utilisateur) req.getSession().getAttribute("util");
 
             chain.doFilter(request, response);
       }
 
       /**
       * @see Filter#init(FilterConfig)
       */
       public final void init(FilterConfig fConfig) throws ServletException {
             Principal owner = new PrincipalImpl("cismaa");
             acl = new AclImpl(owner, "supng");
             List<Role> roles = roleService.getAll();
             for (Role role : roles) {
                    Group g = new GroupImpl(role.getIdRole().toString());
                    for (Utilisateur util : role.getUtilisateurs()) {
                           g.addMember(new PrincipalImpl(util.getIdUtilisateur().toString()));
                    }
                    List<Autorisation> auths= roleService.getUrls(role);
 
                    for(Autorisation auth : auths){
                           Long urlId = auth.getIdAutorisation().getUrl();
                           Url url = urlService.findById(urlId);
                           Boolean droit = auth.getDroits();
                           AclEntry entry = new AclEntryImpl(g);
                           entry.addPermission(new PermissionImpl(url.getLibelleUrl()));
                           if(!droit)
                                  entry.setNegativePermissions();
                           try {
                                  acl.addEntry(owner, entry);
                           } catch (NotOwnerException e) {
                                  e.printStackTrace();
                           }
                    }
 
             }
 
             urls = roleService.getUrls();
       }
 
}

Du coups si les acl on été remplacer par JAAS, je devrait utiliser ce framework?
D'après ce que je lis, sur le net, JAAS fonctionne pas très bien avec Java EE

[tchize_]

Visiblement, tu récupère tes données de plusieurs EJBs (IRoleService par exemple). Il y a quoi là dedans, et tu essaie de faire quoi dans ce filter concrètement?

Parce que là je te vois créer des Rôles, des groupes, des ACLs, mais au final tout jeter .


Si ce qui te manque ce sont GroupImpl, PrincipalImpl, etc. Ce ne sont que des implémentation de l'interface. Tu peux implémenter ça toi même. C'est comme des beans, ça ne fait que stocker de l'information.

Pour prendre un exemple, Jboss a une classe JBossGenericPrincipal qui lui es propre. Et tu n'a pas à y toucher. Si t'as besoin de créer un principal, tu crée le tiens.

[scandinave]

Oui les implémentations je peux le faire moi même, mais du coup je me suis penché sur JAAS qui m'a l'air pas mal foutu.

Le seul soucis c'est que j'ai du mal à savoir comment le mettre en place.

En gros, j'ai une appli Java EE standart avec EJB 3 et JPA 2, j'ai des utilisateurs qui ont un rôle. Chaque rôle est associé à des ressources ( ici des url mais je suis pas sur que ce soit le plus élégant) . En gros je veux pouvoir authentifier un utilisateur et gérer les autorisations liées à son role.

Les utilisateurs, role, ressources et permissions sont stockées en base donné et le tout peut être modifié via l'application par un administrateur.

[tchize_]

Le problème, c'est que si tu veux pouvoir changer les rôles ayant accès à telle ou telle url, tu ne peux plus te baser sur la sécurité fournie par ton conteneur J2EE. Ce dernier se base sur des rôles associés à des url / servlet / méthodes particulières, que tu coule dans le bronze à la création du war. Tu a juste la liberté de changer les membre des rôle dans ta base de données.


Si tu veux jouer plus finement la sécurité toi même, il y a une api qui pourrait t'aider: spring security, qui permet d'injecter des règles plus ou moins complexe sur des méthodes (via la programmation Aspect) ou de vérifier certains droits.

Sinon, tu va devoir tout coder à la main pour ton application

[scandinave]

Donc jaas ne permet de pas de faire du dynamique non plus?

Je vais implémenter mes acl alors, au moins elle permet de faire correctement du dynamique.

[tchize_]

Disons que JAAS est une grosse artillerie, et tu risque d'en ch*** à le configurer :-)

[scandinave]

Ok bah je vais faire au plus simple, je reviendrais sur jaas par la suite si tu me dit que c'est quand même faisable.