org.icestuff.getdown.maven.DefaultSignTool Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of getdown-maven-plugin Show documentation
Creates deployable, updateable java applications using Getdown (https://github.com/threerings/getdown/).
The newest version!
package org.icestuff.getdown.maven;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.shared.jarsigner.JarSigner;
import org.apache.maven.shared.jarsigner.JarSignerRequest;
import org.apache.maven.shared.jarsigner.JarSignerUtil;
import org.apache.maven.shared.utils.cli.CommandLineException;
import org.apache.maven.shared.utils.cli.javatool.JavaToolException;
import org.apache.maven.shared.utils.cli.javatool.JavaToolResult;
import org.codehaus.mojo.keytool.KeyTool;
import org.codehaus.mojo.keytool.requests.KeyToolGenerateKeyPairRequest;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.codehaus.plexus.logging.AbstractLogEnabled;

import java.io.File;
import java.io.IOException;
import java.net.URI;

/**
 * Default implementation of the {@link SignTool}.
 *
 * @author tchemit 
 * @since 1.0-beta-3
 */
@Component(role = SignTool.class, hint = "default")
public class DefaultSignTool extends AbstractLogEnabled implements SignTool {

	/**
	 * The component to invoke jarsigner command.
	 */
	@Requirement
	private JarSigner jarSigner;

	/**
	 * The component to invoke keyTool command.
	 */
	@Requirement
	private KeyTool keyTool;

	/**
	 * {@inheritDoc}
	 */
	public void generateKey(SignConfig config, File keystoreFile) throws MojoExecutionException {
		KeyToolGenerateKeyPairRequest request = config.createKeyGenRequest(keystoreFile);

		try {
			JavaToolResult result = keyTool.execute(request);

			CommandLineException exception = result.getExecutionException();
			if (exception != null) {
				throw new MojoExecutionException("Could not generate key store " + keystoreFile, exception);
			}
			int exitCode = result.getExitCode();
			if (exitCode != 0) {
				throw new MojoExecutionException(
						"Could not generate key store " + keystoreFile + ", use -X to have detail of error");
			}
		} catch (JavaToolException e) {
			throw new MojoExecutionException("Could not find keytool", e);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public void sign(SignConfig config, File jarFile, File signedJar) throws MojoExecutionException {

		JarSignerRequest request = config.createSignRequest(jarFile, signedJar);

		try {
			JavaToolResult result = jarSigner.execute(request);

			CommandLineException exception = result.getExecutionException();
			if (exception != null) {
				throw new MojoExecutionException("Could not sign jar " + jarFile, exception);
			}
			int exitCode = result.getExitCode();
			if (exitCode != 0) {
				throw new MojoExecutionException("Could not sign jar " + jarFile + ", use -X to have detail of error");
			}
		} catch (JavaToolException e) {
			throw new MojoExecutionException("Could not find jarSigner", e);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public void verify(SignConfig config, File jarFile, boolean certs) throws MojoExecutionException {

		JarSignerRequest request = config.createVerifyRequest(jarFile, certs);

		try {
			JavaToolResult result = jarSigner.execute(request);

			CommandLineException exception = result.getExecutionException();
			if (exception != null) {
				throw new MojoExecutionException("Could not verify jar " + jarFile, exception);
			}
			int exitCode = result.getExitCode();
			if (exitCode != 0) {
				throw new MojoExecutionException(
						"Could not verify jar " + jarFile + ", use -X to have detail of error");
			}
		} catch (JavaToolException e) {
			throw new MojoExecutionException("Could not find jarSigner", e);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public boolean isJarSigned(File jarFile) throws MojoExecutionException {
		try {
			return JarSignerUtil.isArchiveSigned(jarFile);
		} catch (IOException e) {
			throw new MojoExecutionException("Could not verifiy that jar is signed or not", e);
		}

	}

	/**
	 * {@inheritDoc}
	 */
	public void unsign(File jarFile, boolean verbose) throws MojoExecutionException {

		if (isJarSigned(jarFile)) {

			// unsign jar

			verboseLog(verbose, "Unsign jar " + jarFile);
			try {
				JarSignerUtil.unsignArchive(jarFile);
			} catch (IOException e) {

				throw new MojoExecutionException("Could not find unsign jar " + jarFile, e);
			}
		} else {

			// not signed jar do nothing
			verboseLog(verbose, "Jar " + jarFile + " is not signed.");
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public void deleteKeyStore(File keystore, boolean verbose) {
		if (keystore.exists()) {
			if (keystore.delete()) {
				infoOrDebug(verbose, "deleted keystore from: " + keystore.getAbsolutePath());
			} else {
				getLogger().warn("Couldn't delete keystore from: " + keystore.getAbsolutePath());
			}
		} else {
			infoOrDebug(verbose, "Skipping deletion of non existing keystore: " + keystore.getAbsolutePath());
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public File getKeyStoreFile(String keystore, File workingKeystore, ClassLoader classLoader)
			throws MojoExecutionException {

		File result;

		URI keystoreURI = null;
		try {
			keystoreURI = URI.create(keystore);
		} catch (IllegalArgumentException e) {
			// Windows paths like C:\Users throw an IAE due to the '\'
		}

		if (keystoreURI == null || keystoreURI.getScheme() == null) {

			// consider it as a simple file
			result = new File(keystore);
		} else {
			// copy stream to working keystore
			result = workingKeystore;

			// make parent directory if required
			Util.makeDirectoryIfNecessary(result.getParentFile());

			// copy keystore to workingKeystore
			Util.copyResources(keystoreURI, classLoader, result);
		}
		return result;
	}

	/**
	 * Log as info when verbose or info is enabled, as debug otherwise.
	 *
	 * @param verbose
	 *            verbose level
	 * @param msg
	 *            message to log
	 */
	protected void verboseLog(boolean verbose, String msg) {
		infoOrDebug(verbose || getLogger().isInfoEnabled(), msg);
	}

	/**
	 * Log a message as info or debug.
	 *
	 * @param info
	 *            if set to true, log as info(), otherwise as debug()
	 * @param msg
	 *            message to log
	 */
	private void infoOrDebug(boolean info, String msg) {
		if (info) {
			getLogger().info(msg);
		} else {
			getLogger().debug(msg);
		}
	}

}