appserver/tests/appserv-tests/devtests/security/jaccApi/src/TestEJBPerms.java

/*
 * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package jakarta.security.jacc;

import java.lang.reflect.*;
import java.util.Enumeration;
import java.security.*; 
import jakarta.security.jacc.EJBMethodPermission;
import jakarta.security.jacc.EJBRoleRefPermission;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.FileOutputStream;

import com.sun.ejte.ccl.reporter.SimpleReporterAdapter;

public class TestEJBPerms {
    private static SimpleReporterAdapter stat =
            new SimpleReporterAdapter("appserv-tests");
    private static String testSuite = "Sec::JACC API testEJBPerms ";
    private static boolean isDebug = Boolean.getBoolean("debug");

    private static void debug(String msg) {
        if (isDebug) {
            System.out.println(msg);
        }
    }

    private static void testSerialization(Permission p1) {
        String description = "TestSerialization:" + p1.getName() +
            "," + p1.getActions();

        boolean result = true;

        Permission p2 = p1;
        try {
            FileOutputStream fout = new 
                FileOutputStream("serial-test-file.tmp");
            ObjectOutputStream sout = new ObjectOutputStream(fout);
            sout.writeObject(p1);
            sout.flush();
            sout.close();
            fout.close();
        } catch( Throwable t ) { 
            t.printStackTrace();
            debug( "-- Serialization Test Failed(write)-" + p1.getName() + "," + p1.getActions());
        }

        try {
            FileInputStream fin = new FileInputStream("serial-test-file.tmp");
            ObjectInputStream sin = new ObjectInputStream(fin);
            p2 = (Permission) sin.readObject();
            sin.close();
            fin.close(); 
        } catch( Throwable t ) { 
            t.printStackTrace();
            debug( "-- Serialization Test Failed(read)-" + p1.getName() + "," + p1.getActions());
            result = false;
        }

        if (result == true) {
            if (p2.equals(p1)) { 
                debug( "-- Serialization Test Succeeded -----------" + p2.getName() + "," + p2.getActions());
                stat.addStatus(description, stat.PASS);
            } else { 
                debug( "-- Serialization Test Failed-" + p1.getName() + "," + p1.getActions());
                stat.addStatus(description, stat.FAIL);
            }
        } else {
            debug( "-- Serialization Test Failed-" + p1.getName() + "," + p1.getActions());
            stat.addStatus(description, stat.FAIL);
        }
    }

    private static void doEJBMethodPermission( boolean expectedToSucceed,
                                               String name, String actions) {
        String description = "doEJBMethodPermission:" +
            expectedToSucceed + "-" + name + "-" + actions;

        boolean result = true;

        EJBMethodPermission p1,p2;

        try {
            debug( "-- Construct Test --" + expectedToSucceed +
                " " + name + " " + actions);

            p1 = new EJBMethodPermission(name,actions);

            if (expectedToSucceed) {

                p2 = new EJBMethodPermission(p1.getName(),p1.getActions()); 
                testSerialization(p2);

                if (!p1.equals(p2)) {
                    result = false;
                    debug("p != p\n\t" + p1 + "\n\t" + p2);
                }

                if (!p1.implies(p2)) {
                    result = false;
                    debug("!p.implies(p)\n\t" + p1 + "\n\t" + p2);
                }

            } else {
                debug("unexpected success\t" + p1);
                result = false;
            }

        } catch( Throwable t ) { 

            if (expectedToSucceed) {
                t.printStackTrace();
            }

            result = false;
        }

        if (result == expectedToSucceed) {
            if (expectedToSucceed) {
                debug( "-- Construct Test Succeeded -------------------------------------");
            } else {
                debug( "-- Construct Test Succeeded (negative)---------------------------");
            }
            stat.addStatus(description, stat.PASS);
        } else {
            debug( "-- Construct Test Failed ----------------------------------------");
            stat.addStatus(description, stat.FAIL);
        }
    }

    private static void doEJBMethodPermission( boolean expectedToSucceed,
           String ejbName, String methodName, String methodInterface, 
           String[] methodParams) {
        String description = "doEJBMethodPermissionWithParams:" +
            expectedToSucceed + "-" + ejbName + "-" + methodName +
            "-" + methodInterface + "-" + methodParams;

        boolean result = true;

        EJBMethodPermission p1,p2;

        try {
            debug( "-- Construct Test --");

            p1 = new EJBMethodPermission(ejbName,methodName,methodInterface,
                                         methodParams);

            if (expectedToSucceed) {
                p2 = new EJBMethodPermission(p1.getName(),p1.getActions()); 
                testSerialization(p2);

                if (!p1.equals(p2)) {
                    result = false;
                    debug("p != p\n\t" + p1 + "\n\t" + p2);
                }

                if (!p1.implies(p2)) {
                    result = false;
                    debug("!p.implies(p)\n\t" + p1 + "\n\t" + p2);
                }

            } else {
                debug("unexpected success\t" + p1);
                result = false;
            }

        } catch( Throwable t ) { 

            if (expectedToSucceed) {
                t.printStackTrace();
            }
            
            result = false;
        } 
        if (result == expectedToSucceed) {
            if (expectedToSucceed) { 
                debug( "-- Construct Test Succeeded -------------------------------------");
            } else {
                debug( "-- Construct Test Succeeded (negative)---------------------------");
            }
            stat.addStatus(description, stat.PASS);
        } else {
            debug( "-- Construct Test Failed ----------------------------------------");
            stat.addStatus(description, stat.FAIL);
        }
    }

    private static void doEJBMethodPermission( boolean expectedToSucceed,
             String ejbName, String methodInterface, Method method) {

        String description = "doEJBMethodPermissionWithMethod:" +
            expectedToSucceed + "-" + ejbName + 
            "-" + methodInterface + "-" + method;

        boolean result = true;

        EJBMethodPermission p1,p2;
        String actions = null;

        try {
            debug( "-- Construct Test -----------------------------------------------");

            p1 = new EJBMethodPermission(ejbName,methodInterface,method);

            if (expectedToSucceed) {

                p2 = new EJBMethodPermission(p1.getName(),p1.getActions());
                actions = p1.getActions();
                testSerialization(p2);

                if (!p1.equals(p2)) {
                    result = false;
                    debug("p != p\n\t" + p1 + "\n\t" + p2);

                }

                if (!p1.implies(p2)) {
                    result = false;
                    debug("!p.implies(p)\n\t" + p1 + "\n\t" + p2);
                }

            } else {
                debug("unexpected success\t" + p1);
                result = false;
            }

        } catch( Throwable t ) { 

            if (expectedToSucceed) {
                t.printStackTrace();
            }

            result = false;
        }

        if (result == expectedToSucceed) {
            if (expectedToSucceed) { 
                debug( "-- Construct Test Succeeded -------------------------------------");
            } else {
                debug( "-- Construct Test Succeeded (negative)---------------------------");
            }
            stat.addStatus(description, stat.PASS);
        } else {
            debug( "-- Construct Test Failed ----------------------------------------");
            stat.addStatus(description, stat.FAIL);
        }
    }

    private static void doEJBRoleRefPermission( boolean expectedToSucceed,
            String servletName, String roleRef) {
        String description = "doEJBRoleRefPermission:" +
            expectedToSucceed + "-" + servletName + "-" + roleRef;

        boolean result = true;

        EJBRoleRefPermission p1,p2;

        p1 = null;

        try {
            debug( "-- Construct Test -----------------------------------------------");

            p1 = new EJBRoleRefPermission(servletName,roleRef);

            if (expectedToSucceed) {

                p2 = new EJBRoleRefPermission(p1.getName(),p1.getActions()); 
                testSerialization(p2);

                if (!p1.equals(p2)) {
                    result = false;
                    debug("p != p\n\t" + p1 + "\n\t" + p2);

                }

                if (!p1.implies(p2)) {
                    result = false;
                    debug("!p.implies(p)\n\t" + p1 + "\n\t" + p2);
                }

            } else {
                debug("unexpected success\t" + p1);
                result = false;
            }

        } catch( Throwable t ) { 

            if (expectedToSucceed) {
                t.printStackTrace();
            }

            result = false;
        }

        if (result == expectedToSucceed) {
            if (expectedToSucceed) { 
                debug( "-- Construct Test Succeeded -------------------------------------" + p1.hashCode());
            } else {
                debug( "-- Construct Test Succeeded (negative)---------------------------");
            }
            stat.addStatus(description, stat.PASS);
        } else {
            debug( "-- Construct Test Failed ----------------------------------------");
            stat.addStatus(description, stat.FAIL);
        }
    }

    private static void doPermissionImplies ( boolean expectedResult,
            Permission thisP, Permission p) {
        //SEC is added there so that it will not cut off the 
        //first part with space, an issue in reporting tools
        String description = "SEC doPermissionImplies:" +
            expectedResult + "-" + thisP + "-" + p;

        try {

            debug( "-- Permission implies Test ----------------------------------------------");

            if (thisP.implies(p) != expectedResult) {
                debug(
                    (expectedResult ? "unexpected failure:" :"unexpected success:")
                     + p + (expectedResult ?" not implied by:":" implied by:") + 
                    thisP);
                debug( "-- Permission implies Test Failed ----------------------------------------");
                stat.addStatus(description, stat.FAIL);
            } else {
                debug(p + 
                   (expectedResult ? " implied by:":" not implied by:") + thisP);
                debug( "-- Permission implies Test Succeeded -------------------------------------");
                stat.addStatus(description, stat.PASS);
            }
        } catch( Throwable t ) { 
            debug("unexpected exception");
            t.printStackTrace();
            debug( "-- Permission implies Test Failed ----------------------------------------");
            stat.addStatus(description, stat.FAIL);
        }
    }

    public static void main ( String[] args ) {
        stat.addDescription(testSuite);
        String params1[] = { "java.lang.string" };
        String params2[] = { "java.lang.string", "java.lang.int" };
        String params3[] = { "java.lang.string", "java.lang.int," };

        for (int i=0; i<100; i++) {
            doEJBMethodPermission(false,"bankbean","withdraw,");
            doEJBMethodPermission(false,"bankbean","withdraw,Home,java.lang.string,");
            doEJBMethodPermission(true,"bankbean",null);
            doEJBMethodPermission(true,"bankbean","withdraw");
            doEJBMethodPermission(true,"bankbean","withdraw,Home");
            doEJBMethodPermission(true,"bankbean","withdraw,Home,java.lang.string");
            doEJBMethodPermission(true,"bankbean",",Home");
    
            doEJBMethodPermission(true,"bankbean",",Home,java.lang.string");
    
            doEJBMethodPermission(true,"bankbean","withdraw");
            doEJBMethodPermission(true,"bankbean","withdraw,Home");
            doEJBMethodPermission(true,"bankbean","withdraw,,java.lang.string");
            doEJBMethodPermission(true,"bankbean","withdraw,,");
            doEJBMethodPermission(false,"bankBean","withdraw","Home",params3);
    
            doEJBMethodPermission(true,"bankBean","withdraw","Home",params1);
            doEJBMethodPermission(true,"bankBean","withdraw","Home",params2);
     
            doEJBMethodPermission(true,"bankBean","withdraw","Home",null);
    
            doEJBMethodPermission(true,"bankBean",null,"Home",params1);
        
            doEJBMethodPermission(true,"bankBean","withdraw",null,params2);
    
            doEJBMethodPermission(true,"bankBean",null,null,null);
            
            EJBMethodPermission a = 
                new EJBMethodPermission("bankBean","withdraw,Home,java.lang.string");
            EJBMethodPermission b = 
                new EJBMethodPermission("myBean","withdraw,Home,java.lang.string");
            EJBMethodPermission c = 
                new EJBMethodPermission("myBean",",Home,java.lang.string");
            EJBMethodPermission d = 
                new EJBMethodPermission("myBean",",,java.lang.string");
            EJBMethodPermission e = 
                new EJBMethodPermission("myBean","withdraw,,java.lang.string");
            EJBMethodPermission f = 
                new EJBMethodPermission("myBean","withdraw,,java.lang.int");
            EJBMethodPermission g = 
                new EJBMethodPermission("myBean","withdraw,Remote,");
            EJBMethodPermission h = 
                new EJBMethodPermission("myBean","withdraw","Remote",new String[0]);
            testSerialization(a);
            testSerialization(b);
            testSerialization(c);
            testSerialization(d);
            testSerialization(e);
            testSerialization(f);
            testSerialization(g);
            testSerialization(h);
    
            doPermissionImplies(false,a,b);
            doPermissionImplies(false,b,a);
            doPermissionImplies(false,c,a);
            doPermissionImplies(false,d,a);
            doPermissionImplies(false,e,a);
            doPermissionImplies(false,f,a);
            doPermissionImplies(false,f,b);
            doPermissionImplies(false,c,d);
            doPermissionImplies(false,e,d);
            doPermissionImplies(true,c,b);
            doPermissionImplies(true,d,b);
            doPermissionImplies(true,e,b);
            doPermissionImplies(true,d,c);
            doPermissionImplies(true,g,h);
            doPermissionImplies(true,h,g);
    
            doEJBRoleRefPermission(true,"EJBName","customer");

            EJBRoleRefPermission a1,a2,a3,a4;
            a1 = new EJBRoleRefPermission("EJBName1","roleRef1");
            a2 = new EJBRoleRefPermission("EJBName1","roleRef2");
            a3 = new EJBRoleRefPermission("EJBName2","roleRef1");
            a4 = new EJBRoleRefPermission("EJBName2","roleRef2");

            testSerialization(a1);
            testSerialization(a2);
            testSerialization(a3);
            testSerialization(a4);
    
            doPermissionImplies(true,a1,a1);
            doPermissionImplies(false,a1,a2);
            doPermissionImplies(false,a1,a3);
            doPermissionImplies(false,a1,a4);
            doPermissionImplies(false,a2,a1);
            doPermissionImplies(true,a2,a2);
            doPermissionImplies(false,a2,a3);
            doPermissionImplies(true,a3,a3);
            doPermissionImplies(false,a3,a4);
            doPermissionImplies(false,a4,a1);
            doPermissionImplies(false,a4,a2);
            doPermissionImplies(false,a4,a3);
            doPermissionImplies(true,a4,a4);
        }

        Method m[] = TestEJBPerms.class.getMethods();
        EJBMethodPermission p[] = new EJBMethodPermission[m.length];

        for (int i=0; i< m.length; i++) {
            doEJBMethodPermission( true, "TestEJBPerms","Home",m[i]);
            p[i] = new EJBMethodPermission("testEJBPerms","Home",m[i]);
            testSerialization(p[i]);
        }

        for (int i=0; i< m.length; i++) {
            for (int j=0; j<m.length; j++) {
                if (i == j) { 
                    doPermissionImplies(true,p[i],p[j]);
                } else {
                    doPermissionImplies(false,p[i],p[j]);
                }
            }
        }

        stat.printSummary();
    }
}