|
1
28 package net.sf.jguard.ext.registration;
29
30 import java.util.Collections  ;
31 import java.util.HashSet ;
32 import java.util.Iterator ;
33 import java.util.Set ;
34 import java.util.logging.Logger ;
35
36 import javax.security.auth.Subject ;
37
38 import net.sf.jguard.core.authentication.credentials.JGuardCredential;
39 import net.sf.jguard.ext.authentication.AuthenticationException;
40
41
48 public class SubjectTemplate implements Cloneable {
49
50 private static final Logger logger = Logger.getLogger(SubjectTemplate.class.getName());
51 private Set privateRequiredCredentials;
52 private Set publicRequiredCredentials;
53 private Set publicOptionalCredentials;
54 private Set privateOptionalCredentials;
55 private Set missingPrivateRequiredCred;
56 private Set missingPublicRequiredCred;
57 private Set unknownPrivateOptionalCred;
58 private Set unknownPublicOptionalCred;
59 private String name;
60
61
62 private Set principals;
64
65
68 public SubjectTemplate(){
69 privateRequiredCredentials = new HashSet ();
71 publicRequiredCredentials = new HashSet ();
72 privateOptionalCredentials = new HashSet ();
73 publicOptionalCredentials = new HashSet ();
74 principals = new HashSet ();
75 missingPrivateRequiredCred = new HashSet ();
76 missingPublicRequiredCred = new HashSet ();
77 unknownPrivateOptionalCred = new HashSet ();
78 unknownPublicOptionalCred= new HashSet ();
79
80 }
81 public Set getPublicRequiredCredentials() {
82 return publicRequiredCredentials;
83 }
84
85 public Set getPrivateRequiredCredentials() {
86 return privateRequiredCredentials;
87 }
88
89 public Set getRequiredCredentials(){
90 Set requiredCredentials = new HashSet (publicRequiredCredentials);
91 requiredCredentials.addAll(privateRequiredCredentials);
92 return requiredCredentials;
93 }
94
95 public JGuardCredential getIdentityCredential() throws AuthenticationException{
96 Set requiredCredentials = getRequiredCredentials();
97 Iterator it = requiredCredentials.iterator();
98
99 while(it.hasNext()){
100 JGuardCredential cred = (JGuardCredential)it.next();
101 if(cred.isIdentity()==true){
102 return cred;
103 }
104 }
105 logger.severe(" subjectTemplate hasn't got any identity credential ");
106 throw new AuthenticationException(" subjectTemplate hasn't got any identity credential ");
107
108 }
109
110 public void setPrivateRequiredCredentials(Set privateCredentials) {
111 this.privateRequiredCredentials = privateCredentials;
112 }
113
114 public void setPublicRequiredCredentials(Set publicCredentials) {
115 this.publicRequiredCredentials = publicCredentials;
116 }
117
118
124 public void validateUser(SubjectTemplate user)throws RegistrationException{
125
126 if(user.getPrivateRequiredCredentials()==null){
127 logger.warning("private required credentials set from user is null ");
128 user.setPrivateRequiredCredentials(new HashSet ());
129 }
130 if(user.getPrivateOptionalCredentials()==null){
131 logger.warning("private optional credentials set from user is null ");
132 user.setPrivateOptionalCredentials(new HashSet ());
133 }
134 if(user.getPublicRequiredCredentials()==null){
135 logger.warning("public required credentials set from user is null ");
136 user.setPublicRequiredCredentials(new HashSet ());
137 }
138 if(user.getPublicOptionalCredentials()==null){
139 logger.warning("public optional credentials set from user is null ");
140 user.setPublicOptionalCredentials(new HashSet ());
141 }
142
143 missingPrivateRequiredCred =
144 validateCredentialSet(privateRequiredCredentials,user.getPrivateRequiredCredentials());
145 if(missingPrivateRequiredCred.size()>0){
146 throw new RegistrationException("missing private credentials required :"+missingPrivateRequiredCred,new HashSet (),missingPrivateRequiredCred);
147 }
148
149 missingPublicRequiredCred =
150 validateCredentialSet(publicRequiredCredentials,user.getPublicRequiredCredentials());
151 if(missingPrivateRequiredCred.size()>0){
152 throw new RegistrationException("missing public credentials required :"+missingPublicRequiredCred,missingPublicRequiredCred,new HashSet ());
153 }
154
155 unknownPrivateOptionalCred =
156 filterCredentialSetFromUser(privateOptionalCredentials,user.getPrivateOptionalCredentials());
157 if(unknownPrivateOptionalCred.size()>0){
158 logger.warning(" user has filled unknown optional private credentials :");
159 logger.warning(unknownPrivateOptionalCred.toString());
160 }
161 unknownPublicOptionalCred =
162 filterCredentialSetFromUser(publicOptionalCredentials,user.getPublicOptionalCredentials());
163 if(unknownPublicOptionalCred.size()>0){
164 logger.warning(" user has filled unknown optional public credentials :");
165 logger.warning(unknownPublicOptionalCred.toString());
166 }
167 }
168
169
175 private static Set getCredentials(Set credentialSetFromTemplate, Set credentialSetFromUser) {
176 Set creds = new HashSet ();
177 Iterator itCredentialFromTemplate = credentialSetFromTemplate.iterator();
178
179 while(itCredentialFromTemplate.hasNext()){
180 JGuardCredential jcred = (JGuardCredential)itCredentialFromTemplate.next();
181 Iterator itCredentialFromUser = credentialSetFromUser.iterator();
182 while(itCredentialFromUser.hasNext()){
183 JGuardCredential jcredFromUser =(JGuardCredential)itCredentialFromUser.next();
184 if(jcred.getId().equals(jcredFromUser.getId())){
186 creds.add(jcred);
187 break;
188 }
189 }
190 }
191
192 return creds;
193 }
194
195
196
202 public Set validateRequiredCredentialsFromUser(Subject user)throws AuthenticationException{
203 Set missingCredentials = new HashSet ();
204 Set credentialsNotRegistered = null;
205 Set userPublicRequiredCredentials = getCredentials(publicRequiredCredentials, user.getPublicCredentials(JGuardCredential.class));
207 Set missingPublicCredentials = validateCredentialSet(publicRequiredCredentials, userPublicRequiredCredentials);
208 missingCredentials.addAll(missingPublicCredentials);
209
210 Set userPublicOptionalCredentials = getCredentials(publicOptionalCredentials, user.getPublicCredentials(JGuardCredential.class));
211 credentialsNotRegistered = filterCredentialSetFromUser(publicOptionalCredentials, userPublicOptionalCredentials);
212 if(credentialsNotRegistered.size()>0){
213 logger.warning(" there are some unknown credentials filled by the user during the registration process: ");
214 logger.warning(credentialsNotRegistered.toString());
215 }
216
217
218 Set userPrivateRequiredCredentials = getCredentials(privateRequiredCredentials, user.getPrivateCredentials(JGuardCredential.class));
219 Set missingPrivateCredentials = validateCredentialSet(privateRequiredCredentials, userPrivateRequiredCredentials);
220 missingCredentials.addAll(missingPrivateCredentials);
221
222 Set userPrivateOptionalCredentials = getCredentials(privateOptionalCredentials, user.getPrivateCredentials(JGuardCredential.class));
223 credentialsNotRegistered = filterCredentialSetFromUser(privateOptionalCredentials, userPrivateOptionalCredentials);
224 if(credentialsNotRegistered.size()>0){
225 logger.warning(" there are some unknown credentials filled by the user during the registration process: ");
226 logger.warning(credentialsNotRegistered.toString());
227 }
228
229 return missingCredentials;
230 }
231
232
233
240 private static Set validateCredentialSet(Set credentialSetFromTemplate,Set credentialSetFromUser) {
241 Iterator itCredentialFromTemplate = credentialSetFromTemplate.iterator();
242 Set missingCredentials = new HashSet ();
243
244 while(itCredentialFromTemplate.hasNext()){
246 JGuardCredential jcred = (JGuardCredential)itCredentialFromTemplate.next();
247 Iterator itCredentialFromUser = credentialSetFromUser.iterator();
248 boolean found = false;
249 while(itCredentialFromUser.hasNext()){
250 JGuardCredential jcredFromUser =(JGuardCredential)itCredentialFromUser.next();
251 if(jcred.getId().equals(jcredFromUser.getId())){
253 found = true;
254 break;
255 }
256 }
257 if (false == found){
258 missingCredentials.add(jcred);
259 }
260 }
261
262 Set credentialsNotRegistered = SubjectTemplate.filterCredentialSetFromUser(credentialSetFromTemplate, credentialSetFromUser);
263 if(credentialsNotRegistered.size()>0){
264 logger.warning(" there are some unknown credentials filled by the user during the registration process: ");
265 logger.warning(credentialsNotRegistered.toString());
266 }
267
268 return missingCredentials;
269 }
270
271
277 private static Set filterCredentialSetFromUser(Set credentialSetFromTemplate, Set credentialSetFromUser) {
278 Iterator itCredentialFromTemplate;
279 Set credentialsNotRegistered = new HashSet ();
281 Iterator itCredentialFromUser = credentialSetFromUser.iterator();
282 while(itCredentialFromUser.hasNext()){
283 JGuardCredential jcred = (JGuardCredential)itCredentialFromUser.next();
284 itCredentialFromTemplate = credentialSetFromTemplate.iterator();
285 boolean found = false;
286 while(itCredentialFromTemplate.hasNext()){
287 JGuardCredential jcredFromUser =(JGuardCredential)itCredentialFromTemplate.next();
288 if(jcred.getId().equals(jcredFromUser.getId())){
289 found = true;
290 break;
291 }
292 }
293 if (false == found){
294 credentialsNotRegistered.add(jcred);
295 itCredentialFromUser.remove();
298 }
299 }
300 return credentialsNotRegistered;
301 }
302
303
308 public Subject buildSubject(SubjectTemplate user){
309
310 Set principalsForRegisteredUsers = new HashSet ();
311 principalsForRegisteredUsers.addAll((getPrincipals()));
312
313 Set publicCredentials = user.getPublicCredentials();
314 Set privateCredentials = user.getPrivateCredentials();
315
316 Subject subject = new Subject (false,principalsForRegisteredUsers,publicCredentials,privateCredentials);
317 return subject;
318 }
319
320
324 public Subject toSubject(){
325 return buildSubject(this);
326 }
327 public Set getPrivateOptionalCredentials() {
328 return privateOptionalCredentials;
329 }
330 public void setPrivateOptionalCredentials(Set privateOptionalCredentials) {
331 this.privateOptionalCredentials = privateOptionalCredentials;
332 }
333 public Set getPublicOptionalCredentials() {
334 return publicOptionalCredentials;
335 }
336 public void setPublicOptionalCredentials(Set publicOptionalCredentials) {
337 this.publicOptionalCredentials = publicOptionalCredentials;
338 }
339 public Set getPrincipals() {
340 return principals;
341 }
342
346 public void setPrincipals(Set principals) {
347 this.principals = principals;
348 }
349
350 public final Set getMissingPrivateRequiredCred() {
351 return missingPrivateRequiredCred;
352 }
353 public final Set getMissingPublicRequiredCred() {
354 return missingPublicRequiredCred;
355 }
356
357 public final Set getUnknownPrivateOptionalCred() {
358 return unknownPrivateOptionalCred;
359 }
360 public final Set getUnknownPublicOptionalCred() {
361 return unknownPublicOptionalCred;
362 }
363
364
371 public SubjectTemplate unmodifiableSubjectTemplate(){
372 SubjectTemplate readOnly = new SubjectTemplate();
373 readOnly.setName(this.name);
374 readOnly.principals = (Collections.unmodifiableSet(principals));
376
377 readOnly.privateOptionalCredentials=(Collections.unmodifiableSet(privateOptionalCredentials));
379 readOnly.privateRequiredCredentials=(Collections.unmodifiableSet(privateRequiredCredentials));
380 readOnly.publicOptionalCredentials=(Collections.unmodifiableSet(publicOptionalCredentials));
381 readOnly.publicRequiredCredentials=(Collections.unmodifiableSet(publicRequiredCredentials));
382
383 return readOnly;
384 }
385 public String getName() {
386 return name;
387 }
388 public void setName(String name) {
389 this.name = name;
390 }
391
392 public Set getPublicCredentials(){
393 Set publicCredentials = getPublicOptionalCredentials();
394 publicCredentials.addAll(getPublicRequiredCredentials());
395 return publicCredentials;
396 }
397
398 public Set getPrivateCredentials(){
399 Set privateCredentials = getPrivateOptionalCredentials();
400 privateCredentials.addAll(getPrivateRequiredCredentials());
401 return privateCredentials;
402
403 }
404
405
409 public Object clone() throws CloneNotSupportedException {
410
411 SubjectTemplate clone = (SubjectTemplate)super.clone();
412 clone.setName(name);
413 clone.setPrincipals(new HashSet (principals));
414 clone.setPrivateOptionalCredentials(cloneSet(privateOptionalCredentials));
415 clone.setPrivateRequiredCredentials(cloneSet(privateRequiredCredentials));
416 clone.setPublicOptionalCredentials(cloneSet(publicOptionalCredentials));
417 clone.setPublicRequiredCredentials(cloneSet(publicRequiredCredentials));
418 return clone;
419 }
420 private Set cloneSet(Set setToClone) throws CloneNotSupportedException {
421 Set clone = new HashSet ();
422 Iterator it = setToClone.iterator();
423 while(it.hasNext()){
424 JGuardCredential jcred = (JGuardCredential)it.next();
425 JGuardCredential clonedCred = new JGuardCredential();
426 clonedCred.setId(jcred.getId());
427 clonedCred.setIdentity(jcred.isIdentity());
428 clonedCred.setDigestNeeded(jcred.isDigestNeeded());
429 clone.add(clonedCred);
431 }
432 return clone;
433 }
434
435 }
436 |
Popular Tags |
Java API By Example, From Geeks To Geeks.