| /* |
| * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.ArrayList; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Arrays; |
| import java.io.IOException; |
| import java.lang.module.ModuleDescriptor; |
| import jdk.testlibrary.ProcessTools; |
| import jdk.testlibrary.OutputAnalyzer; |
| import org.testng.annotations.BeforeTest; |
| |
| /** |
| * @test |
| * @bug 8130360 |
| * @library /lib/testlibrary |
| * @library /java/security/modules |
| * @modules java.base/jdk.internal.module |
| * @build CompilerUtils JarUtils |
| * @summary Test custom security provider module with all possible modular |
| * condition. The test includes different combination of security |
| * client/provider modules interaction with or without service |
| * description. |
| * @run testng SecurityProviderModularTest |
| */ |
| public class SecurityProviderModularTest extends ModularTest { |
| |
| private static final Path S_SRC = SRC.resolve("TestSecurityProvider.java"); |
| private static final String S_PKG = "provider"; |
| private static final String S_JAR_NAME = S_PKG + JAR_EXTN; |
| private static final String S_WITH_DESCR_JAR_NAME = S_PKG + DESCRIPTOR |
| + JAR_EXTN; |
| private static final String MS_JAR_NAME = MODULAR + S_PKG + JAR_EXTN; |
| private static final String MS_WITH_DESCR_JAR_NAME = MODULAR + S_PKG |
| + DESCRIPTOR + JAR_EXTN; |
| |
| private static final Path C_SRC = SRC.resolve( |
| "TestSecurityProviderClient.java"); |
| private static final String C_PKG = "client"; |
| private static final String C_JAR_NAME = C_PKG + JAR_EXTN; |
| private static final String MC_DEPENDS_ON_AUTO_SERVICE_JAR_NAME = MODULAR |
| + C_PKG + AUTO + JAR_EXTN; |
| private static final String MC_JAR_NAME = MODULAR + C_PKG + JAR_EXTN; |
| |
| private static final Path BUILD_DIR = Paths.get(".").resolve("build"); |
| private static final Path COMPILE_DIR = BUILD_DIR.resolve("bin"); |
| private static final Path S_BUILD_DIR = COMPILE_DIR.resolve(S_PKG); |
| private static final Path S_WITH_META_DESCR_BUILD_DIR = COMPILE_DIR.resolve( |
| S_PKG + DESCRIPTOR); |
| private static final Path C_BUILD_DIR = COMPILE_DIR.resolve(C_PKG); |
| private static final Path M_BASE_PATH = BUILD_DIR.resolve("mbase"); |
| private static final Path ARTIFACTS_DIR = BUILD_DIR.resolve("artifacts"); |
| |
| private static final Path S_ARTIFACTS_DIR = ARTIFACTS_DIR.resolve(S_PKG); |
| private static final Path S_JAR = S_ARTIFACTS_DIR.resolve(S_JAR_NAME); |
| private static final Path S_WITH_DESCRIPTOR_JAR = S_ARTIFACTS_DIR.resolve( |
| S_WITH_DESCR_JAR_NAME); |
| private static final Path MS_JAR = S_ARTIFACTS_DIR.resolve( |
| MS_JAR_NAME); |
| private static final Path MS_WITH_DESCR_JAR = S_ARTIFACTS_DIR.resolve( |
| MS_WITH_DESCR_JAR_NAME); |
| |
| private static final Path C_ARTIFACTS_DIR = ARTIFACTS_DIR.resolve(C_PKG); |
| private static final Path C_JAR = C_ARTIFACTS_DIR.resolve(C_JAR_NAME); |
| private static final Path MC_JAR = C_ARTIFACTS_DIR.resolve(MC_JAR_NAME); |
| private static final Path MC_DEPENDS_ON_AUTO_SERVICE_JAR = C_ARTIFACTS_DIR |
| .resolve(MC_DEPENDS_ON_AUTO_SERVICE_JAR_NAME); |
| |
| private static final String MAIN = C_PKG + ".TestSecurityProviderClient"; |
| private static final String S_INTERFACE = "java.security.Provider"; |
| private static final String S_IMPL = S_PKG + ".TestSecurityProvider"; |
| private static final List<String> M_REQUIRED = Arrays.asList("java.base"); |
| private static final Path META_DESCR_PATH = Paths.get("META-INF") |
| .resolve("services").resolve(S_INTERFACE); |
| private static final Path S_META_DESCR_FPATH = S_WITH_META_DESCR_BUILD_DIR |
| .resolve(META_DESCR_PATH); |
| |
| private static final boolean WITH_S_DESCR = true; |
| private static final boolean WITHOUT_S_DESCR = false; |
| private static final String CLASS_NOT_FOUND_MSG = "NoClassDefFoundError:" |
| + " provider/TestSecurityProvider"; |
| private static final String PROVIDER_NOT_FOUND_MSG = "Unable to find Test" |
| + " Security Provider"; |
| private static final String CAN_NOT_ACCESS_MSG = "cannot access class"; |
| private static final String NO_FAILURE = null; |
| private static final String SERVICE_LOADER = "SERVICE_LOADER"; |
| private static final String CLASS_LOADER = "CLASS_LOADER"; |
| private static final String SECURITY_PROP = "SECURITY_PROP"; |
| private static final List<String> MECHANISMS = Arrays.asList(SERVICE_LOADER, |
| CLASS_LOADER, SECURITY_PROP); |
| private static final Path SECURE_PROP_EXTN = Paths.get("./java.secure.ext"); |
| |
| /** |
| * Generates Test specific input parameters. |
| */ |
| @Override |
| public Object[][] getTestInput() { |
| |
| List<List<Object>> params = new ArrayList<>(); |
| MECHANISMS.stream().forEach((mechanism) -> { |
| boolean useCLoader = CLASS_LOADER.equals(mechanism); |
| boolean useSLoader = SERVICE_LOADER.equals(mechanism); |
| String[] args = new String[]{mechanism}; |
| //PARAMETER ORDERS - |
| //client Module Type, Service Module Type, |
| //Service META Descriptor Required, |
| //Expected Failure message, mech used to find the provider |
| params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.EXPLICIT, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.EXPLICIT, |
| WITHOUT_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.AUTO, |
| WITH_S_DESCR, ((useCLoader) ? CAN_NOT_ACCESS_MSG |
| : NO_FAILURE), args)); |
| params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.AUTO, |
| WITHOUT_S_DESCR, CLASS_NOT_FOUND_MSG, args)); |
| params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.UNNAMED, |
| WITH_S_DESCR, ((useCLoader) ? CAN_NOT_ACCESS_MSG |
| : NO_FAILURE), args)); |
| params.add(Arrays.asList(MODULE_TYPE.EXPLICIT, MODULE_TYPE.UNNAMED, |
| WITHOUT_S_DESCR, ((useCLoader) ? CAN_NOT_ACCESS_MSG |
| : ((useSLoader) ? PROVIDER_NOT_FOUND_MSG |
| : NO_FAILURE)), args)); |
| |
| params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.EXPLICIT, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.EXPLICIT, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.AUTO, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.AUTO, |
| WITHOUT_S_DESCR, CLASS_NOT_FOUND_MSG, args)); |
| params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.UNNAMED, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.AUTO, MODULE_TYPE.UNNAMED, |
| WITHOUT_S_DESCR, ((useSLoader) ? PROVIDER_NOT_FOUND_MSG |
| : NO_FAILURE), args)); |
| |
| params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.EXPLICIT, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.EXPLICIT, |
| WITHOUT_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.AUTO, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.AUTO, |
| WITHOUT_S_DESCR, CLASS_NOT_FOUND_MSG, args)); |
| params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.UNNAMED, |
| WITH_S_DESCR, NO_FAILURE, args)); |
| params.add(Arrays.asList(MODULE_TYPE.UNNAMED, MODULE_TYPE.UNNAMED, |
| WITHOUT_S_DESCR, ((useSLoader) ? PROVIDER_NOT_FOUND_MSG |
| : NO_FAILURE), args)); |
| }); |
| return params.stream().map(p -> p.toArray()).toArray(Object[][]::new); |
| } |
| |
| /** |
| * Pre-compile and generate the artifacts required to run this test before |
| * running each test cases. |
| */ |
| @BeforeTest |
| public void buildArtifacts() { |
| |
| boolean done = true; |
| try { |
| |
| done &= CompilerUtils.compile(S_SRC, S_BUILD_DIR); |
| done &= CompilerUtils.compile(S_SRC, S_WITH_META_DESCR_BUILD_DIR); |
| done &= createMetaInfServiceDescriptor(S_META_DESCR_FPATH, S_IMPL); |
| //Generate regular/modular jars with(out) META-INF |
| //Service descriptor |
| generateJar(true, MODULE_TYPE.EXPLICIT, MS_JAR, S_BUILD_DIR, false); |
| generateJar(true, MODULE_TYPE.EXPLICIT, MS_WITH_DESCR_JAR, |
| S_WITH_META_DESCR_BUILD_DIR, false); |
| generateJar(true, MODULE_TYPE.UNNAMED, S_JAR, S_BUILD_DIR, false); |
| generateJar(true, MODULE_TYPE.UNNAMED, S_WITH_DESCRIPTOR_JAR, |
| S_WITH_META_DESCR_BUILD_DIR, false); |
| //Generate regular/modular(depends on explicit/auto Service) |
| //jars for client |
| done &= CompilerUtils.compile(C_SRC, C_BUILD_DIR, "-cp", |
| S_JAR.toFile().getCanonicalPath()); |
| generateJar(false, MODULE_TYPE.EXPLICIT, MC_JAR, C_BUILD_DIR, true); |
| generateJar(false, MODULE_TYPE.EXPLICIT, |
| MC_DEPENDS_ON_AUTO_SERVICE_JAR, C_BUILD_DIR, false); |
| generateJar(false, MODULE_TYPE.UNNAMED, C_JAR, C_BUILD_DIR, false); |
| System.out.format("%nArtifacts generated successfully? %s", done); |
| if (!done) { |
| throw new RuntimeException("Artifacts generation failed"); |
| } |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| /** |
| * Generate modular/regular jar based on module type for this test. |
| */ |
| private void generateJar(boolean isService, MODULE_TYPE moduleType, |
| Path jar, Path compilePath, boolean depends) throws IOException { |
| |
| ModuleDescriptor mDescriptor = null; |
| if (isService) { |
| mDescriptor = generateModuleDescriptor(isService, moduleType, S_PKG, |
| S_PKG, S_INTERFACE, S_IMPL, null, M_REQUIRED, depends); |
| } else { |
| mDescriptor = generateModuleDescriptor(isService, moduleType, C_PKG, |
| C_PKG, S_INTERFACE, null, S_PKG, M_REQUIRED, depends); |
| } |
| generateJar(mDescriptor, jar, compilePath); |
| } |
| |
| /** |
| * Holds Logic for the test. This method will get called with each test |
| * parameter. |
| */ |
| @Override |
| public OutputAnalyzer executeTestClient(MODULE_TYPE cModuleType, |
| Path cJarPath, MODULE_TYPE sModuletype, Path sJarPath, |
| String... args) throws Exception { |
| |
| OutputAnalyzer output = null; |
| try { |
| |
| //For automated/explicit module type copy the corresponding |
| //jars to module base folder, which will be considered as |
| //module base path during execution. |
| if (!(cModuleType == MODULE_TYPE.UNNAMED |
| && sModuletype == MODULE_TYPE.UNNAMED)) { |
| copyJarsToModuleBase(cModuleType, cJarPath, M_BASE_PATH); |
| copyJarsToModuleBase(sModuletype, sJarPath, M_BASE_PATH); |
| } |
| |
| System.out.format("%nExecuting java client with required" |
| + " custom security provider in class/module path."); |
| String mName = getModuleName(cModuleType, cJarPath, C_PKG); |
| Path cmBasePath = (cModuleType != MODULE_TYPE.UNNAMED |
| || sModuletype != MODULE_TYPE.UNNAMED) ? M_BASE_PATH : null; |
| String cPath = buildClassPath(cModuleType, cJarPath, sModuletype, |
| sJarPath); |
| |
| Map<String, String> VM_ARGS = getVMArgs(sModuletype, args); |
| output = ProcessTools.executeTestJava( |
| getJavaCommand(cmBasePath, cPath, mName, MAIN, VM_ARGS, |
| args)).outputTo(System.out).errorTo(System.out); |
| } finally { |
| //clean module path so that the modulepath can hold only |
| //the required jars for next run. |
| cleanModuleBasePath(M_BASE_PATH); |
| System.out.println("--------------------------------------------"); |
| } |
| return output; |
| } |
| |
| /** |
| * Decide the pre-generated client/service jar path for each test case |
| * based on client/service module type. |
| */ |
| @Override |
| public Path findJarPath(boolean isService, MODULE_TYPE moduleType, |
| boolean addMetaDesc, boolean dependsOnServiceModule) { |
| if (isService) { |
| if (moduleType == MODULE_TYPE.EXPLICIT) { |
| if (addMetaDesc) { |
| return MS_WITH_DESCR_JAR; |
| } else { |
| return MS_JAR; |
| } |
| } else { |
| if (addMetaDesc) { |
| return S_WITH_DESCRIPTOR_JAR; |
| } else { |
| return S_JAR; |
| } |
| } |
| } else { |
| if (moduleType == MODULE_TYPE.EXPLICIT) { |
| if (dependsOnServiceModule) { |
| return MC_JAR; |
| } else { |
| return MC_DEPENDS_ON_AUTO_SERVICE_JAR; |
| } |
| } else { |
| return C_JAR; |
| } |
| } |
| } |
| |
| /** |
| * VM argument required for the test. |
| */ |
| private Map<String, String> getVMArgs(MODULE_TYPE sModuletype, |
| String... args) throws IOException { |
| final Map<String, String> VM_ARGS = new LinkedHashMap<>(); |
| VM_ARGS.put("-Duser.language=", "en"); |
| VM_ARGS.put("-Duser.region=", "US"); |
| //If mechanism selected to find the provider through |
| //Security.getProvider() then use providerName/ProviderClassName based |
| //on modular/regular provider jar in security configuration file. |
| if (args != null && args.length > 0 && SECURITY_PROP.equals(args[0])) { |
| if (sModuletype == MODULE_TYPE.UNNAMED) { |
| Files.write(SECURE_PROP_EXTN, ("security.provider.10=" + S_IMPL) |
| .getBytes()); |
| } else { |
| Files.write(SECURE_PROP_EXTN, "security.provider.10=TEST" |
| .getBytes()); |
| } |
| VM_ARGS.put("-Djava.security.properties=", SECURE_PROP_EXTN.toFile() |
| .getCanonicalPath()); |
| } |
| return VM_ARGS; |
| } |
| |
| } |
