Java > Open Source Codes > test > javax > management > remote > RemoteSecurityManagerTestCase


1 /*
2  * Copyright (C) The MX4J Contributors.
3  * All rights reserved.
4  *
5  * This software is distributed under the terms of the MX4J License version 1.0.
6  * See the terms of the MX4J License in the documentation provided with this software.
7  */
8
9 package test.javax.management.remote;
10
11 import java.net.MalformedURLException ;
12 import java.net.SocketPermission ;
13 import java.security.AccessController ;
14 import java.security.AllPermission ;
15 import java.security.CodeSource ;
16 import java.security.Permission ;
17 import java.security.PermissionCollection ;
18 import java.security.Permissions ;
19 import java.security.Policy ;
20 import java.security.Principal ;
21 import java.security.ProtectionDomain ;
22 import java.security.SecurityPermission ;
23 import java.util.Collections ;
24 import java.util.Enumeration ;
25 import java.util.HashMap ;
26 import java.util.HashSet ;
27 import java.util.Map ;
28 import java.util.Set ;
29 import javax.management.MBeanPermission ;
30 import javax.management.MBeanServer ;
31 import javax.management.MBeanServerConnection ;
32 import javax.management.MBeanServerFactory ;
33 import javax.management.MBeanServerPermission ;
34 import javax.management.MBeanTrustPermission ;
35 import javax.management.ObjectName ;
36 import javax.management.remote.JMXAuthenticator ;
37 import javax.management.remote.JMXConnector ;
38 import javax.management.remote.JMXConnectorFactory ;
39 import javax.management.remote.JMXConnectorServer ;
40 import javax.management.remote.JMXConnectorServerFactory ;
41 import javax.management.remote.JMXPrincipal ;
42 import javax.management.remote.JMXServiceURL ;
43 import javax.management.remote.SubjectDelegationPermission ;
44 import javax.security.auth.AuthPermission ;
45 import javax.security.auth.Subject ;
46
47 import junit.framework.TestCase;
48 import mx4j.remote.MX4JRemoteUtils;
49 import mx4j.server.MX4JMBeanServer;
50 import test.javax.management.SecurityManagerTestCase;
51
52 /**
53  * @version $Revision: 1.4 $
54  */
55 public abstract class RemoteSecurityManagerTestCase extends SecurityManagerTestCase
56 {
57    public RemoteSecurityManagerTestCase(String s)
58    {
59       super(s);
60    }
61
62    protected void setUp() throws Exception
63    {
64       // Be sure we have a security manager and the right policy
65 SecurityManager sm = System.getSecurityManager();
66       if (sm == null) fail();
67       Policy policy = Policy.getPolicy();
68       if (!(policy instanceof RemoteModifiablePolicy)) fail();
69       ((RemoteModifiablePolicy)policy).initialize();
70    }
71
72    protected void tearDown() throws Exception
73    {
74       // Allow the sockets to shut down
75 sleep(2000);
76    }
77
78    protected void addPermission(Permission p)
79    {
80       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
81       policy.addServerPermission(p);
82    }
83
84    protected void resetPermissions()
85    {
86       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
87       policy.initialize();
88    }
89
90    /**
91     * Creates and returns a suitable JMXServiceURL for the specific JMXConnectorServer
92     * used in the tests. Subclasses implements it to return specific JMXServiceURL.
93     */
94    protected abstract JMXServiceURL createJMXConnectorServerAddress() throws MalformedURLException ;
95
96    /**
97     * Creates and returns a new environment map to be used for the server side
98     *
99     * @see #createClientEnvironment
100     */
101    protected Map createServerEnvironment()
102    {
103       return new HashMap ();
104    }
105
106    /**
107     * Creates and returns a new environment map to be used for the client side
108     *
109     * @see #createServerEnvironment
110     */
111    protected Map createClientEnvironment()
112    {
113       return new HashMap ();
114    }
115
116    public void testNewJMXConnectorServer() throws Exception
117    {
118       addPermission(new MBeanServerPermission ("newMBeanServer"));
119
120       JMXServiceURL url = createJMXConnectorServerAddress();
121       JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
122
123       try
124       {
125          cntorServer.start();
126          fail();
127       }
128       catch (SecurityException x)
129       {
130       }
131    }
132
133    public void testStartJMXConnectorServer() throws Exception
134    {
135       addPermission(new MBeanServerPermission ("newMBeanServer"));
136
137       JMXServiceURL url = createJMXConnectorServerAddress();
138       JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
139
140       addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
141       try
142       {
143          cntorServer.start();
144       }
145       finally
146       {
147          cntorServer.stop();
148       }
149    }
150
151    public void testConnect() throws Exception
152    {
153       addPermission(new MBeanServerPermission ("newMBeanServer"));
154
155       JMXServiceURL url = createJMXConnectorServerAddress();
156       JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
157
158       // Required by the server
159 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
160
161       JMXConnector cntor = null;
162       try
163       {
164          cntorServer.start();
165
166          RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
167          policy.setSeparateClientServerPermissions(true);
168
169          try
170          {
171             JMXConnectorFactory.connect(cntorServer.getAddress());
172             fail();
173          }
174          catch (SecurityException x)
175          {
176          }
177
178          // Allow any client to connect to the server
179 addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
180          // Allow this client to open a socket to connect to the server
181 policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
182          cntor = JMXConnectorFactory.connect(cntorServer.getAddress());
183       }
184       finally
185       {
186          if (cntor != null) cntor.close();
187          if (cntorServer != null) cntorServer.stop();
188       }
189    }
190
191    public void testAuthenticatedConnect() throws Exception
192    {
193       addPermission(new MBeanServerPermission ("newMBeanServer"));
194
195       JMXServiceURL url = createJMXConnectorServerAddress();
196       Map serverEnv = createServerEnvironment();
197       serverEnv.put(JMXConnectorServer.AUTHENTICATOR, new JMXAuthenticator ()
198       {
199          public Subject authenticate(Object credentials) throws SecurityException
200          {
201             if (!(credentials instanceof String [])) throw new SecurityException ("No credentials provided");
202             String [] creds = (String [])credentials;
203             if (creds.length != 2) throw new SecurityException ("Bad credentials");
204             String user = creds[0];
205             String password = creds[1];
206             if (!"test".equals(user)) throw new SecurityException ("Unknown user");
207             if (!"test".equals(password)) throw new SecurityException ("Wrong password");
208             Principal principal = new JMXPrincipal (user);
209             Set principals = new HashSet ();
210             principals.add(principal);
211             Subject subject = new Subject (true, principals, Collections.EMPTY_SET, Collections.EMPTY_SET);
212             return subject;
213          }
214       });
215
216       JMXConnectorServer cntorServer = null;
217       JMXConnector cntor = null;
218       try
219       {
220          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, serverEnv, newMBeanServer());
221
222          // Required by the server
223 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
224          cntorServer.start();
225
226          RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
227          policy.setSeparateClientServerPermissions(true);
228
229          Map clientEnv = createClientEnvironment();
230          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"test", "test"});
231          // Allow this client to open a socket to connect to the server
232 policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
233          // Allow the authenticated subject to listen and accept a connection
234 policy.addServerPermission(new JMXPrincipal ("test"), new SocketPermission ("localhost:" + url.getPort(), "listen"));
235          policy.addServerPermission(new JMXPrincipal ("test"), new SocketPermission ("*:1024-" + url.getPort(), "accept"));
236
237          // No credentials
238 try
239          {
240             JMXConnectorFactory.connect(cntorServer.getAddress());
241             fail();
242          }
243          catch (SecurityException x)
244          {
245          }
246
247          // Bad credentials
248 clientEnv = createClientEnvironment();
249          clientEnv.put(JMXConnector.CREDENTIALS, null);
250          try
251          {
252             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
253             fail();
254          }
255          catch (SecurityException x)
256          {
257          }
258
259          // Bad credentials
260 clientEnv = createClientEnvironment();
261          clientEnv.put(JMXConnector.CREDENTIALS, new StringBuffer ());
262          try
263          {
264             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
265             fail();
266          }
267          catch (SecurityException x)
268          {
269          }
270
271          // Bad credentials
272 clientEnv = createClientEnvironment();
273          clientEnv.put(JMXConnector.CREDENTIALS, new String [0]);
274          try
275          {
276             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
277             fail();
278          }
279          catch (SecurityException x)
280          {
281          }
282
283          // Bad credentials
284 clientEnv = createClientEnvironment();
285          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"dummy"});
286          try
287          {
288             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
289             fail();
290          }
291          catch (SecurityException x)
292          {
293          }
294
295          // Bad credentials
296 clientEnv = createClientEnvironment();
297          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"dummy", "dummy"});
298          try
299          {
300             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
301             fail();
302          }
303          catch (SecurityException x)
304          {
305          }
306
307          // Bad credentials
308 clientEnv = createClientEnvironment();
309          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"dummy", "dummy", "dummy"});
310          try
311          {
312             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
313             fail();
314          }
315          catch (SecurityException x)
316          {
317          }
318
319          // Bad credentials
320 clientEnv = createClientEnvironment();
321          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"test", "wrong"});
322          try
323          {
324             JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
325             fail();
326          }
327          catch (SecurityException x)
328          {
329          }
330
331          clientEnv = createClientEnvironment();
332          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"test", "test"});
333          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
334       }
335       finally
336       {
337          if (cntor != null) cntor.close();
338          if (cntorServer != null) cntorServer.stop();
339       }
340    }
341
342    public void testAuthenticatedSubjectOnServerSide() throws Exception
343    {
344       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
345       addPermission(new MBeanServerPermission ("newMBeanServer"));
346
347       JMXServiceURL url = createJMXConnectorServerAddress();
348       Map serverEnv = createServerEnvironment();
349       serverEnv.put(JMXConnectorServer.AUTHENTICATOR, new JMXAuthenticator ()
350       {
351          public Subject authenticate(Object credentials) throws SecurityException
352          {
353             if (!(credentials instanceof String [])) throw new SecurityException ("No credentials provided");
354             String [] creds = (String [])credentials;
355             if (creds.length != 2) throw new SecurityException ("Bad credentials");
356             String user = creds[0];
357             String password = creds[1];
358             if (!"test".equals(user)) throw new SecurityException ("Unknown user");
359             if (!"test".equals(password)) throw new SecurityException ("Wrong password");
360             Principal principal = new JMXPrincipal (user);
361             Set principals = new HashSet ();
362             principals.add(principal);
363             Subject subject = new Subject (true, principals, Collections.EMPTY_SET, Collections.EMPTY_SET);
364             return subject;
365          }
366       });
367
368       JMXConnectorServer cntorServer = null;
369       JMXConnector cntor = null;
370       try
371       {
372          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, serverEnv, newMBeanServer());
373
374          // Required by the server
375 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
376          cntorServer.start();
377
378          policy.setSeparateClientServerPermissions(true);
379
380          Map clientEnv = createClientEnvironment();
381          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"test", "test"});
382          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
383          policy.addServerPermission(new JMXPrincipal ("test"), new AuthPermission ("doAsPrivileged"));
384          policy.addServerPermission(new JMXPrincipal ("test"), new SocketPermission ("localhost:" + url.getPort(), "listen"));
385          policy.addServerPermission(new JMXPrincipal ("test"), new SocketPermission ("*:1024-" + url.getPort(), "accept"));
386          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
387
388          addPermission(new MBeanTrustPermission ("*"));
389          policy.addServerPermission(new JMXPrincipal ("test"), new MBeanPermission ("*", "instantiate, registerMBean, getAttribute"));
390          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
391          ObjectName name = ObjectName.getInstance(":name=subject");
392          cntion.createMBean(SubjectCheck.class.getName(), name, null);
393          policy.addServerPermission(new JMXPrincipal ("test"), new AuthPermission ("getSubject"));
394          Subject subject = (Subject )cntion.getAttribute(name, "Subject");
395
396          Set principals = subject.getPrincipals();
397          assertNotNull(principals);
398          assertEquals(principals.size(), 1);
399          Principal principal = (Principal )principals.iterator().next();
400          assertTrue(principal instanceof JMXPrincipal );
401          assertEquals(principal.getName(), "test");
402       }
403       finally
404       {
405          if (cntor != null) cntor.close();
406          if (cntorServer != null) cntorServer.stop();
407       }
408    }
409
410    public void testDelegateSubjectOnServerSide() throws Exception
411    {
412       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
413       addPermission(new MBeanServerPermission ("newMBeanServer"));
414
415       JMXServiceURL url = createJMXConnectorServerAddress();
416       Map serverEnv = createServerEnvironment();
417       serverEnv.put(JMXConnectorServer.AUTHENTICATOR, new JMXAuthenticator ()
418       {
419          public Subject authenticate(Object credentials) throws SecurityException
420          {
421             if (!(credentials instanceof String [])) throw new SecurityException ("No credentials provided");
422             String [] creds = (String [])credentials;
423             if (creds.length != 2) throw new SecurityException ("Bad credentials");
424             String user = creds[0];
425             String password = creds[1];
426             if (!"test".equals(user)) throw new SecurityException ("Unknown user");
427             if (!"test".equals(password)) throw new SecurityException ("Wrong password");
428             Principal principal = new JMXPrincipal (user);
429             Set principals = new HashSet ();
430             principals.add(principal);
431             Subject subject = new Subject (true, principals, Collections.EMPTY_SET, Collections.EMPTY_SET);
432             return subject;
433          }
434       });
435
436       JMXConnectorServer cntorServer = null;
437       JMXConnector cntor = null;
438       try
439       {
440          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, serverEnv, newMBeanServer());
441          // Required by the server
442 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
443          cntorServer.start();
444
445          policy.setSeparateClientServerPermissions(true);
446
447          Map clientEnv = createClientEnvironment();
448          clientEnv.put(JMXConnector.CREDENTIALS, new String []{"test", "test"});
449          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
450          policy.addServerPermission(new JMXPrincipal ("test"), new AuthPermission ("doAsPrivileged"));
451          policy.addServerPermission(new JMXPrincipal ("test"), new SocketPermission ("localhost:" + url.getPort(), "listen"));
452          policy.addServerPermission(new JMXPrincipal ("test"), new SocketPermission ("*:1024-" + url.getPort(), "accept"));
453          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), clientEnv);
454
455          addPermission(new MBeanTrustPermission ("*"));
456          policy.addServerPermission(new JMXPrincipal ("delegate"), new MBeanPermission ("*", "instantiate, registerMBean, getAttribute"));
457          policy.addServerPermission(new JMXPrincipal ("test"), new SubjectDelegationPermission (JMXPrincipal .class.getName() + ".delegate"));
458
459          Set delegates = new HashSet ();
460          delegates.add(new JMXPrincipal ("delegate"));
461          Subject delegate = new Subject (true, delegates, Collections.EMPTY_SET, Collections.EMPTY_SET);
462          MBeanServerConnection cntion = cntor.getMBeanServerConnection(delegate);
463          ObjectName name = ObjectName.getInstance(":name=subject");
464          cntion.createMBean(SubjectCheck.class.getName(), name, null);
465          policy.addServerPermission(new JMXPrincipal ("delegate"), new AuthPermission ("getSubject"));
466          Subject subject = (Subject )cntion.getAttribute(name, "Subject");
467
468          Set principals = subject.getPrincipals();
469          assertNotNull(principals);
470          assertEquals(principals.size(), 1);
471          Principal principal = (Principal )principals.iterator().next();
472          assertTrue(principal instanceof JMXPrincipal );
473          assertEquals(principal.getName(), "delegate");
474       }
475       finally
476       {
477          if (cntor != null) cntor.close();
478          if (cntorServer != null) cntorServer.stop();
479       }
480    }
481
482    public void testAddRemoveNotificationListener() throws Exception
483    {
484       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
485       addPermission(new MBeanServerPermission ("newMBeanServer"));
486
487       JMXServiceURL url = createJMXConnectorServerAddress();
488       JMXConnectorServer cntorServer = null;
489       JMXConnector cntor = null;
490       try
491       {
492          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
493          // Required by the server
494 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
495          cntorServer.start();
496
497          policy.setSeparateClientServerPermissions(true);
498
499          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
500          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
501          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
502          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
503
504          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
505
506          testAddRemoveNotificationListener(cntion);
507       }
508       finally
509       {
510          if (cntor != null) cntor.close();
511          if (cntorServer != null) cntorServer.stop();
512       }
513    }
514
515    public void testCreateMBean4Params() throws Exception
516    {
517       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
518       addPermission(new MBeanServerPermission ("newMBeanServer"));
519
520       JMXServiceURL url = createJMXConnectorServerAddress();
521       JMXConnectorServer cntorServer = null;
522       JMXConnector cntor = null;
523       try
524       {
525          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
526          // Required by the server
527 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
528          cntorServer.start();
529
530          policy.setSeparateClientServerPermissions(true);
531
532          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
533          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
534          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
535          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
536
537          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
538
539          testCreateMBean4Params(cntion);
540       }
541       finally
542       {
543          if (cntor != null) cntor.close();
544          if (cntorServer != null) cntorServer.stop();
545       }
546    }
547
548    public void testCreateMBean5Params() throws Exception
549    {
550       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
551       addPermission(new MBeanServerPermission ("newMBeanServer"));
552
553       JMXServiceURL url = createJMXConnectorServerAddress();
554       JMXConnectorServer cntorServer = null;
555       JMXConnector cntor = null;
556       try
557       {
558          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
559          // Required by the server
560 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
561          cntorServer.start();
562
563          policy.setSeparateClientServerPermissions(true);
564
565          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
566          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
567          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
568          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
569
570          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
571
572          testCreateMBean5Params(cntion);
573       }
574       finally
575       {
576          if (cntor != null) cntor.close();
577          if (cntorServer != null) cntorServer.stop();
578       }
579    }
580
581    public void testGetAttribute() throws Exception
582    {
583       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
584       addPermission(new MBeanServerPermission ("newMBeanServer"));
585
586       JMXServiceURL url = createJMXConnectorServerAddress();
587       JMXConnectorServer cntorServer = null;
588       JMXConnector cntor = null;
589       try
590       {
591          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
592          // Required by the server
593 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
594          cntorServer.start();
595
596          policy.setSeparateClientServerPermissions(true);
597
598          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
599          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
600          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
601          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
602
603          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
604
605          testGetAttribute(cntion);
606       }
607       finally
608       {
609          if (cntor != null) cntor.close();
610          if (cntorServer != null) cntorServer.stop();
611       }
612    }
613
614    public void testGetAttributes() throws Exception
615    {
616       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
617       addPermission(new MBeanServerPermission ("newMBeanServer"));
618
619       JMXServiceURL url = createJMXConnectorServerAddress();
620       JMXConnectorServer cntorServer = null;
621       JMXConnector cntor = null;
622       try
623       {
624          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
625          // Required by the server
626 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
627          cntorServer.start();
628
629          policy.setSeparateClientServerPermissions(true);
630
631          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
632          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
633          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
634          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
635
636          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
637
638          testGetAttributes(cntion);
639       }
640       finally
641       {
642          if (cntor != null) cntor.close();
643          if (cntorServer != null) cntorServer.stop();
644       }
645    }
646
647    public void testGetDefaultDomain() throws Exception
648    {
649       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
650       addPermission(new MBeanServerPermission ("newMBeanServer"));
651
652       JMXServiceURL url = createJMXConnectorServerAddress();
653       JMXConnectorServer cntorServer = null;
654       JMXConnector cntor = null;
655       try
656       {
657          String domain = "xxx";
658          MBeanServer server = MBeanServerFactory.newMBeanServer(domain);
659          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), server);
660          // Required by the server
661 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
662          cntorServer.start();
663
664          policy.setSeparateClientServerPermissions(true);
665
666          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
667          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
668          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
669          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
670
671          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
672
673          testGetDefaultDomain(cntion, domain);
674       }
675       finally
676       {
677          if (cntor != null) cntor.close();
678          if (cntorServer != null) cntorServer.stop();
679       }
680    }
681
682    public void testGetDomains() throws Exception
683    {
684       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
685       addPermission(new MBeanServerPermission ("newMBeanServer"));
686
687       JMXServiceURL url = createJMXConnectorServerAddress();
688       JMXConnectorServer cntorServer = null;
689       JMXConnector cntor = null;
690       try
691       {
692          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
693          // Required by the server
694 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
695          cntorServer.start();
696
697          policy.setSeparateClientServerPermissions(true);
698
699          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
700          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
701          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
702          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
703
704          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
705
706          testGetDomains(cntion);
707       }
708       finally
709       {
710          if (cntor != null) cntor.close();
711          if (cntorServer != null) cntorServer.stop();
712       }
713    }
714
715    public void testGetMBeanCount() throws Exception
716    {
717       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
718       addPermission(new MBeanServerPermission ("newMBeanServer"));
719
720       JMXServiceURL url = createJMXConnectorServerAddress();
721       JMXConnectorServer cntorServer = null;
722       JMXConnector cntor = null;
723       try
724       {
725          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
726          // Required by the server
727 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
728          cntorServer.start();
729
730          policy.setSeparateClientServerPermissions(true);
731
732          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
733          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
734          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
735          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
736
737          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
738
739          testGetMBeanCount(cntion);
740       }
741       finally
742       {
743          if (cntor != null) cntor.close();
744          if (cntorServer != null) cntorServer.stop();
745       }
746    }
747
748    public void testGetMBeanInfo() throws Exception
749    {
750       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
751       addPermission(new MBeanServerPermission ("newMBeanServer"));
752
753       JMXServiceURL url = createJMXConnectorServerAddress();
754       JMXConnectorServer cntorServer = null;
755       JMXConnector cntor = null;
756       try
757       {
758          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
759          // Required by the server
760 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
761          cntorServer.start();
762
763          policy.setSeparateClientServerPermissions(true);
764
765          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
766          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
767          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
768          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
769
770          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
771
772          testGetMBeanInfo(cntion);
773       }
774       finally
775       {
776          if (cntor != null) cntor.close();
777          if (cntorServer != null) cntorServer.stop();
778       }
779    }
780
781    public void testGetObjectInstance() throws Exception
782    {
783       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
784       addPermission(new MBeanServerPermission ("newMBeanServer"));
785
786       JMXServiceURL url = createJMXConnectorServerAddress();
787       JMXConnectorServer cntorServer = null;
788       JMXConnector cntor = null;
789       try
790       {
791          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
792          // Required by the server
793 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
794          cntorServer.start();
795
796          policy.setSeparateClientServerPermissions(true);
797
798          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
799          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
800          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
801          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
802
803          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
804
805          testGetObjectInstance(cntion);
806       }
807       finally
808       {
809          if (cntor != null) cntor.close();
810          if (cntorServer != null) cntorServer.stop();
811       }
812    }
813
814    public void testInvoke() throws Exception
815    {
816       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
817       addPermission(new MBeanServerPermission ("newMBeanServer"));
818
819       JMXServiceURL url = createJMXConnectorServerAddress();
820       JMXConnectorServer cntorServer = null;
821       JMXConnector cntor = null;
822       try
823       {
824          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
825          // Required by the server
826 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
827          cntorServer.start();
828
829          policy.setSeparateClientServerPermissions(true);
830
831          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
832          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
833          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
834          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
835
836          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
837
838          testInvoke(cntion);
839       }
840       finally
841       {
842          if (cntor != null) cntor.close();
843          if (cntorServer != null) cntorServer.stop();
844       }
845    }
846
847    public void testIsInstanceOf() throws Exception
848    {
849       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
850       addPermission(new MBeanServerPermission ("newMBeanServer"));
851
852       JMXServiceURL url = createJMXConnectorServerAddress();
853       JMXConnectorServer cntorServer = null;
854       JMXConnector cntor = null;
855       try
856       {
857          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
858          // Required by the server
859 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
860          cntorServer.start();
861
862          policy.setSeparateClientServerPermissions(true);
863
864          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
865          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
866          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
867          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
868
869          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
870
871          testIsInstanceOf(cntion);
872       }
873       finally
874       {
875          if (cntor != null) cntor.close();
876          if (cntorServer != null) cntorServer.stop();
877       }
878    }
879
880    public void testIsRegistered() throws Exception
881    {
882       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
883       addPermission(new MBeanServerPermission ("newMBeanServer"));
884
885       JMXServiceURL url = createJMXConnectorServerAddress();
886       JMXConnectorServer cntorServer = null;
887       JMXConnector cntor = null;
888       try
889       {
890          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
891          // Required by the server
892 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
893          cntorServer.start();
894
895          policy.setSeparateClientServerPermissions(true);
896
897          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
898          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
899          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
900          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
901
902          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
903
904          testIsRegistered(cntion);
905       }
906       finally
907       {
908          if (cntor != null) cntor.close();
909          if (cntorServer != null) cntorServer.stop();
910       }
911    }
912
913    public void testQueryMBeans() throws Exception
914    {
915       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
916       addPermission(new MBeanServerPermission ("newMBeanServer"));
917
918       JMXServiceURL url = createJMXConnectorServerAddress();
919       JMXConnectorServer cntorServer = null;
920       JMXConnector cntor = null;
921       try
922       {
923          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
924          // Required by the server
925 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
926          cntorServer.start();
927
928          policy.setSeparateClientServerPermissions(true);
929
930          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
931          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
932          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
933          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
934
935          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
936
937          testQueryMBeans(cntion);
938       }
939       finally
940       {
941          if (cntor != null) cntor.close();
942          if (cntorServer != null) cntorServer.stop();
943       }
944    }
945
946    public void testQueryNames() throws Exception
947    {
948       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
949       addPermission(new MBeanServerPermission ("newMBeanServer"));
950
951       JMXServiceURL url = createJMXConnectorServerAddress();
952       JMXConnectorServer cntorServer = null;
953       JMXConnector cntor = null;
954       try
955       {
956          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
957          // Required by the server
958 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
959          cntorServer.start();
960
961          policy.setSeparateClientServerPermissions(true);
962
963          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
964          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
965          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
966          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
967
968          MBeanServerConnection cntion = cntor.getMBeanServerConnection();
969
970          testQueryNames(cntion);
971       }
972       finally
973       {
974          if (cntor != null) cntor.close();
975          if (cntorServer != null) cntorServer.stop();
976       }
977    }
978
979    public void testSetAttribute() throws Exception
980    {
981       RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
982       addPermission(new MBeanServerPermission ("newMBeanServer"));
983
984       JMXServiceURL url = createJMXConnectorServerAddress();
985       JMXConnectorServer cntorServer = null;
986       JMXConnector cntor = null;
987       try
988       {
989          cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
990          // Required by the server
991 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
992          cntorServer.start();
993
994          policy.setSeparateClientServerPermissions(true);
995
996          policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
997          addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
998          addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
999          cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
1000
1001         MBeanServerConnection cntion = cntor.getMBeanServerConnection();
1002
1003         testSetAttribute(cntion);
1004      }
1005      finally
1006      {
1007         if (cntor != null) cntor.close();
1008         if (cntorServer != null) cntorServer.stop();
1009      }
1010   }
1011
1012   public void testSetAttributes() throws Exception
1013   {
1014      RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
1015      addPermission(new MBeanServerPermission ("newMBeanServer"));
1016
1017      JMXServiceURL url = createJMXConnectorServerAddress();
1018      JMXConnectorServer cntorServer = null;
1019      JMXConnector cntor = null;
1020      try
1021      {
1022         cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
1023         // Required by the server
1024 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
1025         cntorServer.start();
1026
1027         policy.setSeparateClientServerPermissions(true);
1028
1029         policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
1030         addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
1031         addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
1032         cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
1033
1034         MBeanServerConnection cntion = cntor.getMBeanServerConnection();
1035
1036         testSetAttributes(cntion);
1037      }
1038      finally
1039      {
1040         if (cntor != null) cntor.close();
1041         if (cntorServer != null) cntorServer.stop();
1042      }
1043   }
1044
1045   public void testUnregisterMBean() throws Exception
1046   {
1047      RemoteModifiablePolicy policy = (RemoteModifiablePolicy)Policy.getPolicy();
1048      addPermission(new MBeanServerPermission ("newMBeanServer"));
1049
1050      JMXServiceURL url = createJMXConnectorServerAddress();
1051      JMXConnectorServer cntorServer = null;
1052      JMXConnector cntor = null;
1053      try
1054      {
1055         cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, createServerEnvironment(), newMBeanServer());
1056         // Required by the server
1057 addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
1058         cntorServer.start();
1059
1060         policy.setSeparateClientServerPermissions(true);
1061
1062         policy.addClientPermission(new SocketPermission ("localhost:" + url.getPort(), "connect"));
1063         addPermission(new SocketPermission ("localhost:" + url.getPort(), "listen"));
1064         addPermission(new SocketPermission ("*:1024-" + url.getPort(), "accept"));
1065         cntor = JMXConnectorFactory.connect(cntorServer.getAddress(), createClientEnvironment());
1066
1067         MBeanServerConnection cntion = cntor.getMBeanServerConnection();
1068
1069         testUnregisterMBean(cntion);
1070      }
1071      finally
1072      {
1073         if (cntor != null) cntor.close();
1074         if (cntorServer != null) cntorServer.stop();
1075      }
1076   }
1077
1078   public interface SubjectCheckMBean
1079   {
1080      public Subject getSubject();
1081   }
1082
1083   public static class SubjectCheck implements SubjectCheckMBean
1084   {
1085      public Subject getSubject()
1086      {
1087         return Subject.getSubject(AccessController.getContext());
1088      }
1089   }
1090
1091   /**
1092    * A modifiable policy that allow permissions to be added at runtime, used for tests purposes only.
1093    */
1094   public abstract static class RemoteModifiablePolicy extends Policy
1095   {
1096      private final ProtectionDomain testDomain;
1097      private final Map serverPermissions = new HashMap ();
1098      private final Map clientPermissions = new HashMap ();
1099      private final Map principalPermissions = new HashMap ();
1100      private volatile boolean separated;
1101
1102      public RemoteModifiablePolicy()
1103      {
1104         // Here we still have no security manager installed
1105 testDomain = RemoteModifiablePolicy.class.getProtectionDomain();
1106
1107         // Add the permissions needed to run the tests
1108 CodeSource junitCodeSource = TestCase.class.getProtectionDomain().getCodeSource();
1109         serverPermissions.put(junitCodeSource, createAllPermissions());
1110         clientPermissions.put(junitCodeSource, createAllPermissions());
1111
1112         CodeSource mx4jCodeSource = MBeanServerFactory .class.getProtectionDomain().getCodeSource();
1113         serverPermissions.put(mx4jCodeSource, createAllPermissions());
1114         clientPermissions.put(mx4jCodeSource, createAllPermissions());
1115
1116         CodeSource implCodeSource = MX4JMBeanServer.class.getProtectionDomain().getCodeSource();
1117         serverPermissions.put(implCodeSource, createAllPermissions());
1118         clientPermissions.put(implCodeSource, createAllPermissions());
1119
1120         CodeSource rmx4jCodeSource = JMXConnector .class.getProtectionDomain().getCodeSource();
1121         serverPermissions.put(rmx4jCodeSource, createAllPermissions());
1122         clientPermissions.put(rmx4jCodeSource, createAllPermissions());
1123
1124         CodeSource rimplCodeSource = MX4JRemoteUtils.class.getProtectionDomain().getCodeSource();
1125         serverPermissions.put(rimplCodeSource, createAllPermissions());
1126         clientPermissions.put(rimplCodeSource, createAllPermissions());
1127
1128         ClassLoader loader = getClass().getClassLoader();
1129
1130         // BCEL
1131 try
1132         {
1133            Class cls = loader.loadClass("org.apache.bcel.generic.Type");
1134            CodeSource bcelCodeSource = cls.getProtectionDomain().getCodeSource();
1135            serverPermissions.put(bcelCodeSource, createAllPermissions());
1136            clientPermissions.put(bcelCodeSource, createAllPermissions());
1137         }
1138         catch (ClassNotFoundException ignored)
1139         {
1140         }
1141
1142
1143         // When we run automated, we need also permissions for Ant jars
1144 try
1145         {
1146            Class cls = loader.loadClass("org.apache.tools.ant.Task");
1147            CodeSource antCodeSource = cls.getProtectionDomain().getCodeSource();
1148            serverPermissions.put(antCodeSource, createAllPermissions());
1149            clientPermissions.put(antCodeSource, createAllPermissions());
1150            cls = loader.loadClass("org.apache.tools.ant.taskdefs.optional.junit.JUnitTask");
1151            antCodeSource = cls.getProtectionDomain().getCodeSource();
1152            serverPermissions.put(antCodeSource, createAllPermissions());
1153            clientPermissions.put(antCodeSource, createAllPermissions());
1154         }
1155         catch (ClassNotFoundException ignored)
1156         {
1157         }
1158
1159         mapServerPermissions(serverPermissions);
1160
1161         initialize();
1162      }
1163
1164      /**
1165       * Callback for subclasses to add more mappings between a codesource and
1166       * (normally) a Permissions object containing AllPermission.
1167       * This is necessary if the implementation of the JMXConnectorServer needs additional
1168       * jars such as for example commons-logging.jar, whose codesource is normally mapped
1169       * with AllPermission.
1170       *
1171       * @see #createAllPermissions
1172       */
1173      protected void mapServerPermissions(Map permissions)
1174      {
1175         // Nothing necessary here
1176 }
1177
1178      /**
1179       * Creates and returns a Permissions object containing AllPermission.
1180       *
1181       * @see #mapServerPermissions
1182       */
1183      protected Permissions createAllPermissions()
1184      {
1185         Permissions allPermissions = new Permissions ();
1186         allPermissions.add(new AllPermission ());
1187         return allPermissions;
1188      }
1189
1190      /**
1191       * Returns whether the current thread is a server side thread or
1192       * a client side thread.
1193       * Subclasses implement this method by for example looking at the thread name.
1194       *
1195       * @see #setSeparateClientServerPermissions
1196       * @see #isSeparateClientServerPermissions
1197       */
1198      public abstract boolean isServerSide();
1199
1200      public PermissionCollection getPermissions(CodeSource codesource)
1201      {
1202         return getPermissions(codesource, isServerSide());
1203      }
1204
1205      private synchronized PermissionCollection getPermissions(CodeSource codesource, boolean serverside)
1206      {
1207         if (serverside)
1208         {
1209            PermissionCollection perms = (PermissionCollection )serverPermissions.get(codesource);
1210            if (perms == null) perms = new Permissions ();
1211            perms = copyIfReadOnly(perms);
1212            serverPermissions.put(codesource, perms);
1213            return perms;
1214         }
1215         else
1216         {
1217            PermissionCollection perms = (PermissionCollection )clientPermissions.get(codesource);
1218            if (perms == null) perms = new Permissions ();
1219            perms = copyIfReadOnly(perms);
1220            clientPermissions.put(codesource, perms);
1221            return perms;
1222         }
1223      }
1224
1225      /**
1226       * For JDK 1.4 overriding this method disables caching of Permissions done by the
1227       * standard Policy implementation.
1228       * This is done because we install this policy *before* installing the security manager.
1229       * By doing so, in JDK 1.4 the permissions granted at the moment of policy installation
1230       * (no security manager == AllPermission) are cached and will invalidate all tests, since
1231       * they will become unmodifiable.
1232       * <p/>
1233       * The stack trace is when checking a permission is:
1234       * <p/>
1235       * SecurityManager.checkPermission()
1236       * AccessController.checkPermission()
1237       * AccessControlContext.checkPermission()
1238       * ProtectionDomain.implies()
1239       * RemoteModifiablePolicy.implies()
1240       */
1241      public boolean implies(ProtectionDomain domain, Permission permission)
1242      {
1243         Principal [] principals = domain.getPrincipals();
1244         boolean injectedDomain = false;
1245         CodeSource cs = domain.getCodeSource();
1246         if (principals != null && principals.length > 0 && cs != null && cs.getLocation() == null && domain.getClassLoader() == null) injectedDomain = true;
1247
1248         if (!injectedDomain)
1249         {
1250            PermissionCollection perms = getPermissions(cs);
1251            boolean result = perms.implies(permission);
1252// System.out.println("Policy.implies, side is " + (isServerSide() ? "server" : "client") + " codesource " + cs + " on " + permission + " over " + perms + ": " + result);
1253 return result;
1254         }
1255         else
1256         {
1257            for (int i = 0; i < principals.length; ++i)
1258            {
1259               Principal principal = principals[i];
1260               PermissionCollection perms = getPrincipalPermissions(principal);
1261               if (perms.implies(permission)) return true;
1262            }
1263            return false;
1264         }
1265      }
1266
1267      private synchronized PermissionCollection getPrincipalPermissions(Principal principal)
1268      {
1269         PermissionCollection perms = (PermissionCollection )principalPermissions.get(principal);
1270         if (perms == null) perms = new Permissions ();
1271         perms = copyIfReadOnly(perms);
1272         principalPermissions.put(principal, perms);
1273         return perms;
1274      }
1275
1276      public void refresh()
1277      {
1278      }
1279
1280      /**
1281       * Adds the given permission to the client (the test in this case) codesource,
1282       * on server side
1283       */
1284      public void addServerPermission(Permission p)
1285      {
1286         Permissions permissions = (Permissions )getPermissions(testDomain.getCodeSource(), true);
1287         permissions.add(p);
1288      }
1289
1290      /**
1291       * Adds the given permission to the client (the test in this case) codesource,
1292       * on client side
1293       */
1294      public void addClientPermission(Permission p)
1295      {
1296         Permissions permissions = (Permissions )getPermissions(testDomain.getCodeSource(), false);
1297         permissions.add(p);
1298      }
1299
1300      /**
1301       * Adds the given permission to the JSR 160 injected codesource,
1302       * on server side, for the given principal
1303       */
1304      public void addServerPermission(Principal principal, Permission p)
1305      {
1306         Permissions permissions = (Permissions )getPrincipalPermissions(principal);
1307         permissions.add(p);
1308         addServerPermission(p);
1309      }
1310
1311      /**
1312       * Initializes the permissions for the client (the test in this case) codesource,
1313       * and marks this policy as working on server side.
1314       *
1315       * @see #setSeparateClientServerPermissions
1316       */
1317      public synchronized void initialize()
1318      {
1319         Permissions permissions = new Permissions ();
1320         permissions.add(new SecurityPermission ("getPolicy"));
1321         serverPermissions.put(testDomain.getCodeSource(), permissions);
1322         permissions = new Permissions ();
1323         permissions.add(new SecurityPermission ("getPolicy"));
1324         clientPermissions.put(testDomain.getCodeSource(), permissions);
1325         principalPermissions.clear();
1326         setSeparateClientServerPermissions(false);
1327      }
1328
1329      /**
1330       * Tells this policy to distinguish the check of permissions basing on the fact
1331       * that the thread is a server side thread or a client side thread.
1332       *
1333       * @see #isServerSide
1334       * @see #isSeparateClientServerPermissions
1335       */
1336      public synchronized void setSeparateClientServerPermissions(boolean value)
1337      {
1338         separated = value;
1339      }
1340
1341      /**
1342       * Returns if this policy distinguishes between server side and client side
1343       * permission checking.
1344       *
1345       * @see #setSeparateClientServerPermissions
1346       */
1347      protected synchronized boolean isSeparateClientServerPermissions()
1348      {
1349         return separated;
1350      }
1351
1352      /**
1353       * The RMI marshalling mechanism (and this is only one place I have discovered so far)
1354       * sometimes marks the PermissionCollection as read-only via
1355       * {@link PermissionCollection#setReadOnly}. Since this policy
1356       * adds permissions at runtime, having the Permissions object marked as read-only
1357       * causes an exception that invalidates the test.
1358       * Here I copy the read-only Permissions into a new Permissions object (by copying
1359       * all permissions it contains into the copied object), and return it.
1360       * If the Permissions object is not read-only, it is returned immediately.
1361       */
1362      private PermissionCollection copyIfReadOnly(PermissionCollection p)
1363      {
1364         if (!p.isReadOnly()) return p;
1365         Permissions permissions = new Permissions ();
1366         for (Enumeration e = p.elements(); e.hasMoreElements();)
1367         {
1368            Permission permission = (Permission )e.nextElement();
1369            permissions.add(permission);
1370         }
1371         return permissions;
1372      }
1373   }
1374}
1375

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags