releasing updates from private repo

Former-commit-id: 064139c68ad185358d6c74a77511d9ca36229633

dependency-check-cli/src/main/java/org/owasp/dependencycheck/App.java

@@ -0,0 +1,198 @@
+/*
+ * This file is part of dependency-check-cli.
+ *
+ * Dependency-check-cli is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * Dependency-check-cli 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 for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * dependency-check-cli. If not, see http://www.gnu.org/licenses/.
+ *
+ * Copyright (c) 2012 Jeremy Long. All Rights Reserved.
+ */
+package org.owasp.dependencycheck;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import org.apache.commons.cli.ParseException;
+import org.owasp.dependencycheck.reporting.ReportGenerator;
+import org.owasp.dependencycheck.dependency.Dependency;
+import org.owasp.dependencycheck.cli.CliParser;
+import org.owasp.dependencycheck.utils.Settings;
+
+/*
+ * This file is part of App.
+ *
+ * App is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ *
+ * App 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * App. If not, see http://www.gnu.org/licenses/.
+ *
+ * Copyright (c) 2012 Jeremy Long. All Rights Reserved.
+ */
+/**
+ * The command line interface for the DependencyCheck application.
+ *
+ * @author Jeremy Long (jeremy.long@owasp.org)
+ */
+public class App {
+
+    /**
+     * The location of the log properties configuration file.
+     */
+    private static final String LOG_PROPERTIES_FILE = "log.properties";
+
+    /**
+     * The main method for the application.
+     *
+     * @param args the command line arguments
+     */
+    public static void main(String[] args) {
+        prepareLogger();
+        final App app = new App();
+        app.run(args);
+    }
+
+    /**
+     * Configures the logger for use by the application.
+     */
+    private static void prepareLogger() {
+        InputStream in = null;
+        try {
+            in = App.class.getClassLoader().getResourceAsStream(LOG_PROPERTIES_FILE);
+            LogManager.getLogManager().reset();
+            LogManager.getLogManager().readConfiguration(in);
+        } catch (IOException ex) {
+            Logger.getLogger(App.class.getName()).log(Level.FINE, "IO Error preparing the logger", ex);
+        } catch (SecurityException ex) {
+            Logger.getLogger(App.class.getName()).log(Level.FINE, "Error preparing the logger", ex);
+        } finally {
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (Exception ex) {
+                    Logger.getLogger(App.class.getName()).log(Level.FINEST, "Error closing resource stream", ex);
+                }
+            }
+        }
+    }
+
+    /**
+     * Main CLI entry-point into the application.
+     *
+     * @param args the command line arguments
+     */
+    public void run(String[] args) {
+
+        final CliParser cli = new CliParser();
+        try {
+            cli.parse(args);
+        } catch (FileNotFoundException ex) {
+            System.err.println(ex.getMessage());
+            cli.printHelp();
+            return;
+        } catch (ParseException ex) {
+            System.err.println(ex.getMessage());
+            cli.printHelp();
+            return;
+        }
+
+        if (cli.isGetVersion()) {
+            cli.printVersionInfo();
+        } else if (cli.isRunScan()) {
+            updateSettings(cli.isAutoUpdate(), cli.getConnectionTimeout(), cli.getProxyUrl(), cli.getProxyPort(), cli.getDataDirectory());
+            runScan(cli.getReportDirectory(), cli.getReportFormat(), cli.getApplicationName(), cli.getScanFiles());
+        } else {
+            cli.printHelp();
+        }
+    }
+
+    /**
+     * Scans the specified directories and writes the dependency reports to the
+     * reportDirectory.
+     *
+     * @param reportDirectory the path to the directory where the reports will
+     * be written
+     * @param outputFormat the output format of the report
+     * @param applicationName the application name for the report
+     * @param files the files/directories to scan
+     */
+    private void runScan(String reportDirectory, String outputFormat, String applicationName, String[] files) {
+        final Engine scanner = new Engine();
+
+        for (String file : files) {
+            scanner.scan(file);
+        }
+
+        scanner.analyzeDependencies();
+        final List<Dependency> dependencies = scanner.getDependencies();
+
+        final ReportGenerator report = new ReportGenerator(applicationName, dependencies, scanner.getAnalyzers());
+        try {
+            report.generateReports(reportDirectory, outputFormat);
+        } catch (IOException ex) {
+            Logger.getLogger(App.class.getName()).log(Level.SEVERE, "There was an IO error while attempting to generate the report.");
+            Logger.getLogger(App.class.getName()).log(Level.INFO, null, ex);
+        } catch (Exception ex) {
+            Logger.getLogger(App.class.getName()).log(Level.SEVERE, "There was an error while attempting to generate the report.");
+            Logger.getLogger(App.class.getName()).log(Level.INFO, null, ex);
+        }
+    }
+
+    /**
+     * Updates the global Settings.
+     *
+     * @param autoUpdate whether or not to update cached web data sources
+     * @param connectionTimeout the timeout to use when downloading resources
+     * (null or blank will use default)
+     * @param proxyUrl the proxy url (null or blank means no proxy will be used)
+     * @param proxyPort the proxy port (null or blank means no port will be
+     * used)
+     * @param dataDirectory the directory to store/retrieve persistent data from
+     */
+    private void updateSettings(boolean autoUpdate, String connectionTimeout, String proxyUrl, String proxyPort, String dataDirectory) {
+        if (dataDirectory != null) {
+            Settings.setString(Settings.KEYS.DATA_DIRECTORY, dataDirectory);
+        } else if (System.getProperty("basedir") != null) {
+            final File dataDir = new File(System.getProperty("basedir"), "data");
+            Settings.setString(Settings.KEYS.DATA_DIRECTORY, dataDir.getAbsolutePath());
+        } else {
+            final File jarPath = new File(App.class.getProtectionDomain().getCodeSource().getLocation().getPath());
+            final File base = jarPath.getParentFile();
+            final String sub = Settings.getString(Settings.KEYS.DATA_DIRECTORY);
+            final File dataDir = new File(base, sub);
+            Settings.setString(Settings.KEYS.DATA_DIRECTORY, dataDir.getAbsolutePath());
+        }
+
+
+        Settings.setBoolean(Settings.KEYS.AUTO_UPDATE, autoUpdate);
+        if (proxyUrl != null && !proxyUrl.isEmpty()) {
+            Settings.setString(Settings.KEYS.PROXY_URL, proxyUrl);
+        }
+        if (proxyPort != null && !proxyPort.isEmpty()) {
+            Settings.setString(Settings.KEYS.PROXY_PORT, proxyPort);
+        }
+        if (connectionTimeout != null && !connectionTimeout.isEmpty()) {
+            Settings.setString(Settings.KEYS.CONNECTION_TIMEOUT, connectionTimeout);
+        }
+    }
+}

dependency-check-cli/src/main/java/org/owasp/dependencycheck/cli/CliParser.java

@@ -0,0 +1,474 @@
+/*
+ * This file is part of dependency-check-cli.
+ *
+ * Dependency-check-cli is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * Dependency-check-cli 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 for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * dependency-check-cli. If not, see http://www.gnu.org/licenses/.
+ *
+ * Copyright (c) 2012 Jeremy Long. All Rights Reserved.
+ */
+package org.owasp.dependencycheck.cli;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.OptionBuilder;
+import org.apache.commons.cli.OptionGroup;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.PosixParser;
+import org.owasp.dependencycheck.reporting.ReportGenerator;
+import org.owasp.dependencycheck.reporting.ReportGenerator.Format;
+import org.owasp.dependencycheck.utils.Settings;
+
+/**
+ * A utility to parse command line arguments for the DependencyCheck.
+ *
+ * @author Jeremy Long (jeremy.long@owasp.org)
+ */
+public final class CliParser {
+
+    /**
+     * The command line.
+     */
+    private CommandLine line;
+    /**
+     * The options for the command line parser.
+     */
+    private final Options options = createCommandLineOptions();
+    /**
+     * Indicates whether the arguments are valid.
+     */
+    private boolean isValid = true;
+
+    /**
+     * Parses the arguments passed in and captures the results for later use.
+     *
+     * @param args the command line arguments
+     * @throws FileNotFoundException is thrown when a 'file' argument does not
+     * point to a file that exists.
+     * @throws ParseException is thrown when a Parse Exception occurs.
+     */
+    public void parse(String[] args) throws FileNotFoundException, ParseException {
+        line = parseArgs(args);
+
+        if (line != null) {
+            validateArgs();
+        }
+    }
+
+    /**
+     * Parses the command line arguments.
+     *
+     * @param args the command line arguments
+     * @return the results of parsing the command line arguments
+     * @throws ParseException if the arguments are invalid
+     */
+    private CommandLine parseArgs(String[] args) throws ParseException {
+        final CommandLineParser parser = new PosixParser();
+        return parser.parse(options, args);
+    }
+
+    /**
+     * Validates that the command line arguments are valid.
+     *
+     * @throws FileNotFoundException if there is a file specified by either the
+     * SCAN or CPE command line arguments that does not exist.
+     * @throws ParseException is thrown if there is an exception parsing the
+     * command line.
+     */
+    private void validateArgs() throws FileNotFoundException, ParseException {
+        if (isRunScan()) {
+            validatePathExists(getScanFiles(), "scan");
+            validatePathExists(getReportDirectory(), "out");
+            if (!line.hasOption(ArgumentName.APP_NAME)) {
+                throw new ParseException("Missing 'app' argument; the scan cannot be run without the an application name.");
+            }
+            if (line.hasOption(ArgumentName.OUTPUT_FORMAT)) {
+                final String format = line.getOptionValue(ArgumentName.OUTPUT_FORMAT);
+                try {
+                    Format.valueOf(format);
+                } catch (IllegalArgumentException ex) {
+                    final String msg = String.format("An invalid 'format' of '%s' was specified. Supported output formats are XML, HTML, VULN, or ALL", format);
+                    throw new ParseException(msg);
+                }
+            }
+        }
+    }
+
+    /**
+     * Validates whether or not the path(s) points at a file that exists; if the
+     * path(s) does not point to an existing file a FileNotFoundException is
+     * thrown.
+     *
+     * @param paths the paths to validate if they exists
+     * @param optType the option being validated (e.g. scan, out, etc.)
+     * @throws FileNotFoundException is thrown if one of the paths being
+     * validated does not exist.
+     */
+    private void validatePathExists(String[] paths, String optType) throws FileNotFoundException {
+        for (String path : paths) {
+            validatePathExists(path, optType);
+        }
+    }
+
+    /**
+     * Validates whether or not the path points at a file that exists; if the
+     * path does not point to an existing file a FileNotFoundException is
+     * thrown.
+     *
+     * @param path the paths to validate if they exists
+     * @param optType the option being validated (e.g. scan, out, etc.)
+     * @throws FileNotFoundException is thrown if the path being validated does
+     * not exist.
+     */
+    private void validatePathExists(String path, String optType) throws FileNotFoundException {
+        final File f = new File(path);
+        if (!f.exists()) {
+            isValid = false;
+            final String msg = String.format("Invalid '%s' argument: '%s'", optType, path);
+            throw new FileNotFoundException(msg);
+        }
+    }
+
+    /**
+     * Generates an Options collection that is used to parse the command line
+     * and to display the help message.
+     *
+     * @return the command line options used for parsing the command line
+     */
+    @SuppressWarnings("static-access")
+    private Options createCommandLineOptions() {
+        final Option help = new Option(ArgumentName.HELP_SHORT, ArgumentName.HELP, false,
+                "Print this message.");
+
+        final Option version = new Option(ArgumentName.VERSION_SHORT, ArgumentName.VERSION,
+                false, "Print the version information.");
+
+        final Option noUpdate = new Option(ArgumentName.DISABLE_AUTO_UPDATE_SHORT, ArgumentName.DISABLE_AUTO_UPDATE,
+                false, "Disables the automatic updating of the CPE data.");
+
+        final Option appName = OptionBuilder.withArgName("name").hasArg().withLongOpt(ArgumentName.APP_NAME)
+                .withDescription("The name of the application being scanned. This is a required argument.")
+                .create(ArgumentName.APP_NAME_SHORT);
+
+        final Option connectionTimeout = OptionBuilder.withArgName("timeout").hasArg().withLongOpt(ArgumentName.CONNECTION_TIMEOUT)
+                .withDescription("The connection timeout (in milliseconds) to use when downloading resources.")
+                .create(ArgumentName.CONNECTION_TIMEOUT_SHORT);
+
+        final Option proxyUrl = OptionBuilder.withArgName("url").hasArg().withLongOpt(ArgumentName.PROXY_URL)
+                .withDescription("The proxy url to use when downloading resources.")
+                .create(ArgumentName.PROXY_URL_SHORT);
+
+        final Option proxyPort = OptionBuilder.withArgName("port").hasArg().withLongOpt(ArgumentName.PROXY_PORT)
+                .withDescription("The proxy port to use when downloading resources.")
+                .create(ArgumentName.PROXY_PORT_SHORT);
+
+        final Option path = OptionBuilder.withArgName("path").hasArg().withLongOpt(ArgumentName.SCAN)
+                .withDescription("The path to scan - this option can be specified multiple times.")
+                .create(ArgumentName.SCAN_SHORT);
+
+        final Option props = OptionBuilder.withArgName("file").hasArg().withLongOpt(ArgumentName.PROP)
+                .withDescription("A property file to load.")
+                .create(ArgumentName.PROP_SHORT);
+
+        final Option data = OptionBuilder.withArgName("path").hasArg().withLongOpt(ArgumentName.DATA_DIRECTORY)
+                .withDescription("The location of the data directory used to store persistent data. This option should generally not be set.")
+                .create(ArgumentName.DATA_DIRECTORY_SHORT);
+
+        final Option out = OptionBuilder.withArgName("folder").hasArg().withLongOpt(ArgumentName.OUT)
+                .withDescription("The folder to write reports to. This defaults to the current directory.")
+                .create(ArgumentName.OUT_SHORT);
+
+        final Option outputFormat = OptionBuilder.withArgName("format").hasArg().withLongOpt(ArgumentName.OUTPUT_FORMAT)
+                .withDescription("The output format to write to (XML, HTML, VULN, ALL). The default is HTML.")
+                .create(ArgumentName.OUTPUT_FORMAT_SHORT);
+
+        final OptionGroup og = new OptionGroup();
+        og.addOption(path);
+
+        final Options opts = new Options();
+        opts.addOptionGroup(og);
+        opts.addOption(out);
+        opts.addOption(outputFormat);
+        opts.addOption(appName);
+        opts.addOption(version);
+        opts.addOption(help);
+        opts.addOption(noUpdate);
+        opts.addOption(props);
+        opts.addOption(data);
+        opts.addOption(proxyPort);
+        opts.addOption(proxyUrl);
+        opts.addOption(connectionTimeout);
+
+        return opts;
+    }
+
+    /**
+     * Determines if the 'version' command line argument was passed in.
+     *
+     * @return whether or not the 'version' command line argument was passed in
+     */
+    public boolean isGetVersion() {
+        return (line != null) && line.hasOption(ArgumentName.VERSION);
+    }
+
+    /**
+     * Determines if the 'help' command line argument was passed in.
+     *
+     * @return whether or not the 'help' command line argument was passed in
+     */
+    public boolean isGetHelp() {
+        return (line != null) && line.hasOption(ArgumentName.HELP);
+    }
+
+    /**
+     * Determines if the 'scan' command line argument was passed in.
+     *
+     * @return whether or not the 'scan' command line argument was passed in
+     */
+    public boolean isRunScan() {
+        return (line != null) && isValid && line.hasOption(ArgumentName.SCAN);
+    }
+
+    /**
+     * Displays the command line help message to the standard output.
+     */
+    public void printHelp() {
+        final HelpFormatter formatter = new HelpFormatter();
+        final String nl = System.getProperty("line.separator");
+
+        formatter.printHelp(Settings.getString("application.name", "DependencyCheck"),
+                nl + Settings.getString("application.name", "DependencyCheck")
+                + " can be used to identify if there are any known CVE vulnerabilities in libraries utilized by an application. "
+                + Settings.getString("application.name", "DependencyCheck")
+                + " will automatically update required data from the Internet, such as the CVE and CPE data files from nvd.nist.gov." + nl + nl,
+                options,
+                "",
+                true);
+    }
+
+    /**
+     * Retrieves the file command line parameter(s) specified for the 'scan'
+     * argument.
+     *
+     * @return the file paths specified on the command line for scan
+     */
+    public String[] getScanFiles() {
+        return line.getOptionValues(ArgumentName.SCAN);
+    }
+
+    /**
+     * Returns the directory to write the reports to specified on the command
+     * line.
+     *
+     * @return the path to the reports directory.
+     */
+    public String getReportDirectory() {
+        return line.getOptionValue(ArgumentName.OUT, ".");
+    }
+
+    /**
+     * Returns the output format specified on the command line. Defaults to HTML
+     * if no format was specified.
+     *
+     * @return the output format name.
+     */
+    public String getReportFormat() {
+        return line.getOptionValue(ArgumentName.OUTPUT_FORMAT, "HTML");
+    }
+
+    /**
+     * Returns the application name specified on the command line.
+     *
+     * @return the application name.
+     */
+    public String getApplicationName() {
+        return line.getOptionValue(ArgumentName.APP_NAME);
+    }
+
+    /**
+     * Returns the connection timeout.
+     *
+     * @return the connection timeout
+     */
+    public String getConnectionTimeout() {
+        return line.getOptionValue(ArgumentName.CONNECTION_TIMEOUT);
+    }
+
+    /**
+     * Returns the proxy url.
+     *
+     * @return the proxy url
+     */
+    public String getProxyUrl() {
+        return line.getOptionValue(ArgumentName.PROXY_URL);
+    }
+
+    /**
+     * Returns the proxy port.
+     *
+     * @return the proxy port
+     */
+    public String getProxyPort() {
+        return line.getOptionValue(ArgumentName.PROXY_PORT);
+    }
+
+    /**
+     * Get the value of dataDirectory.
+     *
+     * @return the value of dataDirectory
+     */
+    public String getDataDirectory() {
+        return line.getOptionValue(ArgumentName.DATA_DIRECTORY);
+    }
+
+    /**
+     * <p>Prints the manifest information to standard output.</p>
+     * <ul><li>Implementation-Title: ${pom.name}</li>
+     * <li>Implementation-Version: ${pom.version}</li></ul>
+     */
+    public void printVersionInfo() {
+        final String version = String.format("%s version %s",
+                Settings.getString("application.name", "DependencyCheck"),
+                Settings.getString("application.version", "Unknown"));
+        System.out.println(version);
+    }
+
+    /**
+     * Checks if the auto update feature has been disabled. If it has been
+     * disabled via the command line this will return false.
+     *
+     * @return if auto-update is allowed.
+     */
+    public boolean isAutoUpdate() {
+        return (line == null) || !line.hasOption(ArgumentName.DISABLE_AUTO_UPDATE);
+    }
+
+    /**
+     * A collection of static final strings that represent the possible command
+     * line arguments.
+     */
+    public static class ArgumentName {
+
+        /**
+         * The long CLI argument name specifying the directory/file to scan.
+         */
+        public static final String SCAN = "scan";
+        /**
+         * The short CLI argument name specifying the directory/file to scan.
+         */
+        public static final String SCAN_SHORT = "s";
+        /**
+         * The long CLI argument name specifying that the CPE/CVE/etc. data
+         * should not be automatically updated.
+         */
+        public static final String DISABLE_AUTO_UPDATE = "noupdate";
+        /**
+         * The short CLI argument name specifying that the CPE/CVE/etc. data
+         * should not be automatically updated.
+         */
+        public static final String DISABLE_AUTO_UPDATE_SHORT = "n";
+        /**
+         * The long CLI argument name specifying the directory to write the
+         * reports to.
+         */
+        public static final String OUT = "out";
+        /**
+         * The short CLI argument name specifying the directory to write the
+         * reports to.
+         */
+        public static final String OUT_SHORT = "o";
+        /**
+         * The long CLI argument name specifying the output format to write the
+         * reports to.
+         */
+        public static final String OUTPUT_FORMAT = "format";
+        /**
+         * The short CLI argument name specifying the output format to write the
+         * reports to.
+         */
+        public static final String OUTPUT_FORMAT_SHORT = "f";
+        /**
+         * The long CLI argument name specifying the name of the application to
+         * be scanned.
+         */
+        public static final String APP_NAME = "app";
+        /**
+         * The short CLI argument name specifying the name of the application to
+         * be scanned.
+         */
+        public static final String APP_NAME_SHORT = "a";
+        /**
+         * The long CLI argument name asking for help.
+         */
+        public static final String HELP = "help";
+        /**
+         * The short CLI argument name asking for help.
+         */
+        public static final String HELP_SHORT = "h";
+        /**
+         * The long CLI argument name asking for the version.
+         */
+        public static final String VERSION_SHORT = "v";
+        /**
+         * The short CLI argument name asking for the version.
+         */
+        public static final String VERSION = "version";
+        /**
+         * The short CLI argument name indicating the proxy port.
+         */
+        public static final String PROXY_PORT_SHORT = "p";
+        /**
+         * The CLI argument name indicating the proxy port.
+         */
+        public static final String PROXY_PORT = "proxyport";
+        /**
+         * The short CLI argument name indicating the proxy url.
+         */
+        public static final String PROXY_URL_SHORT = "u";
+        /**
+         * The CLI argument name indicating the proxy url.
+         */
+        public static final String PROXY_URL = "proxyurl";
+        /**
+         * The short CLI argument name indicating the proxy url.
+         */
+        public static final String CONNECTION_TIMEOUT_SHORT = "c";
+        /**
+         * The CLI argument name indicating the proxy url.
+         */
+        public static final String CONNECTION_TIMEOUT = "connectiontimeout";
+        /**
+         * The short CLI argument name for setting the location of an additional
+         * properties file.
+         */
+        public static final String PROP_SHORT = "p";
+        /**
+         * The CLI argument name for setting the location of an additional
+         * properties file.
+         */
+        public static final String PROP = "propertyfile";
+        /**
+         * The CLI argument name for setting the location of the data directory.
+         */
+        public static final String DATA_DIRECTORY = "data";
+        /**
+         * The short CLI argument name for setting the location of the data
+         * directory.
+         */
+        public static final String DATA_DIRECTORY_SHORT = "d";
+    }
+}

dependency-check-cli/src/main/java/org/owasp/dependencycheck/cli/package-info.java

@@ -0,0 +1,12 @@
+/**
+ * <html>
+ * <head>
+ * <title>org.owasp.dependencycheck.cli</title>
+ * </head>
+ * <body>
+ * Includes utility classes such as the CLI Parser,
+ * </body>
+ * </html>
+*/
+
+package org.owasp.dependencycheck.cli;

dependency-check-cli/src/main/java/org/owasp/dependencycheck/package-info.java

@@ -0,0 +1,12 @@
+/**
+ * <html>
+ * <head>
+ * <title>org.owasp.dependencycheck</title>
+ * </head>
+ * <body>
+ * Includes the main entry point for the DependencyChecker.
+ * </body>
+ * </html>
+*/
+
+package org.owasp.dependencycheck;