Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • irt/autopsy
1 result
Show changes
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1878 additions and 317 deletions
KeywordSearch/src/org/sleuthkit/autopsy/keywordsearch/SolrSearchService.java
View file @ fdb12806
......@@ -18,6 +18,7 @@
*/
package org.sleuthkit.autopsy.keywordsearch;
import java.awt.Component;
import java.io.File;
import java.io.IOException;
import java.io.Reader;
......@@ -26,18 +27,22 @@
import java.util.List;
import java.util.MissingResourceException;
import java.util.logging.Level;
import javax.swing.JOptionPane;
import org.apache.solr.client.solrj.SolrServerException;
import org.openide.util.NbBundle;
import org.openide.util.lookup.ServiceProvider;
import org.openide.util.lookup.ServiceProviders;
import org.openide.windows.WindowManager;
import org.sleuthkit.autopsy.appservices.AutopsyService;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.casemodule.CaseMetadata;
import org.sleuthkit.autopsy.core.RuntimeProperties;
import org.sleuthkit.autopsy.coreutils.FileUtil;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.ingest.IngestManager;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchService;
import org.sleuthkit.autopsy.keywordsearchservice.KeywordSearchServiceException;
import org.sleuthkit.autopsy.progress.ModalDialogProgressIndicator;
import org.sleuthkit.autopsy.progress.ProgressIndicator;
import org.sleuthkit.autopsy.textextractors.TextExtractor;
import org.sleuthkit.autopsy.textextractors.TextExtractorFactory;
......@@ -315,11 +320,25 @@ public void openCaseResources(CaseContext context) throws AutopsyServiceExceptio
}
throw new AutopsyServiceException(Bundle.SolrSearch_unableToFindIndex_msg());
}
if (context.cancelRequested()) {
return;
}
if (!IndexFinder.getCurrentSolrVersion().equals(indexToUse.getSolrVersion())) {
Index prevIndex = indexToUse;
indexToUse = tryUpgradeSolrVersion(context, indexToUse);
if (indexToUse != prevIndex) {
indexes.add(indexToUse);
}
}
if (context.cancelRequested()) {
return;
}
// check if schema is compatible
if (!indexToUse.isCompatible(IndexFinder.getCurrentSchemaVersion())) {
String msg = "Text index schema version " + indexToUse.getSchemaVersion() + " is not compatible with current schema";
......@@ -355,6 +374,71 @@ public void openCaseResources(CaseContext context) throws AutopsyServiceExceptio
progress.progress(Bundle.SolrSearch_complete_msg(), totalNumProgressUnits);
}
private static final long WAIT_TIME_MILLIS = 2000;
/**
* Attempts to upgrade the solr version to most recent version first prompting the user.
* @param context The case context.
* @param index The current index.
* @return The new index.
* @throws org.sleuthkit.autopsy.appservices.AutopsyService.AutopsyServiceException
*/
@NbBundle.Messages({
"Server_configureSolrConnection_unsupportedSolrTitle=Unsupported Keyword Search in Case",
"# {0} - solrVersion",
"# {1} - caseName",
"Server_configureSolrConnection_unsupportedSolrDesc=<html><body><p style=\"width: 400px\">This case was made with an older version of Keyword Search that is no longer supported. You can continue without upgrading, but some Keyword Search functionality will not be usable while the case is open, and you will encounter errors. You can also choose to upgrade the Keyword Search version for the case. If you choose to do this, you will need to run Keyword Search with Solr indexing selected in order to use features like ad hoc search with images in the case.</p></body></html>",
"Server_configureSolrConnection_unsupportedSolrDisableOpt=Continue",
"Server_configureSolrConnection_unsupportedSolrUpgradeOpt=Upgrade Solr Core"
})
private Index tryUpgradeSolrVersion(CaseContext context, Index index) throws AutopsyServiceException {
// if not, attempt to fix issue
if (RuntimeProperties.runningWithGUI()) {
Component parentComponent = WindowManager.getDefault().getMainWindow();
if (context.getProgressIndicator() instanceof ModalDialogProgressIndicator progInd && progInd.getDialog() != null) {
parentComponent = progInd.getDialog();
}
if (context.cancelRequested()) {
return index;
}
try {
// progress updates occur right before this in the same window, so there is the possibility that
// the progress window will update just after the option pane is shown causing the option pane to
// not be visible or selectable. This sleep is added to give the window enough time to finish
Thread.sleep(WAIT_TIME_MILLIS);
} catch (InterruptedException ex) {
// just proceed if interrupted
}
if (context.cancelRequested()) {
return index;
}
int selection = JOptionPane.showOptionDialog(
parentComponent,
Bundle.Server_configureSolrConnection_unsupportedSolrDesc(index.getSolrVersion(), context.getCase().getDisplayName()),
Bundle.Server_configureSolrConnection_unsupportedSolrTitle(),
JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE,
null,
new Object[]{
Bundle.Server_configureSolrConnection_unsupportedSolrDisableOpt(),
Bundle.Server_configureSolrConnection_unsupportedSolrUpgradeOpt()
},
Bundle.Server_configureSolrConnection_unsupportedSolrDisableOpt());
if (selection == 1) {
return IndexFinder.createLatestVersionIndex(context.getCase());
}
}
throw new AutopsyServiceException("Unsupported Keyword Search (Solr " + index.getSolrVersion() + ")");
}
/**
* Closes the open core.
......
RecentActivity/nbproject/project.properties
View file @ fdb12806
javac.source=17
file.reference.Rejistry-1.1-SNAPSHOT.jar=release/modules/ext/Rejistry-1.1-SNAPSHOT.jar
file.reference.sqlite-jdbc-3.42.0.0.jar=release/modules/ext/sqlite-jdbc-3.42.0.0.jar
file.reference.sqlite-jdbc-3.42.0.1.jar=release/modules/ext/sqlite-jdbc-3.42.0.1.jar
javac.compilerargs=-Xlint -Xlint:-serial
license.file=../LICENSE-2.0.txt
nbm.homepage=http://www.sleuthkit.org/autopsy/
......
RecentActivity/nbproject/project.xml
View file @ fdb12806
......@@ -88,8 +88,8 @@
<binary-origin>release/modules/ext/Rejistry-1.1-SNAPSHOT.jar</binary-origin>
</class-path-extension>
<class-path-extension>
<runtime-relative-path>ext/sqlite-jdbc-3.42.0.0.jar</runtime-relative-path>
<binary-origin>release/modules/ext/sqlite-jdbc-3.42.0.0.jar</binary-origin>
<runtime-relative-path>ext/sqlite-jdbc-3.42.0.1.jar</runtime-relative-path>
<binary-origin>release/modules/ext/sqlite-jdbc-3.42.0.1.jar</binary-origin>
</class-path-extension>
</data>
</configuration>
......
Running_Linux_OSX.md
View file @ fdb12806
# Overview
When installing on Debian-based Linux or macOS systems, there are three general steps: [installing prerequisites](#installing-prerequisites), [installing The Sleuth Kit](#installing-the-sleuth-kit), and [installing Autopsy](#installing-autopsy) itself. On macOS, you will want to [setup the JNA paths](#setup-macos-jna-paths).
For Linux systems that [support snapd](https://snapcraft.io/docs/installing-snapd), there is currently the option to install Autopsy from the [snap package](#install-autopsy-snap). Otherwise, when installing on Debian-based Linux or macOS systems, there are three general steps: [installing prerequisites](#installing-prerequisites), [installing The Sleuth Kit](#installing-the-sleuth-kit), and [installing Autopsy](#installing-autopsy) itself. On macOS, you will want to [setup the JNA paths](#setup-macos-jna-paths).
# Install Autopsy Snap
You can download the snap package from the [releases section](https://github.com/sleuthkit/autopsy/releases). In order for Autopsy to run properly, snap connections will need to be properly setup, which can be done by running this script: `snap connections autopsy | sed -nE 's/^[^ ]* *([^ ]*) *- *- *$/\1/p' | xargs -I{} sudo snap connect {}`. See the [snap README](./snap/README.md) for more information.
# Installing Prerequisites
- **Linux**: Run [`linux_macos_install_scripts/install_prereqs_ubuntu.sh`](./linux_macos_install_scripts/install_prereqs_ubuntu.sh).
......
apidiff.py deleted 100644 → 0
View file @ c23b4fd7
"""
Generates an api diff from one commit to another. This script relies on gitpython and similarly require git
installed on the system. This script also requires python 3.
This script can be called as follows:
python apidiff.py <previous tag id> <latest tag id> -r <repo path> -o <output path>
If the '-o' flag is not specified, this script will create a folder at apidiff_output in the same directory as the
script. For full list of options call:
python apidiff.py -h
"""
import os
import subprocess
import sys
import time
from pathlib import Path
from typing import Tuple, Iterator, List
import argparse as argparse
from git import Repo, Blob, Tree
"""
These are exit codes for jdiff:
return code 1 = error in jdiff
return code 100 = no changes
return code 101 = compatible changes
return code 102 = incompatible changes
"""
NO_CHANGES = 100
COMPATIBLE = 101
NON_COMPATIBLE = 102
ERROR = 1
def compare_xml(jdiff_path: str, root_dir: str, output_folder: str, oldapi_folder: str,
newapi_folder: str, api_file_name: str, log_path: str) -> int:
"""
Compares xml generated by jdiff using jdiff.
:param jdiff_path: Path to jdiff jar.
:param root_dir: directory for output .
:param output_folder: Folder for diff output.
:param oldapi_folder: Folder name of old api (i.e. release-4.10.2).
:param newapi_folder: Folder name of new api (i.e. release-4.10.2).
:param api_file_name: Name of xml file name (i.e. if output.xml, just 'output')
:param log_path: Path to log file.
:return: jdiff exit code.
"""
jdiff_parent = os.path.dirname(jdiff_path)
null_file = fix_path(os.path.join(jdiff_parent, "lib", "Null.java"))
# comments are expected in a specific place
make_dir(os.path.join(root_dir,
output_folder,
f"user_comments_for_{oldapi_folder}",
f"{api_file_name}_to_{newapi_folder}"))
log = open(log_path, "w")
cmd = ["javadoc",
"-doclet", "jdiff.JDiff",
"-docletpath", fix_path(jdiff_path),
"-d", fix_path(output_folder),
"-oldapi", fix_path(os.path.join(oldapi_folder, api_file_name)),
"-newapi", fix_path(os.path.join(newapi_folder, api_file_name)),
"-script",
null_file]
code = None
try:
jdiff = subprocess.Popen(cmd, stdout=log, stderr=log, cwd=root_dir)
jdiff.wait()
code = jdiff.returncode
except Exception as e:
log_and_print(log, f"Error executing javadoc: {str(e)}\nExiting...")
exit(1)
log.close()
print(f"Compared XML for {oldapi_folder} {newapi_folder}")
if code == NO_CHANGES:
print(" No API changes")
elif code == COMPATIBLE:
print(" API Changes are backwards compatible")
elif code == NON_COMPATIBLE:
print(" API Changes are not backwards compatible")
else:
print(" *Error in XML, most likely an empty module")
sys.stdout.flush()
return code
def gen_xml(jdiff_path: str, output_path: str, log_output_path: str, src: str, packages: List[str]):
"""
Uses jdiff to generate an xml representation of the source code.
:param jdiff_path: Path to jdiff jar.
:param output_path: Path to output path of diff.
:param log_output_path: The log output path.
:param src: The path to the source code.
:param packages: The packages to process.
"""
make_dir(output_path)
log = open_log_file(log_output_path)
log_and_print(log, f"Generating XML for: {src} outputting to: {output_path}")
cmd = ["javadoc",
"-doclet", "jdiff.JDiff",
"-docletpath", fix_path(jdiff_path),
"-apiname", fix_path(output_path),
"-sourcepath", fix_path(src)]
cmd = cmd + packages
try:
jdiff = subprocess.Popen(cmd, stdout=log, stderr=log)
jdiff.wait()
except Exception as e:
log_and_print(log, f"Error executing javadoc {str(e)}\nExiting...")
exit(1)
log_and_print(log, f"Generated XML for: " + str(packages))
log.close()
sys.stdout.flush()
def _list_paths(root_tree: Tree, src_folder, path: Path = None) -> Iterator[Tuple[str, Blob]]:
"""
Given the root path to serve as a prefix, walks the tree of a git commit returning all files and blobs.
Repurposed from: https://www.enricozini.org/blog/2019/debian/gitpython-list-all-files-in-a-git-commit/
Args:
root_tree: The tree of the commit to walk.
src_folder: relative path in repo to source folder that will be copied.
path: The path to use as a prefix.
Returns: A tuple iterator where each tuple consists of the path as a string and a blob of the file.
"""
for blob in root_tree.blobs:
next_path = Path(path) / blob.name if path else blob.name
if Path(src_folder) in Path(next_path).parents:
ret_item = (next_path, blob)
yield ret_item
for tree in root_tree.trees:
next_path = Path(path) / tree.name if path else tree.name
yield from _list_paths(tree, src_folder, next_path)
def _get_tree(repo_path: str, commit_id: str) -> Tree:
"""
Retrieves the git tree that can be walked for files and file content at the specified commit.
Args:
repo_path: The path to the repo or a child directory of the repo.
commit_id: The commit id.
Returns: The tree.
"""
repo = Repo(repo_path, search_parent_directories=True)
commit = repo.commit(commit_id.strip())
return commit.tree
def copy_commit_paths(repo_path, commit_id, src_folder, output_folder):
"""
Copies all files located within a repo in the folder 'src_folder' to 'output_folder'.
:param repo_path: The path to the repo.
:param commit_id: The commit id.
:param src_folder: The relative path in the repo to the source folder.
:param output_folder: The output folder where the source will be copied.
"""
tree = _get_tree(repo_path, commit_id)
for rel_path, blob in _list_paths(tree, src_folder):
output_path = os.path.join(output_folder, os.path.relpath(rel_path, src_folder))
parent_folder = os.path.dirname(output_path)
make_dir(parent_folder)
output_file = open(output_path, 'w')
output_file.write(blob.data_stream.read().decode('utf-8'))
output_file.close()
def open_log_file(log_path):
"""
Opens a path to a lof file for appending. Creating directories and log file as necessary.
:param log_path: The path to the log file.
:return: The log file opened for writing.
"""
if not os.path.exists(log_path):
make_dir(os.path.dirname(log_path))
Path(log_path).touch()
return open(log_path, 'a+')
def fix_path(path):
"""
Generates a path that is escaped from cygwin paths if present.
:param path: Path (possibly including cygdrive).
:return: The normalized path.
"""
if "cygdrive" in path:
new_path = path[11:]
return "C:/" + new_path
else:
return path
def log_and_print(log, message):
"""
Creates a log entry and prints to stdout.
:param log: The log file object.
:param message: The string to be printed.
"""
time_stamp = time.strftime('%Y-%m-%d %H:%M:%S')
print(f"{time_stamp}: {message}")
log.write(f"{time_stamp}: {message}\n")
def make_dir(dir_path: str):
"""
Create the given directory, if it doesn't already exist.
:param dir_path: The path to the directory.
:return: True if created.
"""
try:
if not os.path.isdir(dir_path):
os.makedirs(dir_path)
if os.path.isdir(dir_path):
return True
return False
except IOError:
print("Exception thrown when creating directory: " + dir_path)
return False
def run_compare(output_path: str, jdiff_path: str, repo_path: str, src_rel_path: str, prev_commit_id: str,
latest_commit_id: str, packages: List[str]):
"""
Runs a comparison of the api between two different commits/branches/tags of the same repo generating a jdiff diff.
:param output_path: The output path for artifacts.
:param jdiff_path: The path to the jdiff jar.
:param repo_path: The path to the repo.
:param src_rel_path: The relative path in the repo to the source directory.
:param prev_commit_id: The previous commit/branch/tag id.
:param latest_commit_id: The latest commit/branch/tag id.
:param packages: The packages to be considered for the api diff.
"""
log_path = os.path.join(output_path, "messages.log")
output_file_name = "output"
diff_dir = "diff"
src_folder = "src"
for commit_id in [prev_commit_id, latest_commit_id]:
src_copy = os.path.join(output_path, src_folder, commit_id)
copy_commit_paths(repo_path, commit_id, src_rel_path, src_copy)
gen_xml(jdiff_path, os.path.join(output_path, commit_id, output_file_name), log_path, src_copy, packages)
# compare the two
compare_xml(jdiff_path, output_path, os.path.join(output_path, diff_dir),
prev_commit_id, latest_commit_id, output_file_name, log_path)
def main():
parser = argparse.ArgumentParser(description="Generates a jdiff diff of the java api between two commits in a "
"repo.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(dest='prev_commit', type=str, help=r'The git commit id/branch/tag to be used for the first '
r'commit')
parser.add_argument(dest='latest_commit', type=str, help=r'The git commit id/branch/tag to be used for the latest '
r'commit')
parser.add_argument('-r', '--repo', dest='repo_path', type=str, required=True,
help='The path to the repo. If not specified, path of script is used.')
parser.add_argument('-o', '--output', dest='output_path', type=str, required=False,
help='The location for output of all artifacts. Defaults to an output folder in same directory'
'as script')
parser.add_argument('-s', '--src', dest='src_rel_folder', type=str, required=False, default="bindings/java/src",
help='The relative path within the repo of the src folder.')
# list of packages can be specified like this:
# https://stackoverflow.com/questions/15753701/how-can-i-pass-a-list-as-a-command-line-argument-with-argparse
parser.add_argument('-p', '--packages', dest='packages', nargs='+', required=False,
default=["org.sleuthkit.datamodel"], help='The packages to consider in api diff.')
parser.add_argument('-j', '--jdiff', dest='jdiff_path', type=str, required=False,
help='The packages to consider in api diff.')
args = parser.parse_args()
script_path = os.path.dirname(os.path.realpath(__file__))
repo_path = args.repo_path if args.repo_path else script_path
output_path = args.output_path if args.output_path else os.path.join(script_path, "apidiff_output")
jdiff_path = args.jdiff_path if args.jdiff_path else os.path.join(script_path,
"thirdparty/jdiff/v-custom/jdiff.jar")
run_compare(output_path=output_path,
jdiff_path=jdiff_path,
repo_path=repo_path,
packages=args.packages,
src_rel_path=args.src_rel_folder,
prev_commit_id=args.prev_commit,
latest_commit_id=args.latest_commit)
main()
docs/doxygen-user/ct_malware_scanner.dox
View file @ fdb12806
......@@ -13,17 +13,19 @@ For more information on what the module does or obtaining a license, refer to [C
Configuration
=======
==============
You will need to first get a paid or eval license from the above URL. The code will come in via email. Example license formats include:
* AUT-8ed86eb5-17fc-4b3a-9b75-ce638c11b070
* b826a555-951f-42ca-86ce-439a81106688
Once you have a license, you must add it on the Options panel. Choose the 'Cyber Triage' tab and choose 'Add License'.
- AUT-8ed86eb5-17fc-4b3a-9b75-ce638c11b070
- b826a555-951f-42ca-86ce-439a81106688
Once you have a license, you must add it on the Autopsy Options panel.
Choose the 'Cyber Triage' tab and choose 'Add License'.
\image html malware-scanner-global-options-panel-no-license.png
After you enter the license number that you should have received from your email, you will then need to review and agree to the license terms.
After you enter the license number from your email, you will then need to review and agree to the license terms.
The options panel should now display information about the lookup limits. You can always refer back to here about what your limits are and when they reset.
......@@ -38,7 +40,7 @@ Using the Module
Ingest Settings
------
For each data source, you select if you want files to be uploaded if they have not already been analyzed. By default, they are uploaded. You can choose to not upload them though.
For each data source, you select if you want files to be uploaded if they have not already been analyzed. By default, they are uploaded. You can choose to not upload them though. Refer to the main [website](https://cybertriage.com/autopsy-malware-module) for details on what happens when files are uploaded.
\image html malware-scanner-ingest-panel.png
......
docs/doxygen-user/footer.html
View file @ fdb12806
<hr/>
<p><i>Copyright &#169; 2012-2022 Basis Technology. Generated on $date<br/>
<p><i>Copyright &#169; 2012-2023 BasisTech. Generated on $date<br/>
This work is licensed under a
<a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/us/">Creative Commons Attribution-Share Alike 3.0 United States License</a>.
</i></p>
......
release_scripts/APIUpdate/.gitignore 0 → 100644
View file @ fdb12806
/target
\ No newline at end of file
release_scripts/APIUpdate/APIUpdate-1.0-jar-with-dependencies.jar 0 → 100644
View file @ fdb12806
File added
release_scripts/APIUpdate/README.md 0 → 100644
View file @ fdb12806
# APIDiff
## Overview
This code can be used to determine the public API changes between the previous version of Autopsy jars to current version of Autopsy jars. Based on those changes, this code can update version numbers (release, implementation, specification, dependency version).
## Sample Usage & Procedure
1. Before starting download the nbm jar files from the [previous release](https://github.com/sleuthkit/autopsy/releases/). The jar files will be located in the zip file or the installation directory (i.e. `C:\Program Files\Autopsy-x.xx.x`) at `autopsy/modules`.
2. Make sure you build the current source directory in order for the program to find the new compiled jars.
3. This code can be called from this directory with a command like: `java -jar APIUpdate-1.0-jar-with-dependencies.jar -p C:\path\to\prev\vers\jars\` to get api updates.
- You can specify the `-u` flag to make updates in source code making the command: `java -jar APIUpdate-1.0-jar-with-dependencies.jar -p C:\path\to\prev\vers\jars\ -u`.
- You can also add ` >C:\path\to\outputdiff.txt 2>&1` to output to a file.
## Arguments
```
usage: APIUpdate
-c,--curr-path <path> The path to the current version jar files
-cv,--curr-version <version> The current version number
-p,--prev-path <path> The path to the previous version jar files
-pv,--prev-version <version> The previous version number
-s,--src-path <path> The path to the root of the autopsy report
-u,--update Update source code versions
```
release_scripts/APIUpdate/nbactions.xml 0 → 100644
View file @ fdb12806
<?xml version="1.0" encoding="UTF-8"?>
<actions>
<action>
<actionName>run</actionName>
<packagings>
<packaging>jar</packaging>
</packagings>
<goals>
<goal>process-classes</goal>
<goal>org.codehaus.mojo:exec-maven-plugin:3.1.0:exec</goal>
</goals>
<properties>
<exec.vmArgs></exec.vmArgs>
<exec.args>${exec.vmArgs} -classpath %classpath ${exec.mainClass} ${exec.appArgs}</exec.args>
<exec.appArgs>--help</exec.appArgs>
<exec.mainClass>${packageClassName}</exec.mainClass>
<exec.executable>java</exec.executable>
</properties>
</action>
<action>
<actionName>debug</actionName>
<packagings>
<packaging>jar</packaging>
</packagings>
<goals>
<goal>process-classes</goal>
<goal>org.codehaus.mojo:exec-maven-plugin:3.1.0:exec</goal>
</goals>
<properties>
<exec.vmArgs>-agentlib:jdwp=transport=dt_socket,server=n,address=${jpda.address}</exec.vmArgs>
<exec.args>${exec.vmArgs} -classpath %classpath ${exec.mainClass} ${exec.appArgs}</exec.args>
<exec.appArgs>--help</exec.appArgs>
<exec.mainClass>${packageClassName}</exec.mainClass>
<exec.executable>java</exec.executable>
<jpda.listen>true</jpda.listen>
</properties>
</action>
<action>
<actionName>profile</actionName>
<packagings>
<packaging>jar</packaging>
</packagings>
<goals>
<goal>process-classes</goal>
<goal>org.codehaus.mojo:exec-maven-plugin:3.1.0:exec</goal>
</goals>
<properties>
<exec.vmArgs></exec.vmArgs>
<exec.args>${exec.vmArgs} -classpath %classpath ${exec.mainClass} ${exec.appArgs}</exec.args>
<exec.mainClass>${packageClassName}</exec.mainClass>
<exec.executable>java</exec.executable>
<exec.appArgs>--help</exec.appArgs>
</properties>
</action>
</actions>
release_scripts/APIUpdate/pom.xml 0 → 100644
View file @ fdb12806
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.sleuthkit.autopsy.classpathsimplication</groupId>
<artifactId>APIUpdate</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<exec.mainClass>org.sleuthkit.autopsy.apiupdate.Main</exec.mainClass>
</properties>
<dependencies>
<dependency>
<groupId>com.github.siom79.japicmp</groupId>
<artifactId>japicmp</artifactId>
<version>0.17.2</version>
</dependency>
<dependency>
<groupId>commons-cli</groupId>
<artifactId>commons-cli</artifactId>
<version>1.5.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.13.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<archive>
<manifest>
<mainClass>${exec.mainClass}</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<!--output jar file to project root-->
<outputDirectory>${project.basedir}</outputDirectory>
</configuration>
<executions>
<execution>
<id>make-assembly</id> <!-- this is used for inheritance merges -->
<phase>package</phase> <!-- bind to the packaging phase -->
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
\ No newline at end of file
release_scripts/APIUpdate/src/main/java/org/sleuthkit/autopsy/apiupdate/APIDiff.java 0 → 100644
View file @ fdb12806
/*
* Autopsy Forensic Browser
*
* Copyright 2023 Basis Technology Corp.
* Contact: carrier <at> sleuthkit <dot> org
*
* Licensed 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.
*/
package org.sleuthkit.autopsy.apiupdate;
import com.google.common.collect.Comparators;
import japicmp.cmp.JApiCmpArchive;
import japicmp.cmp.JarArchiveComparator;
import japicmp.cmp.JarArchiveComparatorOptions;
import japicmp.config.Options;
import japicmp.filter.BehaviorFilter;
import japicmp.filter.ClassFilter;
import japicmp.filter.FieldFilter;
import japicmp.model.JApiClass;
import japicmp.model.JApiSemanticVersionLevel;
import static japicmp.model.JApiSemanticVersionLevel.MAJOR;
import static japicmp.model.JApiSemanticVersionLevel.PATCH;
import japicmp.output.semver.SemverOut;
import japicmp.output.stdout.StdoutOutputGenerator;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javassist.CtBehavior;
import javassist.CtClass;
import javassist.CtField;
import javassist.CtMember;
import javassist.Modifier;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
/**
* Handles diffing the public API between two jar files.
*/
public class APIDiff {
private static final Logger LOGGER = Logger.getLogger(APIDiff.class.getName());
// filters to a jar or nbm file
private static final FileFilter JAR_FILTER
= (File f) -> f.isFile() && (f.getName().toLowerCase().endsWith(".jar") || f.getName().toLowerCase().endsWith(".nbm"));
/**
* Identifies common jar files between two directories. Only files listed in
* the directory are considered. This method does not recurse.
*
* @param prev The previous version directory.
* @param curr The current version directory.
* @return The jar file names.
*/
static List<Pair<File, File>> getCommonJars(File prev, File curr) {
if (prev.isFile() && curr.isFile()) {
return Arrays.asList(Pair.of(prev, curr));
}
Map<String, File> prevJars = getJars(prev);
Map<String, File> currJars = getJars(curr);
Set<String> combined = new HashSet<>(prevJars.keySet());
combined.addAll(currJars.keySet());
List<Pair<File, File>> retMapping = new ArrayList<>();
for (String prevKey : (Iterable<String>) combined.stream().sorted(StringUtils::compareIgnoreCase)::iterator) {
File prevFile = prevJars.get(prevKey);
File curFile = currJars.get(prevKey);
retMapping.add(Pair.of(prevFile, curFile));
}
return retMapping;
}
/**
* Returns all jar files listed in directory (does not recurse).
*
* @param dir The directory.
* @return The jar file names.
*/
private static Map<String, File> getJars(File dir) {
File[] files = dir.isDirectory() ? dir.listFiles(JAR_FILTER) : new File[]{dir};
files = files == null ? new File[0] : files;
return Stream.of(files).collect(Collectors.toMap(f -> f.getName(), f -> f, (f1, f2) -> f1));
}
/**
* Uses manfest.mf specification of "OpenIDE-Module-Public-Packages" to
* determine public API packages.
*
* @param jarFile The jar file.
* @return The set of package names.
* @throws IOException
* @throws IllegalStateException
*/
private static Set<String> getPublicPackages(File jarFile) throws IOException, IllegalStateException {
String publicPackageStr = ManifestLoader.loadFromJar(jarFile).getValue("OpenIDE-Module-Public-Packages");
if (publicPackageStr == null) {
LOGGER.log(Level.WARNING, MessageFormat.format("Manifest for {0} does not have key of 'OpenIDE-Module-Public-Packages'", jarFile.getAbsolutePath()));
return null;
} else {
return Stream.of(publicPackageStr.split(","))
.map(String::trim)
.map(str -> str.endsWith(".*") ? str.substring(0, str.length() - 2) : str)
.collect(Collectors.toSet());
}
}
/**
* Filter to identify non-public, non-protected members for exclusion.
*
* @param member The CtMember (field/method).
* @return True if should be excluded (private/package private).
*/
static boolean excludeMember(CtMember member) {
return !Modifier.isPublic(member.getModifiers()) && !Modifier.isProtected(member.getModifiers());
}
/**
* Compares two jar files.
*
* @param prevVersion The name of the previous version.
* @param curVersion The name of the current version.
* @param prevJar The previous version jar file.
* @param curJar The current version jar file.
* @return A record describing the comparison in public API.
* @throws IOException
*/
static ComparisonRecord getComparison(String prevVersion, String curVersion, File prevJar, File curJar) throws IOException {
// scope only to previous or current public packages if jars have public packages
Set<String> prevPublicApiPackages = getPublicPackages(prevJar);
Set<String> curPublicApiPackages = getPublicPackages(curJar);
Set<String> onlyPrevApiPackages = new HashSet<>();
Set<String> onlyCurApiPackages = new HashSet<>();
Set<String> commonApiPackages = new HashSet<>();
Optional<Set<String>> allPublicApiPackagesFilter = Optional.empty();
if (prevPublicApiPackages != null && curPublicApiPackages != null) {
Set<String> allPublicApiPackages = new HashSet<>();
allPublicApiPackages.addAll(prevPublicApiPackages);
allPublicApiPackages.addAll(curPublicApiPackages);
allPublicApiPackagesFilter.of(allPublicApiPackages);
for (String apiPackage : allPublicApiPackages) {
boolean inPrev = prevPublicApiPackages.contains(apiPackage);
boolean inCur = curPublicApiPackages.contains(apiPackage);
if (inPrev && !inCur) {
onlyPrevApiPackages.add(apiPackage);
} else if (!inPrev && inCur) {
onlyCurApiPackages.add(apiPackage);
} else {
commonApiPackages.add(apiPackage);
}
}
}
// get classes diff for public api changes
List<JApiClass> jApiClasses = getClassDiff(true, allPublicApiPackagesFilter, prevJar, prevVersion, curJar, curVersion);
Options options = Options.newDefault();
options.setOldArchives(Arrays.asList(new JApiCmpArchive(prevJar, prevVersion)));
options.setNewArchives(Arrays.asList(new JApiCmpArchive(curJar, curVersion)));
options.setOutputOnlyModifications(true);
PublicApiChangeType changeType = getChangeType(options, jApiClasses);
// if the change type is none, check for any internal changes
if (changeType == PublicApiChangeType.NONE) {
List<JApiClass> alljApiClasses = getClassDiff(false,Optional.empty(), prevJar, prevVersion, curJar, curVersion);
PublicApiChangeType allClassChangeType = getChangeType(options, jApiClasses);
changeType = allClassChangeType == PublicApiChangeType.NONE ? PublicApiChangeType.NONE : allClassChangeType.INTERNAL_CHANGE;
}
StdoutOutputGenerator stdoutOutputGenerator = new StdoutOutputGenerator(options, jApiClasses);
String humanReadableApiChange = stdoutOutputGenerator.generate();
return new ComparisonRecord(prevVersion, curVersion, prevJar, curJar, humanReadableApiChange, changeType, onlyPrevApiPackages, onlyCurApiPackages, commonApiPackages);
}
private static List<JApiClass> getClassDiff(boolean filter, Optional<Set<String>> publicPackagesFilter, File prevJar, String prevVersion, File curJar, String curVersion) {
JarArchiveComparatorOptions comparatorOptions = new JarArchiveComparatorOptions();
if (filter) {
// only classes in prev or current public api
if (publicPackagesFilter.isPresent()) {
final Set<String> publicPackages = publicPackagesFilter.get();
comparatorOptions.getFilters().getExcludes().add((ClassFilter) (CtClass ctClass) -> !publicPackages.contains(ctClass.getPackageName()));
}
// only public classes
comparatorOptions.getFilters().getExcludes().add((ClassFilter) (CtClass ctClass) -> !Modifier.isPublic(ctClass.getModifiers()));
// only fields, methods that are public or protected and class is not final
comparatorOptions.getFilters().getExcludes().add((FieldFilter) (CtField ctField) -> excludeMember(ctField));
comparatorOptions.getFilters().getExcludes().add((BehaviorFilter) (CtBehavior ctBehavior) -> excludeMember(ctBehavior));
}
comparatorOptions.getIgnoreMissingClasses().setIgnoreAllMissingClasses(true);
JarArchiveComparator jarArchiveComparator = new JarArchiveComparator(comparatorOptions);
List<JApiClass> jApiClasses = jarArchiveComparator.compare(
new JApiCmpArchive(prevJar, prevVersion),
new JApiCmpArchive(curJar, curVersion)
);
return jApiClasses;
}
/**
* Updates an atomic ref to the public api change type to the maximum change
* (where no change is min and incompatible change is max).
*
* @param apiChangeRef The atomic ref to a public api change type.
* @param versionLevel The semantic version level of the current change.
*/
private static void updateToMax(AtomicReference<PublicApiChangeType> apiChangeRef, JApiSemanticVersionLevel versionLevel) {
PublicApiChangeType apiChangeType;
if (versionLevel == null) {
return;
}
switch (versionLevel) {
case PATCH:
apiChangeType = PublicApiChangeType.INTERNAL_CHANGE;
break;
case MINOR:
apiChangeType = PublicApiChangeType.COMPATIBLE_CHANGE;
break;
case MAJOR:
apiChangeType = PublicApiChangeType.INCOMPATIBLE_CHANGE;
break;
default:
LOGGER.log(Level.WARNING, "Unknown sem ver type: " + versionLevel.name());
apiChangeType = PublicApiChangeType.INCOMPATIBLE_CHANGE;
break;
}
final PublicApiChangeType finalApiChangeType = apiChangeType;
apiChangeRef.updateAndGet((refType) -> Comparators.max(refType, finalApiChangeType));
}
/**
* Determines the public api change type for the given classes.
*
* @param options The options for output.
* @param jApiClasses The classes.
* @return The public API change type.
*/
static PublicApiChangeType getChangeType(Options options, List<JApiClass> jApiClasses) {
AtomicReference<PublicApiChangeType> apiChange = new AtomicReference<>(PublicApiChangeType.NONE);
new SemverOut(options, jApiClasses, (change, semanticVersionLevel) -> updateToMax(apiChange, semanticVersionLevel)).generate();
return apiChange.get();
}
/**
* A record describing the public API comparison of a previous and current
* version.
*/
public static class ComparisonRecord {
private final String prevVersion;
private final String curVersion;
private final File prevJar;
private final File curJar;
private final String humanReadableApiChange;
private final PublicApiChangeType changeType;
private final Set<String> onlyPrevApiPackages;
private final Set<String> onlyCurrApiPackages;
private final Set<String> commonApiPackages;
public ComparisonRecord(String prevVersion, String curVersion, File prevJar, File curJar, String humanReadableApiChange, PublicApiChangeType changeType, Set<String> onlyPrevApiPackages, Set<String> onlyCurrApiPackages, Set<String> commonApiPackages) {
this.prevVersion = prevVersion;
this.curVersion = curVersion;
this.prevJar = prevJar;
this.curJar = curJar;
this.humanReadableApiChange = humanReadableApiChange;
this.changeType = changeType;
this.onlyPrevApiPackages = onlyPrevApiPackages;
this.onlyCurrApiPackages = onlyCurrApiPackages;
this.commonApiPackages = commonApiPackages;
}
/**
* @return The previous version name.
*/
public String getPrevVersion() {
return prevVersion;
}
/**
* @return The current version name.
*/
public String getCurVersion() {
return curVersion;
}
/**
* @return The previous version jar file.
*/
public File getPrevJar() {
return prevJar;
}
/**
* @return The current version jar file.
*/
public File getCurJar() {
return curJar;
}
/**
* @return The human readable output describing the api changes.
*/
public String getHumanReadableApiChange() {
return humanReadableApiChange;
}
/**
* @return The public api change type.
*/
public PublicApiChangeType getChangeType() {
return changeType;
}
/**
* @return Names of packages only in previous public API.
*/
public Set<String> getOnlyPrevApiPackages() {
return onlyPrevApiPackages;
}
/**
* @return Names of packages only in current public API.
*/
public Set<String> getOnlyCurrApiPackages() {
return onlyCurrApiPackages;
}
/**
* @return Names of packages in common between previous and current
* public API.
*/
public Set<String> getCommonApiPackages() {
return commonApiPackages;
}
}
}
release_scripts/APIUpdate/src/main/java/org/sleuthkit/autopsy/apiupdate/CLIProcessor.java 0 → 100644
View file @ fdb12806
/*
* Autopsy Forensic Browser
*
* Copyright 2023 Basis Technology Corp.
* Contact: carrier <at> sleuthkit <dot> org
*
* Licensed 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.
*/
package org.sleuthkit.autopsy.apiupdate;
import java.io.File;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
/**
* Processes CLI options.
*/
public class CLIProcessor {
private static final Option PREV_VERS_PATH_OPT = Option.builder()
.argName("path")
.desc("The path to the previous version jar files")
.hasArg(true)
.longOpt("prev-path")
.option("p")
.required(true)
.build();
private static final Option CUR_VERS_PATH_OPT = Option.builder()
.argName("path")
.desc("The path to the current version jar files")
.hasArg(true)
.longOpt("curr-path")
.option("c")
.required(false)
.build();
private static final Option PREV_VERS_OPT = Option.builder()
.argName("version")
.desc("The previous version number")
.hasArg(true)
.longOpt("prev-version")
.option("pv")
.required(false)
.build();
private static final Option CUR_VERS_OPT = Option.builder()
.argName("version")
.desc("The current version number")
.hasArg(true)
.longOpt("curr-version")
.option("cv")
.required(false)
.build();
private static final Option SRC_LOC_OPT = Option.builder()
.argName("path")
.desc("The path to the root of the autopsy report")
.hasArg(true)
.longOpt("src-path")
.option("s")
.required(false)
.build();
private static final Option UPDATE_OPT = Option.builder()
.desc("Update source code versions")
.hasArg(false)
.longOpt("update")
.option("u")
.required(false)
.build();
private static final List<Option> ALL_OPTIONS = Arrays.asList(
PREV_VERS_PATH_OPT,
CUR_VERS_PATH_OPT,
PREV_VERS_OPT,
CUR_VERS_OPT,
SRC_LOC_OPT,
UPDATE_OPT
);
private static final Options CLI_OPTIONS = getCliOptions(ALL_OPTIONS);
private static final String DEFAULT_CURR_VERSION = "Current Version";
private static final String DEFAULT_PREV_VERSION = "Previous Version";
private static final String BUILD_REL_PATH = "build/cluster/modules";
private static final String JAR_SRC_REL_PATH = "../../../";
/**
* Creates an Options object from a list of options.
*
* @param opts The list of options.
* @return The options object.
*/
private static Options getCliOptions(List<Option> opts) {
Options toRet = new Options();
for (Option opt : opts) {
toRet.addOption(opt);
}
return toRet;
}
private static final Option HELP_OPT = Option.builder()
.desc("Print help message")
.hasArg(false)
.longOpt("help")
.option("h")
.required(false)
.build();
private static final Options HELP_OPTIONS = getCliOptions(Collections.singletonList(HELP_OPT));
private static final CommandLineParser parser = new DefaultParser();
private static final HelpFormatter helpFormatter = new HelpFormatter();
/**
* Prints help message.
*
* @param ex The exception or null if no exception.
*/
static void printHelp(Exception ex) {
if (ex != null && ex.getMessage() != null && !ex.getMessage().isBlank()) {
System.out.println(ex.getMessage());
}
helpFormatter.printHelp("APIUpdate", CLI_OPTIONS);
}
/**
* Parses the CLI args.
*
* @param args The arguments.
* @return The CLIArgs object.
* @throws ParseException
*/
static CLIArgs parseCli(String[] args) throws ParseException {
CommandLine helpCmd = parser.parse(HELP_OPTIONS, args, true);
boolean isHelp = helpCmd.hasOption(HELP_OPT);
if (isHelp) {
return new CLIArgs(null, null, null, null, null, false, true);
}
CommandLine cmd = parser.parse(CLI_OPTIONS, args);
String curVers = cmd.hasOption(CUR_VERS_OPT) ? cmd.getOptionValue(CUR_VERS_OPT) : DEFAULT_CURR_VERSION;
String prevVers = cmd.hasOption(PREV_VERS_OPT) ? cmd.getOptionValue(PREV_VERS_OPT) : DEFAULT_PREV_VERSION;
String srcPath;
try {
srcPath = cmd.hasOption(SRC_LOC_OPT)
? cmd.getOptionValue(SRC_LOC_OPT)
: new File(CLIProcessor.class.getProtectionDomain().getCodeSource().getLocation()
.toURI()).toPath().resolve(JAR_SRC_REL_PATH).toAbsolutePath().toString();
} catch (URISyntaxException ex) {
throw new ParseException("Unable to determine source path from current location: " + ex.getMessage());
}
String curVersPath = cmd.hasOption(CUR_VERS_PATH_OPT)
? cmd.getOptionValue(CUR_VERS_PATH_OPT)
: Paths.get(srcPath, BUILD_REL_PATH).toString();
String prevVersPath = cmd.getOptionValue(PREV_VERS_PATH_OPT);
boolean makeUpdate = cmd.hasOption(UPDATE_OPT);
File curVersFile = new File(curVersPath);
File prevVersFile = new File(prevVersPath);
File srcPathFile = new File(srcPath);
if (!curVersFile.exists()) {
throw new ParseException("No directory found at " + curVersFile.getAbsolutePath());
}
if (!prevVersFile.exists()) {
throw new ParseException("No directory found at " + prevVersFile.getAbsolutePath());
}
if (curVersFile.isDirectory() != prevVersFile.isDirectory()) {
throw new ParseException("Current and previous paths must both be directories or files");
}
if (!srcPathFile.isDirectory()) {
throw new ParseException("No directory found at " + srcPathFile.getAbsolutePath());
}
return new CLIArgs(curVers, prevVers, curVersFile, prevVersFile, srcPathFile, makeUpdate, false);
}
/**
* The CLI args object.
*/
public static class CLIArgs {
private final String currentVersion;
private final String previousVersion;
private final File currentVersPath;
private final File previousVersPath;
private final boolean isHelp;
private final File srcPath;
private final boolean makeUpdate;
public CLIArgs(String currentVersion, String previousVersion, File currentVersPath, File previousVersPath, File srcPath, boolean makeUpdate, boolean isHelp) {
this.currentVersion = currentVersion;
this.previousVersion = previousVersion;
this.currentVersPath = currentVersPath;
this.previousVersPath = previousVersPath;
this.srcPath = srcPath;
this.isHelp = isHelp;
this.makeUpdate = makeUpdate;
}
/**
* @return The current version name.
*/
public String getCurrentVersion() {
return currentVersion;
}
/**
* @return The previous version name.
*/
public String getPreviousVersion() {
return previousVersion;
}
/**
* @return The path to the directory containing the jars for current
* version.
*/
public File getCurrentVersPath() {
return currentVersPath;
}
/**
* @return The path to the directory containing the jars for previous
* version.
*/
public File getPreviousVersPath() {
return previousVersPath;
}
/**
* @return True if only print help message.
*/
public boolean isHelp() {
return isHelp;
}
/**
* @return True if module versions should be updated.
*/
public boolean isMakeUpdate() {
return makeUpdate;
}
/**
* @return The path to the source directory root for autopsy.
*/
public File getSrcPath() {
return srcPath;
}
}
}
release_scripts/APIUpdate/src/main/java/org/sleuthkit/autopsy/apiupdate/Main.java 0 → 100644
View file @ fdb12806
/*
* Autopsy Forensic Browser
*
* Copyright 2023 Basis Technology Corp.
* Contact: carrier <at> sleuthkit <dot> org
*
* Licensed 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.
*/
package org.sleuthkit.autopsy.apiupdate;
import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.cli.ParseException;
import org.apache.commons.lang3.tuple.Pair;
import org.sleuthkit.autopsy.apiupdate.APIDiff.ComparisonRecord;
import org.sleuthkit.autopsy.apiupdate.CLIProcessor.CLIArgs;
import org.sleuthkit.autopsy.apiupdate.ModuleUpdates.ModuleVersionNumbers;
/**
* Main class.
*/
public class Main {
private static final Logger LOGGER = Logger.getLogger(Main.class.getName());
public static void main(String[] args) {
CLIArgs cliArgs;
try {
cliArgs = CLIProcessor.parseCli(args);
if (cliArgs.isHelp()) {
CLIProcessor.printHelp(null);
System.exit(0);
}
} catch (ParseException ex) {
CLIProcessor.printHelp(ex);
System.exit(-1);
return;
}
Map<String, ModuleVersionNumbers> newVersionNumMapping = new HashMap<>();
for (Pair<File, File> prevCurJars : APIDiff.getCommonJars(cliArgs.getPreviousVersPath(), cliArgs.getCurrentVersPath())) {
try {
File previous = prevCurJars.getLeft();
File current = prevCurJars.getRight();
// if no current, then we can't update; just continue
if (current == null || !current.exists()) {
if (previous != null) {
LOGGER.log(Level.WARNING, "No matching current jar found for previous jar: " + previous);
}
continue;
}
String jarFileName = current.getName();
ModuleVersionNumbers projectedVersionNums;
if (previous == null || !previous.exists()) {
projectedVersionNums = ModuleVersionNumbers.getNewModule(current.getName());
outputNewModule(jarFileName, projectedVersionNums);
} else {
ModuleVersionNumbers prevVersionNums = ModuleUpdates.getVersionsFromJar(prevCurJars.getLeft());
ComparisonRecord record = APIDiff.getComparison(
cliArgs.getPreviousVersion(),
cliArgs.getCurrentVersion(),
prevCurJars.getLeft(),
prevCurJars.getRight());
projectedVersionNums = ModuleUpdates.getModuleVersionUpdate(prevVersionNums, record.getChangeType());
outputDiff(jarFileName, record, prevVersionNums, projectedVersionNums);
}
if (previous.getName().equalsIgnoreCase(current.getName())) {
jarFileName = previous.getName();
} else {
jarFileName = MessageFormat.format("[previous: {0}, current: {1}]", previous.getName(), current.getName());
}
newVersionNumMapping.put(projectedVersionNums.getRelease().getModuleName(), projectedVersionNums);
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
}
if (cliArgs.isMakeUpdate()) {
ModuleUpdates.setVersions(cliArgs.getSrcPath(), newVersionNumMapping);
}
}
/**
* Outputs the difference between previous and current version public API.
*
* @param commonJarFileName The common jar file name.
* @param record The comparison record.
* @param prevVersionNums The version numbers in previous version.
* @param projectedVersionNums The calculated version numbers for current
* version.
*/
private static void outputDiff(
String commonJarFileName,
ComparisonRecord record,
ModuleVersionNumbers prevVersionNums,
ModuleVersionNumbers projectedVersionNums
) {
LOGGER.log(Level.INFO, MessageFormat.format("""
====================================
DIFF FOR: {0}
Public API Change Type: {1}
Previous Version Numbers:
- release: {2}
- specification: {3}
- implementation: {4}
Current Version Numbers:
- release: {5}
- specification: {6}
- implementation: {7}
====================================
Public API packages only in previous: {8}
Public API packages only in current: {9}
{10}
""",
commonJarFileName,
record.getChangeType(),
prevVersionNums.getRelease().getFullReleaseStr(),
prevVersionNums.getSpec().getSemVerStr(),
prevVersionNums.getImplementation(),
projectedVersionNums.getRelease().getFullReleaseStr(),
projectedVersionNums.getSpec().getSemVerStr(),
projectedVersionNums.getImplementation(),
record.getOnlyPrevApiPackages(),
record.getOnlyCurrApiPackages(),
record.getHumanReadableApiChange()
));
}
/**
* Outputs new jar file name.
*
* @param jarFileName The jar file name.
* @param projectedVersionNums The calculated version numbers for current
* version.
*/
private static void outputNewModule(
String jarFileName,
ModuleVersionNumbers projectedVersionNums
) {
LOGGER.log(Level.INFO, MessageFormat.format("""
====================================
NEW MODULE: {0}
Current Version Numbers:
- release: {1}
- specification: {2}
- implementation: {3}
====================================
""",
jarFileName,
projectedVersionNums.getRelease().getFullReleaseStr(),
projectedVersionNums.getSpec().getSemVerStr(),
projectedVersionNums.getImplementation()
));
}
}
release_scripts/APIUpdate/src/main/java/org/sleuthkit/autopsy/apiupdate/ManifestLoader.java 0 → 100644
View file @ fdb12806
/*
* Autopsy Forensic Browser
*
* Copyright 2023 Basis Technology Corp.
* Contact: carrier <at> sleuthkit <dot> org
*
* Licensed 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.
*/
package org.sleuthkit.autopsy.apiupdate;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
/**
* Loads manifest.mf files.
*/
public class ManifestLoader {
private static final String JAR_MANIFEST_REL_PATH = "META-INF/MANIFEST.MF";
/**
* Loads the manifest attributes from an input stream.
* @param is The input stream.
* @return The manifest attributes.
* @throws IOException
*/
public static Attributes loadManifestAttributes(InputStream is) throws IOException {
Manifest manifest = loadManifest(is);
return manifest.getMainAttributes();
}
/**
* Loads the manifest from an input stream.
* @param is The input stream.
* @return The manifest.
* @throws IOException
*/
public static Manifest loadManifest(InputStream is) throws IOException {
return new Manifest(is);
}
/**
* Loads manifest attributes from a jar file.
* @param jarFile The jar file.
* @return The manifest attributes.
* @throws IOException
*/
public static Attributes loadFromJar(File jarFile) throws IOException {
ZipFile zipFile = new ZipFile(jarFile);
Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (JAR_MANIFEST_REL_PATH.equalsIgnoreCase(entry.getName())) {
return loadManifestAttributes(zipFile.getInputStream(entry));
}
}
throw new FileNotFoundException("Could not find MANIFEST.MF in " + jarFile.getAbsolutePath());
}
}
release_scripts/APIUpdate/src/main/java/org/sleuthkit/autopsy/apiupdate/PublicApiChangeType.java 0 → 100644
View file @ fdb12806
/*
* Autopsy Forensic Browser
*
* Copyright 2023 Basis Technology Corp.
* Contact: carrier <at> sleuthkit <dot> org
*
* Licensed 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.
*/
package org.sleuthkit.autopsy.apiupdate;
import java.util.Comparator;
import org.apache.commons.lang3.ObjectUtils;
/**
* A public API change type (no change, compatible change, incompatible change).
*/
public enum PublicApiChangeType implements Comparator<PublicApiChangeType> {
NONE(0), INTERNAL_CHANGE(1), COMPATIBLE_CHANGE(2), INCOMPATIBLE_CHANGE(3);
private final int level;
/**
* COnstructor.
*
* @param level The level for the api change (none is min, incompatible is
* max).
*/
PublicApiChangeType(int level) {
this.level = level;
}
/**
*
* @return The level for the api change (none is min, incompatible is max).
*/
public int getLevel() {
return level;
}
@Override
public int compare(PublicApiChangeType o1, PublicApiChangeType o2) {
o1 = ObjectUtils.defaultIfNull(o1, PublicApiChangeType.NONE);
o2 = ObjectUtils.defaultIfNull(o2, PublicApiChangeType.NONE);
return Integer.compare(o1.getLevel(), o2.getLevel());
}
}
snap/snapcraft.yaml
View file @ fdb12806
......@@ -19,10 +19,11 @@
# yaml reference here: https://snapcraft.io/docs/snapcraft-yaml-reference
# sample yaml files here: https://github.com/videolan/vlc/blob/master/extras/package/snap/snapcraft.yaml, https://github.com/canonical/firefox-snap/blob/stable/snapcraft.yaml
name: autopsy
title: Autopsy
# more on base snaps here: https://snapcraft.io/docs/base-snaps
# core is based on corresponding ubuntu version. ubuntu version information can be found here: https://wiki.ubuntu.com/Releases
base: core22
version: 4.20.0
version: 4.21.0
summary: A graphical interface to The Sleuth Kit and other digital forensics tools. # 79 char long summary
description: Autopsy is a graphical interface to The Sleuth Kit and other open source digital forensics tools.
source-code: https://github.com/sleuthkit/autopsy/
......@@ -38,7 +39,7 @@ compression: lzo
icon: snap/gui/autopsy.png
plugs:
system-files-autopsy:
system-files-dev:
interface: system-files
read: [/dev]
system-files-hugepages:
......@@ -88,7 +89,6 @@ apps:
# taken from https://snapcraft.io/docs/supported-interfaces
- audio-playback
- block-devices
- browser-sandbox
- desktop
- desktop-launch
- desktop-legacy
......@@ -108,7 +108,7 @@ apps:
- opengl
- optical-drive
- removable-media
- system-files-autopsy
- system-files-dev
- system-files-hugepages
- system-observe
slots:
......@@ -118,8 +118,8 @@ parts:
sleuthkit:
# more information on plugins here: https://snapcraft.io/docs/supported-plugins
plugin: autotools
source: https://github.com/sleuthkit/sleuthkit.git
source-branch: develop
source: https://gitlab.liu.se/irt/sleuthkit.git
source-branch: xfs_support
#source-tag: sleuthkit-4.12.0
build-environment: [JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64]
# information on packages here: https://snapcraft.io/docs/package-repositories
......@@ -173,8 +173,8 @@ parts:
# needed by solr to determine locally running ports
- lsof
plugin: nil
source: https://github.com/sleuthkit/autopsy.git
source-branch: develop
source: https://gitlab.liu.se/irt/autopsy.git
source-branch: xfs_support
build-environment:
- JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64
- TSK_JAVA_LIB_PATH: $SNAPCRAFT_STAGE/usr/local/share/java
......@@ -186,7 +186,7 @@ parts:
AUTOPSY_PLATFORM_PATH="$AUTOPSY_SRC_PATH/netbeans-plat/$NETBEANS_PLAT_VER"
AUTOPSY_HARNESS_PATH="$AUTOPSY_PLATFORM_PATH/harness"
export TSK_HOME="$HOME/parts/sleuthkit/build"
ant -Dnbplatform.active.dir="$AUTOPSY_PLATFORM_PATH" -Dnbplatform.default.harness.dir="$AUTOPSY_HARNESS_PATH" build build-zip
ant -Dnbplatform.active.dir="$AUTOPSY_PLATFORM_PATH" -Dnbplatform.default.harness.dir="$AUTOPSY_HARNESS_PATH" build-zip
# ----- SETUP EXTRACT DIRECTORY -----
AUTOPSY_LOCATION="$SNAPCRAFT_PART_INSTALL/autopsy"
......
thirdparty/jdiff/v-custom/.cvsignore deleted 100644 → 0
View file @ c23b4fd7
build
bin