View Javadoc

1   /*
2    * $Id: MuleSecurityManager.java 19191 2010-08-25 21:05:23Z tcarlson $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.security;
12  
13  import org.mule.api.EncryptionStrategy;
14  import org.mule.api.lifecycle.Initialisable;
15  import org.mule.api.lifecycle.InitialisationException;
16  import org.mule.api.lifecycle.LifecycleTransitionResult;
17  import org.mule.api.security.Authentication;
18  import org.mule.api.security.SecurityContext;
19  import org.mule.api.security.SecurityException;
20  import org.mule.api.security.SecurityManager;
21  import org.mule.api.security.SecurityProvider;
22  import org.mule.api.security.SecurityProviderNotFoundException;
23  import org.mule.api.security.UnauthorisedException;
24  import org.mule.api.security.UnknownAuthenticationTypeException;
25  import org.mule.config.i18n.CoreMessages;
26  
27  import java.util.ArrayList;
28  import java.util.Collection;
29  import java.util.Collections;
30  import java.util.Iterator;
31  import java.util.LinkedList;
32  import java.util.List;
33  import java.util.Map;
34  
35  import edu.emory.mathcs.backport.java.util.concurrent.ConcurrentHashMap;
36  
37  import org.apache.commons.logging.Log;
38  import org.apache.commons.logging.LogFactory;
39  
40  /**
41   * <code>MuleSecurityManager</code> is a default implementation security manager
42   * for a Mule instance.
43   */
44  
45  public class MuleSecurityManager implements SecurityManager
46  {
47      /**
48       * logger used by this class
49       */
50      protected static final Log logger = LogFactory.getLog(MuleSecurityManager.class);
51  
52      @SuppressWarnings("unchecked")
53      private Map<String, SecurityProvider> providers = new ConcurrentHashMap();
54  
55      @SuppressWarnings("unchecked")
56      private Map<String, EncryptionStrategy> cryptoStrategies = new ConcurrentHashMap();
57  
58      public MuleSecurityManager()
59      {
60          super();
61      }
62  
63      public void initialise() throws InitialisationException
64      {
65          List<Initialisable> all = new LinkedList<Initialisable>(providers.values());
66          // ordering: appends
67          all.addAll(cryptoStrategies.values());
68          LifecycleTransitionResult.initialiseAll(all.iterator());
69      }
70  
71      public Authentication authenticate(Authentication authentication)
72          throws SecurityException, SecurityProviderNotFoundException
73      {
74          Iterator<SecurityProvider> iter = providers.values().iterator();
75          Class<? extends Authentication> toTest = authentication.getClass();
76  
77          while (iter.hasNext())
78          {
79              SecurityProvider provider = iter.next();
80  
81              if (provider.supports(toTest))
82              {
83                  if (logger.isDebugEnabled())
84                  {
85                      logger.debug("Authentication attempt using " + provider.getClass().getName());
86                  }
87  
88                  Authentication result = null;
89                  try
90                  {
91                      result = provider.authenticate(authentication);
92                  }
93                  catch (Exception e)
94                  {
95                      if (!iter.hasNext())
96                      {
97                          throw new UnauthorisedException(CoreMessages.authorizationAttemptFailed(), e);
98                      }
99                  }
100 
101                 if (result != null)
102                 {
103                     return result;
104                 }
105             }
106         }
107 
108         throw new SecurityProviderNotFoundException(toTest.getName());
109     }
110 
111     public void addProvider(SecurityProvider provider)
112     {
113         if (getProvider(provider.getName()) != null)
114         {
115             throw new IllegalArgumentException("Provider already registered: " + provider.getName());
116         }
117         providers.put(provider.getName(), provider);
118     }
119 
120     public SecurityProvider getProvider(String name)
121     {
122         if (name == null)
123         {
124             throw new IllegalArgumentException("provider Name cannot be null");
125         }
126         return providers.get(name);
127     }
128 
129     public SecurityProvider removeProvider(String name)
130     {
131         return providers.remove(name);
132     }
133 
134     public Collection<SecurityProvider> getProviders()
135     {
136         ArrayList<SecurityProvider> providersList = new ArrayList<SecurityProvider>(providers.values());
137         return Collections.unmodifiableCollection(providersList);
138     }
139 
140     public void setProviders(Collection<SecurityProvider> providers)
141     {
142         for (SecurityProvider provider : providers)
143         {
144             addProvider(provider);
145         }
146     }
147 
148     public SecurityContext createSecurityContext(Authentication authentication)
149         throws UnknownAuthenticationTypeException
150     {
151         Iterator<SecurityProvider> iter = providers.values().iterator();
152         Class<? extends Authentication> toTest = authentication.getClass();
153 
154         while (iter.hasNext())
155         {
156             SecurityProvider provider = iter.next();
157             if (provider.supports(toTest))
158             {
159                 return provider.createSecurityContext(authentication);
160             }
161         }
162         throw new UnknownAuthenticationTypeException(authentication);
163     }
164 
165     public EncryptionStrategy getEncryptionStrategy(String name)
166     {
167         return cryptoStrategies.get(name);
168     }
169 
170     public void addEncryptionStrategy(EncryptionStrategy strategy)
171     {
172         cryptoStrategies.put(strategy.getName(), strategy);
173     }
174 
175     public EncryptionStrategy removeEncryptionStrategy(String name)
176     {
177         return cryptoStrategies.remove(name);
178     }
179 
180     public Collection<EncryptionStrategy> getEncryptionStrategies()
181     {
182         List<EncryptionStrategy> allStrategies = new ArrayList<EncryptionStrategy>(cryptoStrategies.values());
183         return Collections.unmodifiableCollection(allStrategies);
184     }
185 
186     public void setEncryptionStrategies(Collection<EncryptionStrategy> strategies)
187     {
188         for (EncryptionStrategy strategy : strategies)
189         {
190             addEncryptionStrategy(strategy);
191         }
192     }
193 }