1
2
3
4
5
6
7
8
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
42
43
44
45 public class MuleSecurityManager implements SecurityManager
46 {
47
48
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
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 }