haskal
/
dragnpkgs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: haskal:main
Branches Tags
haskal:main
haskal:nixos-25.05
haskal:wip/nixos-25.05-ghidra
haskal:nixos-24.11
haskal:mkflake
haskal:nixos-24.11-tmp
haskal:nixos-24.05
haskal:module/dbzfs
..
compare: haskal:mkflake
Branches Tags
haskal:nixos-25.05
haskal:main
haskal:wip/nixos-25.05-ghidra
haskal:nixos-24.11
haskal:mkflake
haskal:nixos-24.11-tmp
haskal:nixos-24.05
haskal:module/dbzfs

1 Commits
main ... mkflake

Author SHA1 Message Date
xenia 7d39b44e6a mkFlake: add self argument which handles system 2025-04-26 19:56:23 -04:00
62 changed files with 1736 additions and 2675 deletions
Show Stats Expand all files Collapse all files

663
README.md
View File

@ -6,45 +6,28 @@ include_toc: true
# dragnpkgs
this is my personal nixos modules and packages repository. while it was designed for my own use,
it's also intended to be flexible and reusable enough for general purpose usage
dragnpkgs provides the following
- a set of package definitions, in `pkgs/`, which provide packages not in `nixpkgs`, some of my own
libraries and utilities, and rewrites/patches of upstream packages to suit my needs
- the top level overlay is located in `overlay.nix`, in a similar style as nixpkgs
`all-packages.nix`
- a set of nixos modules, in `modules/`
- a module including all of the other modules is located at `module.nix`
- utilities, in `lib/` and contained within `flake.nix`
- flake templates, in `templates/`
- a full wrapper around `nixpkgs` which includes the package set and nixos modules by default, and
changes the default nix implementation to `lix`, so this repo can be used in place of the
`nixpkgs` flake
## licensing
this repository is NOT licensed under a "standard" FOSS license. instead, it uses [CC-BY-NC-SA
4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en). this means, in particular that
commercial use is forbidden. if you are, for whatever reason, interested in using this code
commercially, please contact me
additionally, several package definitions included in this repo point to packages which have their
own noteworthy licensing (including, for example, unfree and non-redistributable game server
software). make sure you are following the license requirements, which can be found in
`meta.license` for each package
it's also intended to be flexible and reusable enough for general purpose usage. i might consider
upstreaming into nixpkgs if there is sufficient interest
## usage
dragnpkgs provides a set of nixos modules and a nixpkgs overlay containing custom packages. the
modules require the overlay
### non-flake
since i use flakes now (sigh!!!) i'm not supporting non-flake usage anymore. if you read the files
in the repo there's a way to do it probably
### flake
for flake usage, add this repo as an input and don't input nixpkgs at all, since we fully wrap it
```nix
{
inputs = {
# for nixos-25.05
dragnpkgs.url = "git+https://git.lain.faith/haskal/dragnpkgs.git?ref=nixos-25.05";
# for nixos-24.11
dragnpkgs.url = "git+https://git.lain.faith/haskal/dragnpkgs.git?ref=nixos-24.11";
# for nixos-unstable
dragnpkgs.url = "git+https://git.lain.faith/haskal/dragnpkgs.git?ref=main";
@ -64,81 +47,159 @@ flake.nix for details
dragnpkgs-specific registration mechanism for these that is enabled by default, see
`options.dragnpkgs`
- in flake.nix but not in module.nix: disable channels
- add lix cache and its keys to substitutors
- enable experimental features `nix-command flakes repl-flake`
- disable the default flake registry. i think it's cringe
- add a repl overlay that adds some useful utilities to `nix repl` -- see repl-overlay.nix for
details
- provides a flake pure eval mode bypass via a lix plugin for allowlisting certain unfree licenses
that can be enabled when the user has permission to use packages with those licenses. this allows
usage of those packages without needing to set `NIXPKGS_ALLOW_UNFREE=1` and passing `--impure`,
which i find very clunky
also note that overriding inputs to the flake won't necessarily work because of the way nixpkgs
registers itself with the system. this requires really annoying hacks to get working at all. if you
want to depend on `dragnpkgs` with a different version of `nixpkgs` (ie not 24.11 or unstable),
clone the repo and recreate `flake.lock`. aren't flakes so cool and fun!!!!
## flake lib documentation
## options documentation
These utilities are provided by the dragnpkgs flake.
documentation for options provided by dragnpkgs
### `dragnpkgs.lib.mkFlake attrs`
This provides a small utility for defining flakes in a way that avoids some of the pain related to
flake attributes being keyed by `system`. `attrs` is an attribute set similar to what would normally
be returned for `outputs`, but the keys `packages`, `legacyPackages`, `devShells`, and `apps` are
written in `callPackage` style
For example:
### [`services.ghidra-server`](./modules/ghidra-server)
the shared project server for [ghidra](https://ghidra-sre.org)
example usage:
```nix
outputs = { self, dragnpkgs }: dragnpkgs.lib.mkFlake {
devShells.default = {
mkShell,
hello,
}: mkShell {
packages = [
hello
];
};
services.ghidra-server = {
enable = true;
host = "your.domain.or.ip";
};
```
Currently there is no mechanism to access `system`-keyed attributes from another `system`-keyed
attribute, so it must be done manually using `system` in the arguments to the `callPackage`-style
function. For example:
#### services.ghidra-server.enable
```nix
outputs = { self, dragnpkgs }: dragnpkgs.lib.mkFlake {
packages.default = {
stdenv,
mydependency,
}: stdenv.mkDerivation {
pname = "mypackage";
version = "DEV";
enables the ghidra server service
src = ./.;
#### services.ghidra-server.enableAdminCli (`true`)
buildInputs = [ mydependency ];
};
adds a system package for the CLI tool `ghidra-svrAdmin`, which allows anyone in the `ghidra` group
to administer the server (this corresponds to the `server/svrAdmin` tool in the stock ghidra
distribution)
devShells.default = {
mkShell,
system,
}: mkShell {
packages = [
self.packages.${system}.default
];
};
};
#### services.ghidra-server.{package, jdkPackage} (`ghidra_headless`, `openjdk21_headless`)
allows overriding the ghidra package and jdk package used for the server
#### services.ghidra-server.host
the server hostname or IP; this is typically required (by java RMI) for correct operation
#### services.ghidra-server.basePort (`13100`)
the server will use 3 consecutive TCP ports starting from this port
#### services.ghidra-server.directory (`ghidra-server`)
the root directory for server files, as a subdirectory of `/var/lib`. this is needed because this
option is passed to systemd `StateDirectory=`
#### services.ghidra-server.{user,group} (`ghidra`)
the service user and group
### more coming soon(tm)
## packages documentation
### [`ghidra_headless`](./default.nix)
a variant of ghidra which does not have a dependency on any jdk, intended to
reduce closure size for server operation with a headless jdk (in particular,
the ghidra-server nixos module uses `ghidra_headless` with `openjdk21_headless`
by default
### [`ghidra`](./pkgs/ghidra-xenia/build.nix)
a version of ghidra that uses a split derivation, `lib` contains the core
ghidra distribution, `doc` contains all the documentation elements, and `out`
contains the bin folder, icons, and desktop file. only `out` has a dependency
on the build jdk, so `lib` and `doc` can be used with reduced closure size
### [`kicad`](./pkgs/kicad-xenia/default.nix)
preview version of kicad with my patches
### [`ocamlPackages.ppx_unicode`](./pkgs/ocaml/ppx_unicode)
opinionated ppx for string literals: <https://git.lain.faith/haskal/ppx_unicode>
### [`ocamlPackages.xlog`](./pkgs/ocaml/xlog)
logging for cats, in ocaml: <https://git.lain.faith/haskal/xlog>
### [`ocamlPackages.systemd-ml`](./pkgs/ocaml/systemd-ml)
libsystemd implementation in native ocaml: <https://git.lain.faith/haskal/systemd-ml>
### [`ocamlPackages.ocaml-manual`](./pkgs/ocaml/ocaml-manual)
the ocaml html docs package from opam
### [`python312Packages.feedvalidator` or `feedvalidator`](./pkgs/python/feedvalidator)
the W3C atom/RSS feed validator library, <https://github.com/w3c/feedvalidator>
this package comes with an additional CLI bin, `feedvalidator`, which is a simple wrapper around the
library that enables CLI usage
usage
```
usage: feedvalidator [-h] [-b BASE] file
W3C feedvalidator
positional arguments:
file File to validate
options:
-h, --help show this help message and exit
-b BASE, --base BASE Base URL of document
```
Future work is planned to make this easier.
example
```bash
feedvalidator --base "https://my-base-url/atom.xml" path/to/atom.xml
```
### [`outer-wilds-text-adventure`](./pkgs/games/outer-wilds-text-adventure)
nix packaging for the Outer Wilds text adventure game. it should work by default on NixOS. if using
the nix package manager on a non-NixOS computer, you also need the following when using pipewire or
another ALSA plugin that lives in a separate package
```bash
export ALSA_PLUGIN_DIR=$(nix eval -f '<nixpkgs>' --raw pipewire)/lib/alsa-lib
```
### [`eta`](./pkgs/cmdline/eta)
Generic tool for monitoring ETA and progress of an arbitrary process.
<https://github.com/aioobe/eta>
### [`zbasefind`](./pkgs/rust/zbasefind)
Command line tool to guess the base address of a raw firmware binary (zoomer edition).
<https://git.lain.faith/haskal/zbasefind.git>
### [`cado-nfs`](./pkgs/crypto/cado-nfs)
Cado-NFS, An Implementation of the Number Field Sieve Algorithm
<https://gitlab.inria.fr/cado-nfs/cado-nfs>
## lib documentation
These utilities are provided by the dragnpkgs overlay
### [`fetchFromSteam`](./lib/fetchsteam)
a fetcher that downloads binaries from [Steam](https://store.steampowered.com/) using
@ -168,8 +229,7 @@ pkgs.fetchFromSteam {
### [`fetchb4`](./lib/fetchb4)
A fetcher that uses `b4` to download patchsets from <https://lore.kernel.org> so that they can be
applied in `boot.kernelPatches`
A fetcher that uses `b4` to download patchsets from <https://lore.kernel.org> so that they can be applied in `boot.kernelPatches`
Usage:
@ -184,8 +244,7 @@ pkgs.fetchb4 {
}
```
note that not specifying a version may make cause future invocations to return different output if a
newer version is sent to the thread
note that not specifying a version may make cause future invocations to return different output if a newer version is sent to the thread
### [`mkNginxServer`](./lib/dev-nginx)
@ -204,6 +263,24 @@ pkgs.mkNginxServer {
}
```
### [`gitSource`](./lib/git-source)
for development package nix files, computes the source set of files tracked by git at the given root
path
arguments:
- `root`: the root of the git repo, where `.git` is located
- `subdir`, optional: a subdirectory within the git repo. if provided, only files in this
subdirectory will go into the final source set
example:
```nix
stdenv.mkDerivation {
# ...
src = gitSource { root = ./.; };
}
```
### [`makeSquashFs`](./lib/make-squashfs)
builds a squashfs image from the given derivations
@ -221,412 +298,20 @@ makeSquashFs {
create a packaged nix distribution with the given packages in it for weird HPC systems. go read the
source to find out what it does; i don't recommend using this if you're not me
### [`lib.licenses.fyptl`](./lib/licenses/fyptl.nix)
The "Fuck You, Pirate This License" (FYPTL) is the author's version of a software non-license, which
explicitly does not grant any rights to use, modify, or redistribute a given piece of software, but
does disclaim warranty.
## nixos options documentation
documentation for nixos options provided by dragnpkgs
### [`dragnpkgs`](./flake.nix)
options for configuring dragnpkgs
### [`dragnpkgs.setFlakeRegistry`](./flake.nix) (`true`)
Set flake registry option pointing to self
### [`dragnpkgs.setNixPath`](./flake.nix) (`true`)
Set nix path entry pointing to self
### [`dragnpkgs.setNixpkgsFlakeAlias`](./flake.nix) (`true`)
Set flake registry entry for `nixpkgs` to self
### [`dragnpkgs.setTemplatesFlakeAlias`](./flake.nix) (`true`)
Set flake registry entry for `templates` to self
### [`dragnpkgs.possiblyCommitCrimes`](./flake.nix) (`false`)
Globally enable usage of packages marked as FYPTL. This installs a nix plugin, which is widely
considered to be a nix crime, and it also might be an actual crime to use these packages depending
on you jurisdiction. Use at your own risk
### [`services.ghidra-server`](./modules/ghidra-server)
the shared project server for [ghidra](https://github.com/NationalSecurityAgency/ghidra)
example usage:
```nix
services.ghidra-server = {
enable = true;
host = "your.domain.or.ip";
};
```
##### development notes
the module does the following:
- sets up unix permissions on the ghidra repositories location that allows anyone in the `ghidra`
group to run `ghidra-svrAdmin` to perform admin tasks
- only supports basic username/password authentication for the time being
- parses the classpath file for the ghidra server which is normally read by the launcher, and uses
it to launch the server directly, without using the launcher. this was done because the launcher
was doing several things that were unwanted / could be better handled by systemd and journald, and
it was complicated to turn them off. this also allows us to customize the jvm args more easily
- provides a log4j configuration that causes all logs to be sent to the system journal. this
effectively disables any ghidra-server-specific logfile management
- sets the most basic isolation parameters (`PrivateTmp=true` and `NoNewPrivileges=true`), but more
work could be done to secure the ghidra server service
#### `services.ghidra-server.enable`
enables the ghidra server service
#### `services.ghidra-server.enableAdminCli` (`true`)
adds a system package for the CLI tool `ghidra-svrAdmin`, which allows anyone in the `ghidra` group
to administer the server (this corresponds to the `server/svrAdmin` tool in the stock ghidra
distribution)
#### `services.ghidra-server.{package, jdkPackage}` (`ghidra_headless`, `openjdk21_headless`)
allows overriding the ghidra package and jdk package used for the server
#### `services.ghidra-server.host`
the server hostname or IP; this is typically required (by java RMI) for correct operation
#### `services.ghidra-server.basePort` (`13100`)
the server will use 3 consecutive TCP ports starting from this port
#### `services.ghidra-server.directory` (`ghidra-server`)
the root directory for server files, as a subdirectory of `/var/lib`. this is needed because this
option is passed to systemd `StateDirectory=`
#### `services.ghidra-server.{user,group}` (`ghidra`)
the service user and group
### [`programs.ghidra`](./modules/ghidra-client/default.nix)
like upstream, but patches an issue with loading python packages in the ghidra debug feature
additionally, provides a way to specify extensions
#### `programs.ghidra.extensions`
Ghidra extensions to be included in the installation.
example:
```
[ (ps: with ps; [ binsync ]) ]
```
#### `programs.ghidra.binsync.enable`
enable binsync integration
### [`programs.idapro`](./modules/idapro/default.nix)
Enables IDA Pro in the system environment, with optional plugin config.
This also directs IDA Pro to use `~/.config/idapro` as its main user config directory, instead of
`~/.idapro`. Unfortunately, as of IDA Pro 9.2, `~/.idapro` still gets created, though it will be
empty.
#### `programs.idapro.enable`
Whether to enable IDA Pro
#### `programs.idapro.package`
The IDA Pro package to use
#### `programs.idapro.binsync.enable`
Enables binsync integration with IDA Pro
### [`environment.machineInfo`](./modules/machine-info/default.nix)
provides options to customize the `/etc/machine-info` file on a NixOS system. See the module itself
and <https://www.freedesktop.org/software/systemd/man/latest/machine-info.html> for more info
### [`services.satisfactory`](./modules/satisfactory-dedicated-server/default.nix)
The dedicated server for the game [Satisfactory](https://satisfactorygame.com)
This module provides the needed runtime environment for the dedicated server to run on NixOS, as
well as settings which can be automatically applied to provision the server on the first start (eg
server name, admin password). This provisioning needs to be done at runtime, due to the way the
server works, but it will be performed securely, before the server is exposed to the network for the
first time. This means you can safely deploy the server to the public internet without worrying
about exposing the "unclaimed" initial server mode, where any user could gain full privileges.
##### development notes
this module does the following:
- sets up `satisfactory.service` with some systemd isolation options and
notably, a private mount namespace in which the nix store path for the server
is mounted together with some overmounts for read-write directories within
the installation. this allows the software to "write to its own install
directory" which is required for operation. the real location of the written
files is in `/var/lib/satisfactory`
- if certs are provided, the systemd credentials mechanism is used to make them
available to the server process. another bind overmount is used to put the
credentials dir in the place that the server binary expects. additionally,
`satisfactory-restart-certs.service` is configured to restart the dedicated
server whenever the cert is renewed
- when the first-run options are specified,
`satisfactory-first-time-setup.service` is configured as a dependency with a
condition on the data file the server uses to store its settings. if the file
exists, the first-run setup is skipped. in this service,
`PrivateNetwork=true` is used to isolate the service from the network while a
bash script executes HTTP API calls to perform the requested setup. once this
is done, the server is shut down and execution will proceed to the main
`satisfactory.service`
this is mostly still in line with [a blog post i wrote on the
topic](https://blog.awoo.systems/posts/2024-01-12-going-win32-scale-packaging-the-satisfactory-dedicated-server-on-nixos)
but there have been some changes since then that are not reflected in the post
#### `services.satisfactory.enable`
enables the satisfactory dedicated server service
#### `services.satisfactory.package` (`pkgs.satisfactory-dedicated-server`)
the package to use for the service
#### `services.satisfactory.directory` (`"/var/lib/satisfactory"`)
Directory where Satisfactory Dedicated Server data will be stored
#### `services.satisfactory.{user,group}` (`"satisfactory"`)
User account and group under which Satisfactory Dedicated Server runs
#### `services.satisfactory.useACMEHost` (`null`)
If set, the server will use the ACME-provided TLS certificate for the given host.
Note that this module does not actually provision the specified certificate; you must use additional
config (e.g., `services.nginx.virtualHosts.<name>.enableACME = true`) to provision the certificate
using a supported ACME method.
#### `services.satisfactory.port` (`7777`)
Server port number (TCP/UDP)
This corresponds to the `-Port` command line option.
#### `services.satisfactory.reliablePort` (`8888`)
Server reliable port number
This corresponds to the `-ReliablePort` command line option.
#### `services.satisfactory.externalReliablePort` (`null`)
Server reliable port number as seen outside NAT.
This corresponds to the `-ExternalReliablePort` command line option.
#### `services.satisfactory.disableSeasonalEvents` (`false`)
Whether to run the server with seasonal events disabled.
This corresponds to the `-DisableSeasonalEvents` command line option.
#### `services.satisfactory.extraIniOptions` (`{}`)
Run the server with additional ini configuration values.
This is a nested attribute set of values.
- The top level attribute specifies the ini file containing the value to set (i.e., the
first component of the `-ini` command line option), for example `Game` or `Engine`.
- The secondary level attribute specifies the ini file category, without brackets,
for example `/Script/Engine.GameSession`.
- The final level attribute specifies the option name to set, for example
`MaxPlayers`. The value of the attribute is the value to set on the command line.
This corresponds to the `-ini` command line option.
#### `services.satisfactory.initialSettings`
Settings to apply to the server via the server API on the first run.
#### `services.satisfactory.initialSettings.serverName` (`null`)
The name of the server.
If this is provided, `adminPasswordFile` must also be set.
#### `services.satisfactory.initialSettings.adminPasswordFile` (`null`)
Path to a file containing the initial admin password.
If this is provided, `serverName` must also be set.
#### `services.satisfactory.initialSettings.clientPasswordFile` (`null`)
Path to a file containing the initial client password. If not set, the server will
not be configured with a client password and will be accessible to any client.
### [`hardware.wirelessRegulatoryDomain`](./modules/regdom/default.nix)
The wireless regulatory domain to set in the kernel `cfg80211` module. This defaults to `"00"`
(international), but more bands (such as 6GHz, on supported hardware) can be enabled by setting this
to the jurisdiction in which the machine is located, for example `"US"`.
## packages documentation
### [`ghidra`](./pkgs/reverse-engineering/ghidra/build.nix)
a version of ghidra that uses a split derivation, `lib` contains the core ghidra distribution, `doc`
contains all the documentation elements, and `out` contains the bin folder, icons, and desktop file.
only `out` has a dependency on the build jdk, so `lib` and `doc` can be used with reduced closure
size
### [`ghidra_headless`](./pkgs/reverse-engineering/ghidra/build.nix)
a variant of ghidra which does not have a dependency on any jdk, intended to reduce closure size for
server operation with a headless jdk (in particular, the ghidra-server nixos module uses
`ghidra_headless` with `openjdk21_headless` by default
this is equivalent to the `lib` output of the split `ghidra` package
### [`ghidra-extensions`](./pkgs/reverse-engineering/ghidra/extensions)
like upstream, but contains additional extensions:
- `binsync-ghidra`: the binsync `ghidra_scripts` installation packaged as an extension, so it can be
installed at the system level
### [`ocamlPackages.ppx_unicode`](./pkgs/ocaml/ppx_unicode)
opinionated ppx for string literals: <https://git.lain.faith/haskal/ppx_unicode>
### [`ocamlPackages.xlog`](./pkgs/ocaml/xlog)
logging for cats, in ocaml: <https://git.lain.faith/haskal/xlog>
### [`ocamlPackages.systemd-ml`](./pkgs/ocaml/systemd-ml)
libsystemd implementation in native ocaml: <https://git.lain.faith/haskal/systemd-ml>
### [`ocamlPackages.ocaml-manual`](./pkgs/ocaml/ocaml-manual)
the ocaml html docs package from opam
### [`ocamlPackages.patdiff-bin`](./pkgs/ocaml/patdiff-bin)
a repackaged version of `ocamlPackages.patdiff` with a reduced closure size
### [`python312Packages.feedvalidator` or `feedvalidator`](./pkgs/python/feedvalidator)
the W3C atom/RSS feed validator library, <https://github.com/w3c/feedvalidator>
this package comes with an additional CLI bin, `feedvalidator`, which is a simple wrapper around the
library that enables CLI usage
usage
```
usage: feedvalidator [-h] [-b BASE] file
W3C feedvalidator
positional arguments:
file File to validate
options:
-h, --help show this help message and exit
-b BASE, --base BASE Base URL of document
```
example
```bash
feedvalidator --base "https://my-base-url/atom.xml" path/to/atom.xml
```
### [`python312Packages.megacom` or `megacom`](./pkgs/python/megacom)
a python utility to access serial ports from the command line
### [`python311Packages.binsync` and `python311Packages.libbs`](./pkgs/reverse-engineering/binsync)
packaged latest versions of binsync and libbs from git
### [`outer-wilds-text-adventure`](./pkgs/games/outer-wilds-text-adventure)
nix packaging for the Outer Wilds text adventure game. it should work by default on NixOS. if using
the nix package manager on a non-NixOS computer, you also need the following when using pipewire or
another ALSA plugin that lives in a separate package
```bash
export ALSA_PLUGIN_DIR=$(nix eval -f '<nixpkgs>' --raw pipewire)/lib/alsa-lib
```
### [`satisfactory-dedicated-server`](./pkgs/games/satisfactory-dedicated-server)
The dedicated server for [Satisfactory](https://satisfactorygame.com), with packaging steps to make
it run correctly on NixOS. This must be used together with the NixOS module
(`services.satisfactory`), which sets up the environment needed for the server to execute.
See
[`services.satisfactory`](#services-satisfactory-modules-satisfactory-dedicated-server-default-nix)
for further info and development notes
### [`eta`](./pkgs/cmdline/eta)
Generic tool for monitoring ETA and progress of an arbitrary process.
<https://github.com/aioobe/eta>
### [`zbasefind`](./pkgs/rust/zbasefind)
Command line tool to guess the base address of a raw firmware binary (zoomer edition).
<https://git.lain.faith/haskal/zbasefind.git>
### [`cado-nfs`](./pkgs/crypto/cado-nfs)
Cado-NFS, An Implementation of the Number Field Sieve Algorithm
<https://gitlab.inria.fr/cado-nfs/cado-nfs>
### [`lix-plugins`](./pkgs/lix/lix-plugins)
A plugin module for lix which provides the flake pure eval bypass which can be enabled using the
dragnpkgs flake.
### [`zfs_2_3`](./pkgs/zfs/)
A version of ZFS with a patch for the `zed` userspace daemon to enable desktop notifications on ZFS
errors. This makes ZFS a bit more reasonable to run on GUI systems
### [`pympress`](./pkgs/python/pympress)
A version of [pympress](https://cimbali.github.io/pympress/) with a patch to fix the window icon on
KDE
### [`texliveDragonPackages.moloch`](./pkgs/tex/moloch)
A version of the [moloch](https://jolars.co/blog/2024-05-30-moloch/) beamer theme with [some
patches](https://git.lain.faith/haskal/moloch-dragon/) to make it easier to use with pympress and
fix an issue with appendix slide numbering
### [`idapro`](./pkgs/reverse-engineering/idapro9/default.nix)
Nix packaging for IDA Pro (see the file for details on how to use it)
## development
structure of this repo
- `default.nix`: the top level NixOS module, which can also be interpreted as a plain nix file
outside of NixOS for access to just the nixpkgs overlay. this contains all definitions for
packages, library functions, and NixOS modules
- `lib/`: library functions (ie functions that get added to the overlay) go here
- `modules/`: NixOS modules go here
- `pkgs/`: packages that get added to the overlay go here
- `support/`: WIP support tools (eg generating documentation)
## licensing
this repository is NOT licensed under a "standard" FOSS license. instead, it uses
[CC-BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en). this means, in
particular that commercial use is forbidden. if you are, for whatever reason, interested in using
this code commercially, please contact me

9
TODO.md
View File

@ -1,12 +1,7 @@
# TODO
## `ghidra`
- wrap/expose pyghidraRun so it works correctly
- export passthru python packages
- pyghidra packages
- type stubs
- lower priority: gdb, lldb
## upstream
- fix kicad desktop file name
## `ghidra-server`

33
flake.lock
View File

@ -1,26 +1,40 @@
{
"nodes": {
"lix-module": {
"lix": {
"flake": false,
"locked": {
"lastModified": 1756125859,
"narHash": "sha256-6a+PWILmqHCs9B5eIBLg6HSZ8jYweZpgOWO8FlyVwYI=",
"rev": "d3292125035b04df00d01549a26e948631fabe1e",
"lastModified": 1737234286,
"narHash": "sha256-CCKIAE84dzkrnlxJCKFyffAxP3yfsOAbdvydUGqq24g=",
"rev": "2837da71ec1588c1187d2e554719b15904a46c8b",
"type": "tarball",
"url": "https://git.lix.systems/api/v1/repos/lix-project/nixos-module/archive/d3292125035b04df00d01549a26e948631fabe1e.tar.gz?rev=d3292125035b04df00d01549a26e948631fabe1e"
"url": "https://git.lix.systems/api/v1/repos/lix-project/lix/archive/2837da71ec1588c1187d2e554719b15904a46c8b.tar.gz?rev=2837da71ec1588c1187d2e554719b15904a46c8b"
},
"original": {
"type": "tarball",
"url": "https://git.lix.systems/lix-project/nixos-module/archive/2.93.3-2.tar.gz"
"url": "https://git.lix.systems/lix-project/lix/archive/2.92.0.tar.gz"
}
},
"lix-module": {
"flake": false,
"locked": {
"lastModified": 1742943028,
"narHash": "sha256-fprwZKE1uMzO9tiWWOrmLWBW3GPkMayQfb0xOvVFIno=",
"rev": "868d97695bab9d21f6070b03957bcace249fbe3c",
"type": "tarball",
"url": "https://git.lix.systems/api/v1/repos/lix-project/nixos-module/archive/868d97695bab9d21f6070b03957bcace249fbe3c.tar.gz?rev=868d97695bab9d21f6070b03957bcace249fbe3c"
},
"original": {
"type": "tarball",
"url": "https://git.lix.systems/lix-project/nixos-module/archive/2.92.0-3.tar.gz"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1757745802,
"narHash": "sha256-hLEO2TPj55KcUFUU1vgtHE9UEIOjRcH/4QbmfHNF820=",
"lastModified": 1744932701,
"narHash": "sha256-fusHbZCyv126cyArUwwKrLdCkgVAIaa/fQJYFlCEqiU=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "c23193b943c6c689d70ee98ce3128239ed9e32d1",
"rev": "b024ced1aac25639f8ca8fdfc2f8c4fbd66c48ef",
"type": "github"
},
"original": {
@ -32,6 +46,7 @@
},
"root": {
"inputs": {
"lix": "lix",
"lix-module": "lix-module",
"nixpkgs": "nixpkgs"
}

136
flake.nix
View File

@ -5,22 +5,22 @@
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
lix-module = {
url = "https://git.lix.systems/lix-project/nixos-module/archive/2.93.3-2.tar.gz";
url = "https://git.lix.systems/lix-project/nixos-module/archive/2.92.0-3.tar.gz";
flake = false;
};
lix = {
url = "https://git.lix.systems/lix-project/lix/archive/2.92.0.tar.gz";
flake = false;
};
};
outputs = { self, nixpkgs, lix-module }:
outputs = { self, nixpkgs, lix, lix-module }:
let
overlays = [
(import ./overlay.nix)
(import "${lix-module}/overlay.nix" { lix = null; })
(import "${lix-module}/overlay.nix" { inherit lix; })
];
forAllSystems = nixpkgs.lib.genAttrs nixpkgs.lib.systems.flakeExposed;
libVersionInfoOverlay = import "${nixpkgs}/lib/flake-version-info.nix" nixpkgs;
# this is taken from upstream. if upstream changes, the code here needs to be updated to match
addLibVersionInfo = lib: lib.extend libVersionInfoOverlay;
lib-base = addLibVersionInfo (import "${nixpkgs}/lib");
in {
# we don't just use nix.registry.whatever.flake = self
# the reason for this is to be able to handle a flake.lock containing an entry for this
@ -41,41 +41,10 @@
# the nix path entry for self
meta.path-entry = "dragnpkgs-unstable=flake:dragnpkgs-unstable";
lib = (lib-base.extend (import ./lib/overlay.nix)).extend (final: prev: {
# initializes regular upstream nixpkgs with the given arguments
nixpkgs-custom = { system, ... } @ args: (
(import "${nixpkgs}" args).extend (final: prev: {
lib = addLibVersionInfo prev.lib;
})
);
lib = nixpkgs.lib.extend (final: prev: {
forAllSystems = final.genAttrs final.systems.flakeExposed;
# initializes dragnpkgs with its overlays and default config using the given arguments
dragnpkgs-custom = { system, ... } @ args: let
unsafeConf = if builtins.hasAttr "extraBuiltins" builtins then (
let conf = builtins.extraBuiltins; in
if builtins.isAttrs conf then conf else {}
) else {};
possiblyCommitCrimes =
if
builtins.hasAttr "dragnpkgs" unsafeConf &&
builtins.isAttrs unsafeConf.dragnpkgs &&
builtins.hasAttr "possiblyCommitCrimes" unsafeConf.dragnpkgs &&
builtins.isBool unsafeConf.dragnpkgs.possiblyCommitCrimes
then
unsafeConf.dragnpkgs.possiblyCommitCrimes
else
false;
in
final.nixpkgs-custom (args // {
overlays = overlays ++ (args.overlays or []);
config = (args.config or {}) // {
allowlistedLicenses = (final.optionals
possiblyCommitCrimes
[ final.licenses.fyptl ]) ++ (args.config.allowlistedLicenses or []);
};
});
nixos = import "${nixpkgs}/nixos/lib" { lib = final; };
licenses = prev.licenses // { fyptl = import ./lib/licenses/fyptl.nix; };
nixosSystem = args:
import "${nixpkgs}/nixos/lib/eval-config.nix" (
@ -185,19 +154,18 @@
lib.mkForce "/etc/nix/extra-builtins.nix"
);
config.environment.etc = lib.mkIf config.dragnpkgs.possiblyCommitCrimes {
"nix/extra-builtins.nix".text =
let
possiblyCommitCrimes =
lib.boolToString config.dragnpkgs.possiblyCommitCrimes;
in ''
{ ... }: {
dragnpkgs = {
possiblyCommitCrimes = ${possiblyCommitCrimes};
};
}
'';
};
config.environment.etc."nix/extra-builtins.nix".text =
lib.mkIf config.dragnpkgs.possiblyCommitCrimes (
let
possiblyCommitCrimes =
lib.boolToString config.dragnpkgs.possiblyCommitCrimes;
in ''
{ ... }: {
dragnpkgs = {
possiblyCommitCrimes = ${possiblyCommitCrimes};
};
}
'');
})
(import ./module.nix)
@ -205,40 +173,48 @@
} // builtins.removeAttrs args [ "modules" ]
);
mkFlake = flakeDef:
let
rewritePerSystem = sectionDef: (forAllSystems (system:
builtins.mapAttrs (name: value:
if final.isDerivation value then
value
else
self.legacyPackages.${system}.callPackage value {}
) sectionDef
));
in
builtins.mapAttrs (name: value:
if name == "packages" || name == "legacyPackages" || name == "devShells" ||
name == "apps" then
rewritePerSystem value
else
value
) flakeDef;
mkFlake = import ./lib/mkflake/default.nix {
pkgs = system: self.legacyPackages.${system};
lib = final;
};
});
legacyPackages = forAllSystems (system:
self.lib.dragnpkgs-custom { inherit system; }
legacyPackages = self.lib.forAllSystems (system:
let
unsafeConf = if builtins.hasAttr "extraBuiltins" builtins then (
let conf = builtins.extraBuiltins; in
if builtins.isAttrs conf then conf else {}
) else {};
possiblyCommitCrimes =
if
builtins.hasAttr "dragnpkgs" unsafeConf &&
builtins.isAttrs unsafeConf.dragnpkgs &&
builtins.hasAttr "possiblyCommitCrimes" unsafeConf.dragnpkgs &&
builtins.isBool unsafeConf.dragnpkgs.possiblyCommitCrimes
then
unsafeConf.dragnpkgs.possiblyCommitCrimes
else
false;
in
nixpkgs.legacyPackages.${system}.appendOverlays (overlays ++
[(final: prev: {
stdenv = prev.stdenv.override {
config = prev.config // {
allowlistedLicenses = final.lib.optionals
possiblyCommitCrimes
[ final.lib.licenses.fyptl ];
};
};
})])
);
nixosModules = nixpkgs.nixosModules;
templates = {
default = {
path = ./templates/default;
description = "A very basic flake (with dragnpkgs)";
};
beamer = {
path = ./templates/beamer;
description = "A very basic presentation with Beamer";
};
};
defaultTemplate = self.templates.default;

14
lib/git-source/default.nix Normal file
View File

@ -0,0 +1,14 @@
{ lib }: { root, subdir ? null }:
let
fs = lib.fileset;
sourceFiles = fs.difference
(fs.gitTracked root)
(fs.fileFilter (file: file.hasExt "nix") root);
finalSourceFiles =
if subdir == null then
sourceFiles
else
fs.intersection sourceFiles subdir;
finalRoot = if subdir == null then root else subdir;
in
fs.toSource { root = finalRoot; fileset = finalSourceFiles; }

28
lib/mkflake/default.nix Normal file
View File

@ -0,0 +1,28 @@
{ pkgs, lib }:
flakeDef:
let
rewritePerSystem = final: sectionDef:
lib.forAllSystems (system:
builtins.mapAttrs (name: value:
if lib.isDerivation value then
value
else
(pkgs system).callPackage value { self = (final system); }
) sectionDef
);
rewriteAttr = final: name: value:
let
final_self = system: (builtins.mapAttrs (aname: avalue:
if aname == "packages" || aname == "legacyPackages" || aname == "devShells" then
avalue.${system}
else
avalue
) final);
in
if name == "packages" || name == "legacyPackages" || name == "devShells" then
rewritePerSystem final_self value
else
value;
self = builtins.mapAttrs (rewriteAttr self) flakeDef;
in
self

3
lib/overlay.nix
View File

@ -1,3 +0,0 @@
final: prev: {
licenses = prev.licenses // { fyptl = import ./licenses/fyptl.nix; };
}

10
module.nix
View File

@ -1,18 +1,16 @@
{ ... }: {
imports = [
./modules/ghidra-client
./modules/ghidra-server
./modules/idapro
./modules/machine-info
./modules/regdom
./modules/satisfactory-dedicated-server
./modules/machine-info
];
# set some nix settings defaults
config.nix.settings = {
repl-overlays = [ ./repl-overlay.nix ];
experimental-features = "nix-command flakes pipe-operator";
temp-dir = "/var/tmp";
experimental-features = "nix-command flakes repl-flake";
substituters = [ "https://cache.lix.systems" ];
trusted-public-keys = [ "cache.lix.systems:aBnZUw8zA7H35Cz2RyKFVs3H4PlGTLawyY5KRbvJR8o=" ];
# we're disabling the default flake registry because i don't like it
flake-registry = "";

73
modules/ghidra-client/default.nix
View File

@ -1,73 +0,0 @@
{
config,
lib,
pkgs,
...
}:
let
cfg = config.programs.ghidra;
isSplit = lib.elem "lib" cfg.package.outputs;
libOutput = if isSplit then cfg.package.lib else cfg.package;
packageWithExts = cfg.package.withExtensions
(p: lib.concatMap (pl: pl p) cfg.extensions);
in
{
disabledModules = [ "programs/ghidra.nix" ];
options.programs.ghidra = {
enable = lib.mkEnableOption "Ghidra, a software reverse engineering (SRE) suite of tools";
gdb = lib.mkOption {
default = true;
type = lib.types.bool;
description = ''
Whether to add to gdbinit the python modules required to make Ghidra's debugger work.
'';
};
package = lib.mkPackageOption pkgs "ghidra" { example = "ghidra_headless"; };
extensions = lib.mkOption {
type = with lib.types; listOf (functionTo (listOf package));
default = [];
description = ''
Ghidra extensions to be included in the installation.
'';
example = lib.literalExpression "[ (ps: with ps; [ my_extension ]) ]";
};
binsync = {
enable = lib.mkEnableOption "Ghidra binsync integration";
};
};
config = lib.mkIf cfg.enable {
programs.ghidra.extensions = lib.mkIf (cfg.binsync.enable) [
(ps: [ ps.binsync ])
];
environment = {
systemPackages = [
packageWithExts
];
etc = lib.mkIf cfg.gdb {
"gdb/gdbinit.d/ghidra-modules.gdb".text = with pkgs.python3.pkgs; ''
python
import sys
[sys.path.append(p) for p in "${
(makePythonPath [
psutil
protobuf
])
}".split(":")]
sys.path.append("${libOutput}/lib/ghidra/Ghidra/Debug/Debugger-agent-gdb/pypkg/src")
sys.path.append("${libOutput}/lib/ghidra/Ghidra/Debug/Debugger-rmi-trace/pypkg/src")
end
'';
};
};
};
}

44
modules/idapro/default.nix
View File

@ -1,44 +0,0 @@
{
config,
lib,
pkgs,
...
}:
let
cfg = config.programs.idapro;
binsyncPkg = pkgs.python311.pkgs.binsync;
binsyncPath = "${pkgs.python311.pkgs.binsync}/${pkgs.python311.sitePackages}";
idaproConfigured = cfg.package.override {
pythonDeps = lib.optionals cfg.binsync.enable [binsyncPkg];
plugins = lib.optionals cfg.binsync.enable [
(pkgs.runCommand "binsync-ida" {} ''
mkdir -p $out/plugins
cp ${binsyncPath}/binsync/binsync_plugin.py $out/plugins
'')
];
};
in
{
options.programs.idapro = {
enable = lib.mkEnableOption "IDA Pro";
package = lib.mkPackageOption pkgs "idapro" {
example = lib.literalExpression "idapro.override { ... }";
};
binsync = {
enable = lib.mkEnableOption "IDA binsync integration";
};
};
config = lib.mkIf cfg.enable {
environment = {
systemPackages = [
idaproConfigured
];
sessionVariables.IDAUSR = "$HOME/.config/idapro";
};
};
}

208
modules/machine-info/default.nix
View File

@ -1,119 +1,119 @@
{ config, pkgs, lib, ... }: with lib; {
options.environment.machineInfo = mkOption {
description = lib.mdDoc ''
Machine metadata, including stylized hostname, computer icon, etc.
options.environment.machineInfo = mkOption {
description = lib.mdDoc ''
Machine metadata, including stylized hostname, computer icon, etc.
This module controls the options written to `/etc/machine-info`. For more
information, see [the freedesktop documentation][1].
This module controls the options written to `/etc/machine-info`. For more
information, see [the freedesktop documentation][1].
[1]: https://www.freedesktop.org/software/systemd/man/machine-info.html
'';
default = {};
type = types.submodule { options = {
[1]: https://www.freedesktop.org/software/systemd/man/machine-info.html
'';
default = {};
type = types.submodule { options = {
prettyHostname = mkOption {
description = lib.mdDoc ''
A pretty, human-readable hostname for this machine, potentially including
spaces, unicode, and emoji. If unset, this falls back to the network hostname
set in `networking.hostName`.
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"Jade's Laptop 💎\"";
};
prettyHostname = mkOption {
description = lib.mdDoc ''
A pretty, human-readable hostname for this machine, potentially including
spaces, unicode, and emoji. If unset, this falls back to the network hostname
set in `networking.hostName`.
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"Jade's Laptop 💎\"";
};
iconName = mkOption {
description = lib.mdDoc ''
An XDG icon which should be associated with this machine. Some common choices
include: `"computer"`, `"phone"`, but a complete list of icons can be found in
the [XDG Icon Naming Spec][1].
iconName = mkOption {
description = lib.mdDoc ''
An XDG icon which should be associated with this machine. Some common choices
include: `"computer"`, `"phone"`, but a complete list of icons can be found in
the [XDG Icon Naming Spec][1].
If left unset, applications will typically default to `"computer"`.
If left unset, applications will typically default to `"computer"`.
[1]: https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"computer\"";
};
[1]: https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"computer\"";
};
chassis = mkOption {
description = lib.mdDoc ''
The type of chassis this machine resides within. This is typically detected
automatically, but can be manually overridden here.
'';
type = with types; nullOr (enum [
"desktop"
"laptop"
"convertible"
"server"
"tablet"
"handset"
"watch"
"embedded"
"vm"
"container"
]);
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"server\"";
};
chassis = mkOption {
description = lib.mdDoc ''
The type of chassis this machine resides within. This is typically detected
automatically, but can be manually overridden here.
'';
type = with types; nullOr (enum [
"desktop"
"laptop"
"convertible"
"server"
"tablet"
"handset"
"watch"
"embedded"
"vm"
"container"
]);
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"server\"";
};
deployment = mkOption {
description = lib.mdDoc ''
If this machine is part of a deployment environment / pipeline, this option can
be used to specify what environment/pipeline stage it manages.
deployment = mkOption {
description = lib.mdDoc ''
If this machine is part of a deployment environment / pipeline, this option can
be used to specify what environment/pipeline stage it manages.
Typically, but not necessarily, set to something like `"development"`,
`"integration"`, `"staging"`, or `"production"`.
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"production\"";
};
Typically, but not necessarily, set to something like `"development"`,
`"integration"`, `"staging"`, or `"production"`.
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"production\"";
};
location = mkOption {
description = lib.mdDoc ''
A human-readable short description of the location of this machine.
location = mkOption {
description = lib.mdDoc ''
A human-readable short description of the location of this machine.
This can be set to whatever has the most meaning for you, for example "Living
Room", "Left Rack, 2nd Shelf", or "Parishville, NY".
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"Bedroom\"";
};
This can be set to whatever has the most meaning for you, for example "Living
Room", "Left Rack, 2nd Shelf", or "Parishville, NY".
'';
type = with types; nullOr str;
default = null;
defaultText = literalExpression "null";
example = literalExpression "\"Bedroom\"";
};
extraOptions = mkOption {
description = lib.mdDoc ''
Extra variables to put in `/etc/machine-info`
'';
type = with types; attrsOf str;
default = {};
defaultText = literalExpression "{ }";
example = literalExpression "{ HARDWARE_VENDOR = \"Intel Corp.\" }";
};
extraOptions = mkOption {
description = lib.mdDoc ''
Extra variables to put in `/etc/machine-info`
'';
type = with types; attrsOf str;
default = {};
defaultText = literalExpression "{ }";
example = literalExpression "{ HARDWARE_VENDOR = \"Intel Corp.\" }";
};
};};
};
};};
};
config.environment.etc.machine-info =
with config.environment.machineInfo;
let
rawShellVars = {
PRETTY_HOSTNAME = prettyHostname;
ICON_NAME = iconName;
CHASSIS = chassis;
DEPLOYMENT = deployment;
LOCATION = location;
} // extraOptions;
nonNullShellVars = attrsets.filterAttrs (k: v: v != null) rawShellVars;
in rec {
text = strings.toShellVars nonNullShellVars;
enable = builtins.stringLength text > 0;
};
}
config.environment.etc.machine-info =
with config.environment.machineInfo;
let
rawShellVars = {
PRETTY_HOSTNAME = prettyHostname;
ICON_NAME = iconName;
CHASSIS = chassis;
DEPLOYMENT = deployment;
LOCATION = location;
} // extraOptions;
nonNullShellVars = attrsets.filterAttrs (k: v: v != null) rawShellVars;
in rec {
text = strings.toShellVars nonNullShellVars;
enable = builtins.stringLength text > 0;
};
}

421
modules/satisfactory-dedicated-server/default.nix
View File

@ -1,421 +0,0 @@
{ config, lib, pkgs, ... }:
let
cfg = config.services.satisfactory;
in {
options.services.satisfactory = with lib; {
enable = mkEnableOption "satisfactory";
package = mkPackageOption pkgs "satisfactory-dedicated-server" {};
directory = mkOption {
description = ''
Directory where Satisfactory Dedicated Server data will be stored
'';
default = "/var/lib/satisfactory";
type = types.str;
example = literalExpression "\"/data/games/satisfactory\"";
};
user = mkOption {
description = "User account under which Satisfactory Dedicated Server runs.";
default = "satisfactory";
type = types.str;
example = literalExpression "\"satisfactory2\"";
};
group = mkOption {
description = "Group under which Satisfactory Dedicated Server runs.";
default = "satisfactory";
type = types.str;
example = literalExpression "\"satisfactory2\"";
};
useACMEHost = mkOption {
description = ''
If set, the server will use the ACME-provided TLS certificate for the given host.
Note that this module does not actually provision the specified certificate; you must
use additional config (e.g., `services.nginx.virtualHosts.<name>.enableACME = true`) to
provision the certificate using a supported ACME method.
'';
default = null;
type = types.nullOr types.str;
example = literalExpression "\"myserver.example\"";
};
port = mkOption {
description = ''
Server port number (TCP/UDP)
This corresponds to the `-Port` command line option.
'';
default = 7777;
type = types.port;
example = literalExpression "7778";
};
reliablePort = mkOption {
description = ''
Server reliable port number
This corresponds to the `-ReliablePort` command line option.
'';
default = 8888;
type = types.port;
example = literalExpression "8889";
};
externalReliablePort = mkOption {
description = ''
Server reliable port number as seen outside NAT.
This corresponds to the `-ExternalReliablePort` command line option.
'';
default = null;
type = types.nullOr types.port;
example = literalExpression "12345";
};
disableSeasonalEvents = mkOption {
description = ''
Whether to run the server with seasonal events disabled.
This corresponds to the `-DisableSeasonalEvents` command line option.
'';
default = false;
type = types.bool;
example = literalExpression "true";
};
extraIniOptions = mkOption {
description = ''
Run the server with additional ini configuration values.
This is a nested attribute set of values.
- The top level attribute specifies the ini file containing the value to set (i.e., the
first component of the `-ini` command line option), for example `Game` or `Engine`.
- The secondary level attribute specifies the ini file category, without brackets,
for example `/Script/Engine.GameSession`.
- The final level attribute specifies the option name to set, for example
`MaxPlayers`. The value of the attribute is the value to set on the command line.
This corresponds to the `-ini` command line option.
'';
default = {};
type = with types; attrsOf (attrsOf (attrsOf str));
example = literalExpression ''
{
Game."/Script/Engine.GameSession".MaxPlayers = "8";
}
'';
};
initialSettings = mkOption {
description = ''
Settings to apply to the server via the server API on the first run.
'';
type = types.submodule {
options = {
serverName = mkOption {
description = ''
The name of the server.
If this is provided, `adminPasswordFile` must also be set.
'';
type = with types; nullOr str;
default = null;
example = literalExpression "\"My Dedicated Server\"";
};
adminPasswordFile = mkOption {
description = ''
Path to a file containing the initial admin password.
If this is provided, `serverName` must also be set.
'';
type = with types; nullOr path;
default = null;
example = literalExpression "\"/var/lib/secrets/admin-password.txt\"";
};
clientPasswordFile = mkOption {
description = ''
Path to a file containing the initial client password. If not set, the server will
not be configured with a client password and will be accessible to any client.
'';
type = with types; nullOr path;
default = null;
example = literalExpression "\"/var/lib/secrets/client-password.txt\"";
};
};
};
};
};
config = lib.mkIf cfg.enable {
assertions = [
{
assertion = with cfg.initialSettings; (serverName == null) == (adminPasswordFile == null);
message = ''
When either of services.satisfactory.initialSettings.serverName or
services.satisfactory.initialSettings.adminPasswordFile are set, the other must also be
set. The dedicated server API requires configuring both options simultaneously.
'';
}
{
assertion = with cfg.initialSettings; (clientPasswordFile == null) || (serverName != null);
message = ''
Option services.satisfactory.initialSettings.clientPasswordFile is set, but there are
no options set for the initial server claim data (i.e., serverName and adminPasswordFile).
Setting a client password is not possible without executing a server claim.
'';
}
];
users.users."${cfg.user}" = {
isSystemUser = true;
home = cfg.directory;
group = cfg.group;
createHome = false;
};
users.groups."${cfg.group}" = {};
systemd.tmpfiles.settings."satisfactory" = let
default = {
inherit (cfg) user group;
mode = "0755";
};
in {
"${cfg.directory}".d = default;
"${cfg.directory}/saves".d = default;
"${cfg.directory}/settings".d = default;
"${cfg.directory}/settings/game".d = default;
"${cfg.directory}/settings/engine".d = default;
};
systemd.services = let
base_url = "https://127.0.0.1:${builtins.toString cfg.port}/api/v1/";
binary = "${cfg.directory}/server/Engine/Binaries/Linux/FactoryServer-Linux-Shipping";
ini_list = lib.flatten (
lib.mapAttrsToList (filename: fileOpts:
lib.mapAttrsToList (section: sectionOpts:
lib.mapAttrsToList (key: value:
" -ini:${filename}:[${section}]:${key}=${value}"
) sectionOpts
) fileOpts
) cfg.extraIniOptions
);
ini_args = lib.concatStringsSep " " ini_list;
port = with builtins;
"-Port=${toString cfg.port} -ReliablePort=${toString cfg.reliablePort}";
extport =
if cfg.externalReliablePort == null then
""
else
" -ExternalReliablePort=${builtins.toString cfg.externalReliablePort}";
seasonalEvts =
if cfg.disableSeasonalEvents then
" -DisableSeasonalEvents"
else
"";
args = "${port}${extport}${seasonalEvts}${ini_args}";
server_command = "${binary} FactoryGame ${args}";
doSetup = cfg.initialSettings.serverName != null;
commonConfig = {
after = ["network.target"] ++ lib.optionals (cfg.useACMEHost != null) [
"acme-finished-${cfg.useACMEHost}.target"
];
unitConfig = {
RequiresMountsFor = cfg.directory;
};
serviceConfig = {
Nice = "-5";
User = cfg.user;
Group = cfg.user;
WorkingDirectory = cfg.directory;
StandardOutput = "journal";
LoadCredential = lib.mkIf (cfg.useACMEHost != null) (let
certDir = config.security.acme.certs.${cfg.useACMEHost}.directory;
in [
"cert_chain.pem:${certDir}/fullchain.pem"
"private_key.pem:${certDir}/key.pem"
]);
ProtectSystem = true;
ProtectHome = true;
NoNewPrivileges = true;
# virtualize the file system to synthesize what is read only with what is dedicated server
# game state
PrivateTmp = true;
CacheDirectory = "satisfactory";
TemporaryFileSystem = [
"${cfg.directory}:ro"
];
BindReadOnlyPaths = [
"${cfg.package}/opt:${cfg.directory}/server"
];
BindPaths = [
"${cfg.directory}/saves:${cfg.directory}/.config/Epic"
"/var/cache/satisfactory:${cfg.directory}/server/FactoryGame/Intermediate"
"${cfg.directory}/settings/game:${cfg.directory}/server/FactoryGame/Saved"
"${cfg.directory}/settings/engine:${cfg.directory}/server/Engine/Saved"
] ++ lib.optionals (cfg.useACMEHost != null) [
"%d:${cfg.directory}/server/FactoryGame/Certificates"
];
Restart = "on-failure";
RestartSec = 60;
SuccessExitStatus = 143;
};
};
in {
"satisfactory" = lib.mkMerge [
commonConfig
{
description = "Satisfactory Dedicated Server";
wantedBy = [ "multi-user.target" ];
requires = lib.optionals doSetup ["satisfactory-first-time-setup.service"];
after = lib.optionals doSetup ["satisfactory-first-time-setup.service"];
serviceConfig = {
ExecStart = server_command;
};
}
];
"satisfactory-first-time-setup" = lib.mkIf doSetup (lib.mkMerge [
commonConfig
{
description = "Satisfactory Dedicated Server first-time setup";
path = with pkgs; [
curl
jq
];
unitConfig = {
ConditionPathExists =
"!${cfg.directory}/saves/FactoryGame/Saved/SaveGames/ServerSettings.${builtins.toString cfg.port}.sav";
};
serviceConfig = {
Type = "oneshot";
# isolate satisfactory during configuration
PrivateNetwork = true;
LoadCredential =
(lib.optionals (cfg.initialSettings.adminPasswordFile != null) [
"admin_password.txt:${cfg.initialSettings.adminPasswordFile}"
]) ++ (lib.optionals (cfg.initialSettings.clientPasswordFile != null) [
"client_password.txt:${cfg.initialSettings.clientPasswordFile}"
]);
};
script = ''
set -euo pipefail
set -m
echo Starting server...
${server_command} &
server_pid=$!
server_status=""
for i in {1..5}; do
server_status="$(curl -SsLk -XPOST -H "Content-Type: application/json" \
--data '{"function":"HealthCheck","data":{"clientCustomData":""}}' \
"${base_url}" | jq -r '.data.health' || true)"
if [ "$server_status" == "healthy" ]; then
break
fi
sleep 5
done
if [ "$server_status" != "healthy"; then
echo Server did not report healthy status in time
exit 1
fi
token="$(curl -SsLk -XPOST -H "Content-Type: application/json" \
--data '{"function":"PasswordlessLogin","data":{"MinimumPrivilegeLevel":"InitialAdmin"}}' \
"${base_url}" | jq -r '.data.authenticationToken')"
if [ "$token" == "null" ]; then
echo Server authentication failed
exit 2
fi
echo Executing server claim...
data="$(jq -n \
--arg "serverName" "${cfg.initialSettings.serverName}" \
--rawfile "password" "$CREDENTIALS_DIRECTORY/admin_password.txt" \
'{} |.function="ClaimServer" | .data.ServerName=$serverName | .data.AdminPassword=($password|rtrimstr("\n"))')"
new_token="$(curl -SsLk -XPOST -H "Content-Type: application/json" \
-H "Authorization: Bearer $token" \
--data "$data" \
"${base_url}" | jq -r '.data.authenticationToken')"
if [ "$new_token" == "null" ]; then
echo Server claim failed
exit 2
fi
token="$new_token"
if [ -f "$CREDENTIALS_DIRECTORY/client_password.txt" ]; then
echo Setting client password...
data="$(jq -n \
--rawfile "password" "$CREDENTIALS_DIRECTORY/client_password.txt" \
'{} |.function="SetClientPassword" | .data.Password=($password|rtrimstr("\n"))')"
result="$(curl -SsLk -XPOST -H "Content-Type: application/json" \
-H "Authorization: Bearer $token" \
--data "$data" \
"${base_url}" | jq -r '.data')"
if [ "$result" != "" ]; then
echo "Password set failed: $result"
exit 4
fi
fi
echo Setup complete
echo Stopping server...
kill -SIGTERM $server_pid
wait $server_pid
'';
}
]);
"satisfactory-restart-certs" = lib.mkIf (cfg.useACMEHost != null) {
description = "Restart Satisfactory Dedicated Server after cert provisioning";
wantedBy = ["acme-finished-${cfg.useACMEHost}.target"];
path = [config.systemd.package];
script = ''
systemctl try-restart satisfactory.service
'';
serviceConfig = {
Type = "simple";
};
};
};
};
}

37
overlay.nix
View File

@ -1,22 +1,25 @@
final: prev: {
lib = prev.lib.extend (import ./lib/overlay.nix);
lib = prev.lib.extend (lfinal: lprev: {
licenses = lprev.licenses // { fyptl = import ./lib/licenses/fyptl.nix; };
});
fetchFromSteam = prev.callPackage ./lib/fetchsteam {};
fetchb4 = prev.callPackage ./lib/fetchb4 {};
gitSource = prev.callPackage ./lib/git-source {};
makeSquashFs = prev.callPackage ./lib/make-squashfs {};
makeHpcDist = final.callPackage ./lib/make-hpc-dist {};
ghidra_headless = final.ghidra.lib;
# stuff that tracks upstream
ghidra = final.callPackage ./pkgs/reverse-engineering/ghidra/build.nix {
ghidra = final.callPackage ./pkgs/ghidra-xenia-v2/build.nix {
protobuf = final.protobuf_21;
};
ghidra-extensions = final.lib.recurseIntoAttrs (final.callPackage ./pkgs/reverse-engineering/ghidra/extensions.nix { });
ghidra-extensions = final.lib.recurseIntoAttrs (final.callPackage ./pkgs/ghidra-xenia-v2/extensions.nix { });
# end stuff that tracks upstream
idapro = final.callPackage ./pkgs/reverse-engineering/idapro9 {};
ocamlPackages = prev.ocamlPackages.overrideScope (ofinal: oprev: {
ppx_unicode = ofinal.callPackage ./pkgs/ocaml/ppx_unicode {};
@ -24,30 +27,18 @@ final: prev: {
systemd-ml = ofinal.callPackage ./pkgs/ocaml/systemd-ml {};
ocaml-manual = ofinal.callPackage ./pkgs/ocaml/ocaml-manual {};
patdiff-bin = ofinal.callPackage ./pkgs/ocaml/patdiff-bin {};
});
python312 = prev.python312.override {
packageOverrides = pfinal: pprev: {
feedvalidator = pfinal.callPackage ./pkgs/python/feedvalidator {};
megacom = pfinal.callPackage ./pkgs/python/megacom {};
};
};
python312Packages = prev.python312Packages.overrideScope (pfinal: pprev: {
feedvalidator = pfinal.callPackage ./pkgs/python/feedvalidator {};
megacom = pfinal.callPackage ./pkgs/python/megacom {};
});
# add to top level because it has a binary
feedvalidator = final.python312Packages.feedvalidator;
megacom = final.python312Packages.megacom;
python311 = prev.python311.override {
packageOverrides = pfinal: pprev: {
libbs = pfinal.callPackage ./pkgs/reverse-engineering/binsync/libbs.nix {};
binsync = pfinal.callPackage ./pkgs/reverse-engineering/binsync/binsync.nix {};
};
};
outer-wilds-text-adventure = prev.callPackage ./pkgs/games/outer-wilds-text-adventure {};
satisfactory-dedicated-server = prev.callPackage ./pkgs/games/satisfactory-dedicated-server {};
mkNginxServer = prev.callPackage ./lib/dev-nginx {};
@ -60,15 +51,11 @@ final: prev: {
lix-plugins = prev.callPackage ./pkgs/lix/lix-plugins {};
nix-plugins = builtins.throw "nix-plugins is not supported. see pkgs.lix-plugins";
zfs_2_3 = prev.zfs_2_3.overrideAttrs {
zfs_2_2 = prev.zfs_2_2.overrideAttrs {
patches = [ ./pkgs/zfs/0001-ZED-add-support-for-desktop-notifications-D-Bus.patch ];
};
pympress = prev.pympress.overrideDerivation (oldAttrs: {
patches = [ ./pkgs/python/pympress/0001-Fix-KDE-window-icon.patch ];
});
texliveDragonPackages = {
moloch = prev.callPackage ./pkgs/tex/moloch {};
};
}

43
pkgs/games/satisfactory-dedicated-server/default.nix
View File

@ -7,46 +7,45 @@
}:
let
appId = "1690800";
buildId = "19876517";
buildId = "15636842";
steamworks_sdk = fetchFromSteam {
name = "steamworks-sdk";
inherit appId;
depot = {
depotId = "1006";
manifestId = "5587033981095108078";
manifestId = "7138471031118904166";
};
hash = "sha256-CjrVpq5ztL6wTWIa63a/4xHM35DzgDR/O6qVf1YV5xw=";
hash = "sha256-OtPI1kAx6+9G09IEr2kYchyvxlPl3rzx/ai/xEVG4oM=";
};
server_dist = fetchFromSteam {
name = "satisfactory-dedicated-server";
inherit appId;
depot = {
depotId = "1690802";
manifestId = "7620210706575413121";
manifestId = "1910179703516567959";
};
hash = "sha256-jQbtHSBFCDcdycrDjIJBY4DGV7EgITvwv3k3+htZ7io=";
hash = "sha256-TxPegZFAwiAzuHgw9xLGr5sAP7KAVMMfPFYL7TRX1O0=";
};
in stdenv.mkDerivation {
pname = "satisfactory-dedicated-server";
version = "build-${buildId}";
src = server_dist;
buildInputs = [ steamworks_sdk ];
propagatedBuildInputs = [ SDL2 ];
dontConfigure = true;
dontBuild = true;
installPhase = ''
mkdir -p $out/opt
cp -r . $out/opt/.
cp -r ${steamworks_sdk}/linux64 $out/opt
mkdir -p $out
cp -r . $out/.
cp -r ${steamworks_sdk}/linux64 $out
mkdir -p $out/opt/FactoryGame/Intermediate
mkdir -p $out/opt/FactoryGame/Saved
mkdir -p $out/opt/FactoryGame/Certificates
mkdir -p $out/FactoryGame/Intermediate
mkdir -p $out/FactoryGame/Saved
mkdir -p $out/opt/Engine/Saved
rm $out/opt/FactoryServer.sh
rm $out/FactoryServer.sh
'';
dontStrip = true;
@ -57,23 +56,19 @@ in stdenv.mkDerivation {
preFixup = ''
echo patching binaries
chmod +x $out/opt/Engine/Binaries/Linux/FactoryServer-Linux-Shipping
chmod +x $out/Engine/Binaries/Linux/FactoryServer-Linux-Shipping
patchelf \
--add-needed ${SDL2}/lib/libSDL2-2.0.so.0 \
$out/opt/linux64/steamclient.so
patchelf --add-needed ${SDL2}/lib/libSDL2-2.0.so.0 \
$out/linux64/steamclient.so
patchelf \
--set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
--add-needed $out/opt/linux64/steamclient.so \
$out/opt/Engine/Binaries/Linux/FactoryServer-Linux-Shipping
patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
--add-needed $out/linux64/steamclient.so \
$out/Engine/Binaries/Linux/FactoryServer-Linux-Shipping
'';
meta = with lib; {
description = "Satisfactory Dedicated Server";
homepage = "https://www.satisfactorygame.com/";
license = licenses.unfree;
platforms = [ "x86_64-linux" ];
sourceProvenance = [ sourceTypes.binaryNativeCode ];
};
}

127
pkgs/reverse-engineering/ghidra/0001-Use-protobuf-gradle-plugin.patch → pkgs/ghidra-xenia-v2/0001-Use-protobuf-gradle-plugin.patch
View File

@ -1,13 +1,48 @@
diff --git a/Ghidra/Debug/Debugger-isf/build.gradle b/Ghidra/Debug/Debugger-isf/build.gradle
index 2db94ed67e..925f394cf0 100644
--- a/Ghidra/Debug/Debugger-isf/build.gradle
+++ b/Ghidra/Debug/Debugger-isf/build.gradle
@@ -18,11 +18,17 @@ apply from: "${rootProject.projectDir}/gradle/javaProject.gradle"
From ffb6777d58f068db7e14372415154cd93f77766e Mon Sep 17 00:00:00 2001
From: roblabla <unfiltered@roblab.la>
Date: Wed, 31 Jan 2024 13:19:55 +0100
Subject: [PATCH] Use com.google.protobuf:protobuf-gradle-plugin
---
Ghidra/Debug/Debugger-gadp/build.gradle | 7 +-
Ghidra/Debug/Debugger-isf/build.gradle | 8 +-
Ghidra/Debug/Debugger-rmi-trace/build.gradle | 14 +--
build.gradle | 6 ++
gradle/hasProtobuf.gradle | 94 --------------------
5 files changed, 26 insertions(+), 103 deletions(-)
diff --git a/Ghidra/Debug/Debugger-gadp/build.gradle b/Ghidra/Debug/Debugger-gadp/build.gradle
index 9e1c57faf..3a3242eb5 100644
--- a/Ghidra/Debug/Debugger-gadp/build.gradle
+++ b/Ghidra/Debug/Debugger-gadp/build.gradle
@@ -18,11 +18,16 @@ apply from: "${rootProject.projectDir}/gradle/javaProject.gradle"
apply from: "${rootProject.projectDir}/gradle/jacocoProject.gradle"
apply from: "${rootProject.projectDir}/gradle/javaTestProject.gradle"
apply from: "${rootProject.projectDir}/gradle/distributableGhidraModule.gradle"
-apply from: "${rootProject.projectDir}/gradle/hasProtobuf.gradle"
+apply plugin: 'com.google.protobuf'
apply plugin: 'eclipse'
eclipse.project.name = 'Debug Debugger-gadp'
+buildscript {
+ dependencies {
+ classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.18'
+ }
+}
dependencies {
api project(':Framework-AsyncComm')
api project(':Framework-Debugging')
diff --git a/Ghidra/Debug/Debugger-isf/build.gradle b/Ghidra/Debug/Debugger-isf/build.gradle
index d135294a0..785681ca2 100644
--- a/Ghidra/Debug/Debugger-isf/build.gradle
+++ b/Ghidra/Debug/Debugger-isf/build.gradle
@@ -18,11 +18,15 @@ apply from: "${rootProject.projectDir}/gradle/javaProject.gradle"
apply from: "${rootProject.projectDir}/gradle/jacocoProject.gradle"
apply from: "${rootProject.projectDir}/gradle/javaTestProject.gradle"
apply from: "${rootProject.projectDir}/gradle/distributableGhidraModule.gradle"
-apply from: "${rootProject.projectDir}/gradle/hasProtobuf.gradle"
-
+apply plugin: 'com.google.protobuf'
apply plugin: 'eclipse'
eclipse.project.name = 'Debug Debugger-isf'
@ -17,22 +52,21 @@ index 2db94ed67e..925f394cf0 100644
+ classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.18'
+ }
+}
+
dependencies {
api project(':ProposedUtils')
}
api project(':Framework-AsyncComm')
api project(':Framework-Debugging')
diff --git a/Ghidra/Debug/Debugger-rmi-trace/build.gradle b/Ghidra/Debug/Debugger-rmi-trace/build.gradle
index 4fa3b9a539..2663aeaeb0 100644
index 40fbc17ab..7517ffe6e 100644
--- a/Ghidra/Debug/Debugger-rmi-trace/build.gradle
+++ b/Ghidra/Debug/Debugger-rmi-trace/build.gradle
@@ -19,12 +19,17 @@ apply from: "${rootProject.projectDir}/gradle/helpProject.gradle"
@@ -18,12 +18,17 @@ apply from: "${rootProject.projectDir}/gradle/javaProject.gradle"
apply from: "${rootProject.projectDir}/gradle/jacocoProject.gradle"
apply from: "${rootProject.projectDir}/gradle/javaTestProject.gradle"
apply from: "${rootProject.projectDir}/gradle/distributableGhidraModule.gradle"
-apply from: "${rootProject.projectDir}/gradle/hasProtobuf.gradle"
apply from: "${rootProject.projectDir}/gradle/hasPythonPackage.gradle"
-
+apply plugin: 'com.google.protobuf'
apply from: "${rootProject.projectDir}/gradle/hasPythonPackage.gradle"
apply plugin: 'eclipse'
eclipse.project.name = 'Debug Debugger-rmi-trace'
@ -41,33 +75,30 @@ index 4fa3b9a539..2663aeaeb0 100644
+ classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.18'
+ }
+}
+
dependencies {
api project(':ProposedUtils')
api project(':Pty')
@@ -37,13 +42,10 @@ dependencies {
}
task configureGenerateProtoPy {
api project(':Debugger')
@@ -44,12 +49,9 @@ task generateProtoPy {
ext.outdir = file("build/generated/source/proto/main/py")
outputs.dir(outdir)
inputs.files(src)
- dependsOn(configurations.protocArtifact)
+ dependsOn(protobuf.generateProtoTasks.all())
- doLast {
doLast {
- def exe = configurations.protocArtifact.first()
- if (!isCurrentWindows()) {
- exe.setExecutable(true)
- }
+ doLast {
+ def exe = protobuf.tools.protoc.path
generateProtoPy.commandLine exe
generateProtoPy.args "--python_out=${generateProtoPy.outdir}"
generateProtoPy.args "--pyi_out=${generateProtoPy.stubsOutdir}"
exec {
commandLine exe, "--python_out=$outdir", "-I$srcdir"
args src
diff --git a/build.gradle b/build.gradle
index 159eb7dd7b..ef4add1ad8 100644
index b0c717fb1..5f56506a5 100644
--- a/build.gradle
+++ b/build.gradle
@@ -80,6 +80,12 @@ if (flatRepo.isDirectory()) {
mavenCentral()
@@ -74,6 +74,12 @@ if (flatRepo.isDirectory()) {
jcenter()
flatDir name: "flat", dirs:["$flatRepo"]
}
+ buildscript {
@ -80,20 +111,19 @@ index 159eb7dd7b..ef4add1ad8 100644
}
else {
diff --git a/gradle/hasProtobuf.gradle b/gradle/hasProtobuf.gradle
deleted file mode 100644
index a8c176bcbe..0000000000
index 23b4ce74b..e69de29bb 100644
--- a/gradle/hasProtobuf.gradle
+++ /dev/null
@@ -1,98 +0,0 @@
+++ b/gradle/hasProtobuf.gradle
@@ -1,94 +0,0 @@
-/* ###
- * IP: GHIDRA
- *
- * 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.
@ -146,22 +176,7 @@ index a8c176bcbe..0000000000
- }
-}*/
-
-task configureGenerateProto {
- dependsOn(configurations.protocArtifact)
-
- doLast {
- def exe = configurations.protocArtifact.first()
- if (!isCurrentWindows()) {
- exe.setExecutable(true)
- }
- generateProto.commandLine exe, "--java_out=${generateProto.outdir}", "-I${generateProto.srcdir}"
- generateProto.args generateProto.src
- }
-}
-
-// Can't use providers.exec, or else we see no output
-task generateProto(type:Exec) {
- dependsOn(configureGenerateProto)
-task generateProto {
- ext.srcdir = file("src/main/proto")
- ext.src = fileTree(srcdir) {
- include "**/*.proto"
@ -169,6 +184,17 @@ index a8c176bcbe..0000000000
- ext.outdir = file("build/generated/source/proto/main/java")
- outputs.dir(outdir)
- inputs.files(src)
- dependsOn(configurations.protocArtifact)
- doLast {
- def exe = configurations.protocArtifact.first()
- if (!isCurrentWindows()) {
- exe.setExecutable(true)
- }
- exec {
- commandLine exe, "--java_out=$outdir", "-I$srcdir"
- args src
- }
- }
-}
-
-tasks.compileJava.dependsOn(tasks.generateProto)
@ -183,3 +209,6 @@ index a8c176bcbe..0000000000
- }
-}
-zipSourceSubproject.dependsOn generateProto
--
2.42.0

0
pkgs/reverse-engineering/ghidra/0002-Load-nix-extensions.patch → pkgs/ghidra-xenia-v2/0002-Load-nix-extensions.patch
View File

0
pkgs/reverse-engineering/ghidra/0003-Remove-build-datestamp.patch → pkgs/ghidra-xenia-v2/0003-Remove-build-datestamp.patch
View File

64
pkgs/reverse-engineering/ghidra/build-extension.nix → pkgs/ghidra-xenia-v2/build-extension.nix
View File

@ -12,26 +12,20 @@ let
oldMeta:
oldMeta
// {
maintainers =
(oldMeta.maintainers or [ ])
++ (with lib.maintainers; [
vringar
ivyfanchiang
]);
maintainers = (oldMeta.maintainers or [ ]) ++ (with lib.maintainers; [ vringar ]);
platforms = oldMeta.platforms or ghidra.meta.platforms;
};
buildGhidraExtension = lib.extendMkDerivation {
constructDrv = stdenv.mkDerivation;
extendDrvArgs =
finalAttrs:
{
pname,
nativeBuildInputs ? [ ],
meta ? { },
...
}@args:
{
buildGhidraExtension =
{
pname,
nativeBuildInputs ? [ ],
meta ? { },
...
}@args:
stdenv.mkDerivation (
args
// {
nativeBuildInputs = nativeBuildInputs ++ [
unzip
jdk
@ -50,7 +44,7 @@ let
__darwinAllowLocalNetworking = true;
gradleBuildTask = args.gradleBuildTask or "buildExtension";
gradleFlags = args.gradleFlags or [ ] ++ [ "-PGHIDRA_INSTALL_DIR=${ghidra.lib}/lib/ghidra" ];
gradleFlags = args.gradleFlags or [ ] ++ [ "-PGHIDRA_INSTALL_DIR=${ghidra}/lib/ghidra" ];
installPhase =
args.installPhase or ''
@ -59,28 +53,22 @@ let
mkdir -p $out/lib/ghidra/Ghidra/Extensions
unzip -d $out/lib/ghidra/Ghidra/Extensions dist/*.zip
# Prevent attempted creation of plugin lock files in the Nix store.
for i in $out/lib/ghidra/Ghidra/Extensions/*; do
touch "$i/.dbDirLock"
done
runHook postInstall
'';
meta = metaCommon meta;
};
};
}
);
buildGhidraScripts = lib.extendMkDerivation {
constructDrv = stdenv.mkDerivation;
extendDrvArgs =
finalAttrs:
{
pname,
meta ? { },
...
}@args:
{
buildGhidraScripts =
{
pname,
meta ? { },
...
}@args:
stdenv.mkDerivation (
args
// {
installPhase = ''
runHook preInstall
@ -89,7 +77,7 @@ let
cp -r . $GHIDRA_HOME/ghidra_scripts
touch $GHIDRA_HOME/Module.manifest
cat <<'EOF' > $GHIDRA_HOME/extension.properties
cat <<'EOF' > extension.properties
name=${pname}
description=${meta.description or ""}
author=
@ -102,8 +90,8 @@ let
'';
meta = metaCommon meta;
};
};
}
);
in
{
inherit buildGhidraExtension buildGhidraScripts;

29
pkgs/reverse-engineering/ghidra/build.nix → pkgs/ghidra-xenia-v2/build.nix
View File

@ -3,7 +3,7 @@
fetchFromGitHub,
lib,
callPackage,
gradle_8,
gradle,
makeBinaryWrapper,
openjdk21,
unzip,
@ -19,9 +19,7 @@
let
pname = "ghidra";
version = "11.4.2";
isMacArm64 = stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64;
version = "11.2.1";
releaseName = "NIX";
distroPrefix = "ghidra_${version}_${releaseName}";
@ -29,7 +27,7 @@ let
owner = "NationalSecurityAgency";
repo = "Ghidra";
rev = "Ghidra_${version}_build";
hash = "sha256-/veSp2WuGOF0cYwUC4QFJD6kaMae5NuKrQ5Au4LjDe8=";
hash = "sha256-UVX56yNZSAbUejiQ0AIn00r7R+fUW1DEjZmCr1iYwV4=";
# populate values that require us to use git. By doing this in postFetch we
# can delete .git afterwards and maintain better reproducibility of the src.
leaveDotGit = true;
@ -65,7 +63,7 @@ let
echo "application.revision.ghidra=$(cat COMMIT)" >> Ghidra/application.properties
# Tells ghidra to use our own protoc binary instead of the prebuilt one.
tee -a Ghidra/Debug/Debugger-{isf,rmi-trace}/build.gradle <<HERE
cat >>Ghidra/Debug/Debugger-gadp/build.gradle <<HERE
protobuf {
protoc {
path = '${protobuf}/bin/protoc'
@ -74,9 +72,6 @@ let
HERE
'';
# "Deprecated Gradle features were used in this build, making it incompatible with Gradle 9.0."
gradle = gradle_8;
in
stdenv.mkDerivation (finalAttrs: {
inherit
@ -132,21 +127,7 @@ stdenv.mkDerivation (finalAttrs: {
data = ./deps.json;
};
gradleFlags =
[ "-Dorg.gradle.java.home=${openjdk21}" ]
++ lib.optionals isMacArm64 [
# For some reason I haven't been able to figure out yet, ghidra builds for
# arm64 seems to build the x64 binaries of the decompiler. These fail to
# build due to trying to link the x64 object files with arm64 stdc++
# library, which obviously fails.
#
# Those binaries are entirely unnecessary anyways, since we're targeting
# arm64 build here, so let's exclude them from the build.
"-x"
"Decompiler:linkSleighMac_x86_64Executable"
"-x"
"Decompiler:linkDecompileMac_x86_64Executable"
];
gradleFlags = [ "-Dorg.gradle.java.home=${openjdk21}" ];
preBuild = ''
export JAVA_TOOL_OPTIONS="-Duser.home=$NIX_BUILD_TOP/home"

314
pkgs/reverse-engineering/ghidra/deps.json → pkgs/ghidra-xenia-v2/deps.json
View File

@ -7,138 +7,72 @@
}
},
"https://files.pythonhosted.org/packages": {
"05/71/590b2a91b43763aa27eac2c63803542a2878a4d8c600b81aa694d3fde919/jpype1-1.5.2-cp39-cp39-macosx_10_9_x86_64": {
"whl": "sha256-i3XTPpOjvGVD3fl8JO4K21qGpp+2fw5PT6HIw5cLv5g="
},
"0b/7d/9fdbbc1a574be43f9820735ca8df0caf8b159856201d9b21fd73932342bc/jpype1-1.5.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64": {
"whl": "sha256-uQDhVIJqB2EY0HQWZZbx2BfhE+BwhL8MnEPYBkqGq3c="
},
"0e/78/95db2eb3c8a7311ee08a2c237cea24828859db6a6cb5e901971d3f5e49da/jpype1-1.5.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64": {
"whl": "sha256-pUp3HuViYPmOW5p3RVCE5KSAYZZ94T2r9ii9upyBIuA="
},
"0e/b9/4dfb38a7f4efb21f71df7344944a8d9a23e30d0503574e455af6ce4f1a56/jpype1-1.5.2-cp311-cp311-win_amd64": {
"whl": "sha256-Cg0Y1DhLPfLlUoJUVzffzxjGBFBPE4KtFPiAvvlg8mU="
},
"20/a3/00a265d424f7d47e0dc547df2320225ce0143fec671faf710def41404b8c/jpype1-1.5.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64": {
"whl": "sha256-wISAx9GBJWZKEr8KJEuWtJwFEFMGtlk32+/rBatLKEc="
},
"22/18/0a51845ca890ffdc72f4d71a0c2be334b887c5bb6812207efe5ad45afcb3/jpype1-1.5.2-cp310-cp310-win_amd64": {
"whl": "sha256-kksKDPk9Pd2z95KG++QPjJAceO1hIW7b4QhmYjTfQ+A="
},
"27/d6/003e593296a85fd6ed616ed962795b2f87709c3eee2bca4f6d0fe55c6d00/wheel-0.37.1-py2.py3-none-any": {
"whl": "sha256-S9zX2EATgIYSbNCSVNxhlftPxvAcBQodcjbyYw2x0io="
},
"35/a0/638186a75026a02286041e4a0449b1dff799a3914dc1c0716ef9b9367b73/jpype1-1.5.2-cp311-cp311-macosx_10_9_universal2": {
"whl": "sha256-yfarjdKEwW4mF6aX1Uw9AwSwgCCjc4btlhA6EpORotk="
},
"50/8f/518a37381e55a8857a638afa86143efa5508434613541402d20611a1b322/comtypes-1.4.1-py3-none-any": {
"whl": "sha256-ogig48ocClNic12g/2YYIoAdzocxK4lNfXUq3QEKIbA="
},
"6d/d0/191db2e9ab6ae7029368a488c9d88235966843b185aba7925e54aa0c0013/jpype1-1.5.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64": {
"whl": "sha256-Qv6NtmrU5cZvY39cTegvyogLppYQTh9KfldYhZI96tg="
},
"74/dd/7408d4beae755de6fcd07c76b2f0bacabc0461b43fba83811c1f7c22440e/jpype1-1.5.2-cp312-cp312-win_amd64": {
"whl": "sha256-x7HC120hHKtgvhZQXTKms8n//FHOecaOgaPUjl7//y0="
},
"74/f3/1cd4332076ed0421e703412f47f15f43af170809435c57ba3162edc80d4b/jpype1-1.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64": {
"whl": "sha256-tbH7K0MKUPCB6g7iTRkjKuDQPb/j3QduxfiuQrMKZW8="
},
"76/be/b37005bec457b94eaaf637a663073b7c5df70113fd4ae4865f6e386c612f/jpype1-1.5.2-cp313-cp313-macosx_10_13_universal2": {
"whl": "sha256-SssJjLFpixS25ceeJ19McNzAGw+5NCXyBtCl44DkPGY="
},
"77/6b/130fb6d0c43976b4e129c6bc19daf0e25c42fc38c5096ed92c4105bfd2c4/jpype1-1.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64": {
"whl": "sha256-6iG8pM7OdSzT7oj81izo9ET+rI3HJER1/bnA6HEuB+o="
},
"77/91/f08a719461a390b48d9096b50f1f4a49ee281007ec192e51073090d3d8b7/jpype1-1.5.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64": {
"whl": "sha256-VHRCZe82Zl0RDROaS4HRBTJpTGB3sj72DzYJ/q3CLTA="
},
"83/1c/25b79fc3ec99b19b0a0730cc47356f7e2959863bf9f3cd314332bddb4f68/pywin32-306-cp312-cp312-win_amd64": {
"whl": "sha256-NyV3lMGtOe6b5lLaBGLcLjlMgVnf2ROopOjrb9NG2g4="
},
"8d/14/619e24a4c70df2901e1f4dbc50a6291eb63a759172558df326347dce1f0d/protobuf-3.20.3-py2.py3-none-any": {
"whl": "sha256-p8ptSIqo/38ynUxUWy262KwxRk8dixyHrRNGcXcx5Ns="
},
"8d/e4/0c27352e8222dcc0e3ce44b298015072d2057d08dd353541c980a31d26c9/jpype1-1.5.2-cp312-cp312-macosx_10_9_universal2": {
"whl": "sha256-Hh25rJCa0q4OQLBMKqiMsUJQ1SRdaXFVYVB2gfKwiy8="
},
"90/c7/6dc0a455d111f68ee43f27793971cf03fe29b6ef972042549db29eec39a2/psutil-5.9.8": {
"tar.gz": "sha256-a+Em4yJUht/yhqj7mgYkalJT9MfFO0depfWsk05kGUw="
},
"97/0a/cbe03759331c640aa5862f974028122a862b08935a0b11b8fa6f6e46c26b/jpype1-1.5.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64": {
"whl": "sha256-zcqTzHT42x9gTS6mrbdk3sTexoUo8e5oMI+j1SQJVzk="
},
"bd/68/47fa634cbd0418cbca86355e9421425f5892ee994f7338106327e49f9117/jpype1-1.5.2": {
"tar.gz": "sha256-dKQuzPIdMDlMGDKuw5haFJZfpTINoIe2UCnRcsDOxDs="
},
"c0/c6/63538d160c17e837f62d29ba4163bc444cef08c29cd3f3b8090691c1869c/jpype1-1.5.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64": {
"whl": "sha256-/PxcHUXWsQiADRcuqBe9pYXbfxZG1qmNFNqaymbg60Q="
},
"c7/42/be1c7bbdd83e1bfb160c94b9cafd8e25efc7400346cf7ccdbdb452c467fa/setuptools-68.0.0-py3-none-any": {
"whl": "sha256-EeUsZ0FaOB0Q1rRiztnPuXBmF58OhxOZ4AbEqxAfyF8="
},
"c7/f2/b2efcad1ea5a541f125218e4eb1529ebb8ca18941264c879f3e89a36dc35/jpype1-1.5.2-cp310-cp310-macosx_10_9_universal2": {
"whl": "sha256-ey2pjBQoEspAoYpzWzPkfGURsD3r8el5Yw9M9HO2ioc="
},
"ce/78/91db67e7fe1546dc8b02c38591b7732980373d2d252372f7358054031dd4/Pybag-2.2.12-py3-none-any": {
"whl": "sha256-7aXubE6HOQKYG39SW0KgJCi4fHNo3yxb3+He0OaIQSY="
},
"d0/dd/b28df50316ca193dd1275a4c47115a720796d9e1501c1888c4bfa5dc2260/capstone-5.0.1-py3-none-win_amd64": {
"whl": "sha256-G/pcgeaIDK9BoxlGzW0tBpwEi8wi7fEhJUtQGgSN5nU="
},
"e3/b7/e1787633b41d609320b41d0dd87fe3118598210609e4e3f6cef93cfcef40/jpype1-1.5.2-cp313-cp313-win_amd64": {
"whl": "sha256-K5Y2XxMC3y+zxq1zEX1v5FClW3VQ/X/sraw87FvHEXw="
},
"e5/cf/344e1f81f1e8c651ec23dfa9fe4b91f6e1d699b36f610a547ba85ee7fb16/jpype1-1.5.2-cp39-cp39-win_amd64": {
"whl": "sha256-aOHRGCAPxG9OpL8gkACBWH7ATeSEA3yZewo7fF63H+M="
},
"ec/1a/610693ac4ee14fcdf2d9bf3c493370e4f2ef7ae2e19217d7a237ff42367d/packaging-23.2-py3-none-any": {
"whl": "sha256-jEkRkAM6mvfh2THQtdrMLvR1CbNN0N5n7SCbUgP8iMc="
},
"fa/4c/e0200a6e3fed5cda79e926c2a8a610676f04948f89d7e38d93c7d4b21be9/jpype1-1.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64": {
"whl": "sha256-mU+3sxm0U/d61Lav8B4N1BgOp0pv5aAx5OnbktvpU3Y="
}
},
"https://ftp.postgresql.org": {
"pub/source/v15.13/postgresql-15.13": {
"tar.gz": "sha256-r9wisKblvse2VyN1a5DUTqkR5hsvewHE3FUkq4E7TYk="
"pub/source/v15.3/postgresql-15.3": {
"tar.gz": "sha256-CG04Uz4odHlmpNXx546kMuM6ePIdy5EzAQ7LUYn62Yw="
}
},
"https://github.com/NationalSecurityAgency/ghidra-data/raw/Ghidra_11.4.2": {
"Debugger/dbgmodel": {
"tlb": "sha256-jPXzouuBFgqjSQVqXKTCxyaxtumL8wl81BNRRxYzQ8c="
},
"FunctionID/vs2012_x64": {
"https://github.com": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2012_x64": {
"fidb": "sha256-1OmKs/eQuDF5MhhDC7oNiySl+/TaZbDB/6jLDPvrDNw="
},
"FunctionID/vs2012_x86": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2012_x86": {
"fidb": "sha256-pJDtfi7SHlh0Wf6urOcDa37eTOhOcuEN/YxXQ0ppGLY="
},
"FunctionID/vs2015_x64": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2015_x64": {
"fidb": "sha256-4E6eQPnstgHIX02E7Zv2a0U2O+HR6CwWLkyZArjLUI8="
},
"FunctionID/vs2015_x86": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2015_x86": {
"fidb": "sha256-tm7mlmU+LtNlkZ3qrviFEDEgx5LiLnmvcNEgnX4dhkQ="
},
"FunctionID/vs2017_x64": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2017_x64": {
"fidb": "sha256-1fpfaXKYF0+lPSR9NZnmoSiEYFrRgce5VOI4DsHwvYk="
},
"FunctionID/vs2017_x86": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2017_x86": {
"fidb": "sha256-04nLjXb/SlnKNfiRuFIccq1fDfluJTlzotIahhSkzIE="
},
"FunctionID/vs2019_x64": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2019_x64": {
"fidb": "sha256-FQAHeW/DakBpZgrWJEmq2q890Rs4ZKXvIeeYMcnOkRg="
},
"FunctionID/vs2019_x86": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vs2019_x86": {
"fidb": "sha256-62MKNvqlhqNx63NNwLvY0TzK72l/PbWHJZY1jz3SQyo="
},
"FunctionID/vsOlder_x64": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vsOlder_x64": {
"fidb": "sha256-jDtR9GYM0n4aDWEKnz8tX7yDOmasnuQ5PuLySB6FWGY="
},
"FunctionID/vsOlder_x86": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/FunctionID/vsOlder_x86": {
"fidb": "sha256-mGBca2uSFKlF2ETkHIWGDVRkmkW8p4c+9pkcDpNyB4c="
},
"lib/java-sarif-2.1-modified": {
"NationalSecurityAgency/ghidra-data/raw/Ghidra_11.2.1/lib/java-sarif-2.1-modified": {
"jar": "sha256-f3NlZklHVtJxql5LGvbIncUNB0qxxjdKR9+CImQiawE="
},
"pxb1988/dex2jar/releases/download/v2.1/dex2jar-2.1": {
"zip": "sha256-epvfhD1D3k0elOwue29VglAXsMSn7jn/gmYOJJOkbwg="
}
},
"https://repo.maven.apache.org/maven2": {
@ -154,10 +88,10 @@
"jar": "sha256-FWvnNhmcmQMh2f93CQsZlinPyYZeLWwT980pG7FkGBc=",
"pom": "sha256-F84MMunPlTZ4+CCuXyrZLu85bYQPZn/JnyOtwK0l0yg="
},
"com/formdev#flatlaf/3.5.4": {
"jar": "sha256-PDS2rrLxcKlUxDWGR+tDtotEeiw1H/MRBy9xV6XU4v4=",
"module": "sha256-Rjx10DAKwDblv9OLBqPx8Ua/17YdoyYael79bebtqdU=",
"pom": "sha256-ymv/5ynY3zr6lZQM0Wz/dL4eiHIHGP5hCsD+Jv4XsWA="
"com/formdev#flatlaf/3.2.1": {
"jar": "sha256-fYMX/hOyYIiZTWZmOvjofBI5DugIf3unS2hjj0pV9EA=",
"module": "sha256-kU7FLZBJj8ctFju0F1UhHnW7yfy3ip5wTZn/Mvfzywg=",
"pom": "sha256-uKf+YYO269HIAaqwdGnF2UFRQFSftLdpkqyALuJeGtE="
},
"com/github/rotty3000#phidias/0.3.7": {
"jar": "sha256-yNB2DOOw7RRT1DW83THjTwvjrAkCTn4amLijzr9Ka7U=",
@ -249,6 +183,9 @@
"jar": "sha256-8CqV+hpele2z7YWf0Pt99wnRIaNSkO/4t03OKrf01u0=",
"pom": "sha256-N/h3mLGDhRE8kYv6nhJ2/lBzXvj6hJtYAMUZ1U2/Efg="
},
"com/google/protobuf#protobuf-bom/3.17.3": {
"pom": "sha256-bf431vImF9VqQUzNrf+NmFhaH3kXEr6HbCYWZxDR2N0="
},
"com/google/protobuf#protobuf-bom/3.21.8": {
"pom": "sha256-+7Ds/DyjGFddtifjOuRUwT1qTcp68UXRTT9m4IY8PPo="
},
@ -256,17 +193,32 @@
"jar": "sha256-RP2JrzepsvHdQcCUqbtzPAe/f8eg4jhooQuvbjUfpeA=",
"pom": "sha256-Gwqekab09LYqWmB4wibudwqo3FdnueRzwvwY8KOImAQ="
},
"com/google/protobuf#protobuf-java/3.17.3": {
"jar": "sha256-SsVJsZJpQUGVgEnwYKHIJqMzQvYZ4QjO2MF9mHf14+0=",
"pom": "sha256-Km8izVJli4uxTBANs+F5NT+MNR0ENzo79voKOzlGStw="
},
"com/google/protobuf#protobuf-java/3.21.8": {
"jar": "sha256-C4WBrYENLfrv0Nz78VabFFBEhlAjjX4v1rF2yTLQjJU=",
"pom": "sha256-OJBUBuApx6MYaW8O4RnFXM7HizN+oR5MMZWfDgardAg="
},
"com/google/protobuf#protobuf-parent/3.17.3": {
"pom": "sha256-T09Q5moqvM/o7SCbU/q3C4k+NfQ77FqB98GESbY+hrE="
},
"com/google/protobuf#protobuf-parent/3.21.8": {
"pom": "sha256-bHKyrDl1sAnR5FdQlVnp+onyV4vShD3LTWo+XPgRFws="
},
"com/googlecode/json-simple#json-simple/1.1.1": {
"jar": "sha256-TmlpaJK4i0HFXUmrL9zCHurZK/VKzFiMAFBZbDt1GZw=",
"pom": "sha256-Zl9jWQ3vtj1irdIdNSU2LPk3z2ocBeSwFFuujailf4M="
},
"com/h2database#h2/2.2.220": {
"jar": "sha256-l4q4YwGNP5ZeOIgFccNik+qLEKgIYZQVnE1dILUPClc=",
"pom": "sha256-tbp8XBcINbyupnWMWfo8EOvNepx5LiWzm4a559X72Mo="
},
"com/jcraft#jsch/0.1.55": {
"jar": "sha256-1JKxWm0uo/HMOcQiyVPEDBIokHPb6DYNmMD2+ex0/EQ=",
"pom": "sha256-dHx0jR8BBx6j0PhHb2jUqCOjE7dycB2FUck+qqV/n5k="
},
"com/opencsv#opencsv/5.4": {
"jar": "sha256-n94e8+VEQE406u4V5L97p0uANV15gJOwUk1jpZk2JCs=",
"pom": "sha256-uGQpmn0KIQIKgxaZQ499P4VAirJKNOkR+qmf9oTrdv0="
@ -286,10 +238,6 @@
"jar": "sha256-fZOMgXiQKARcCMBl6UvnX8KAUnYg1b1itRnVg4UyNoo=",
"pom": "sha256-w1zKe2HUZ42VeMvAuQG4cXtTmr+SVEQdp4uP5g3gZNA="
},
"commons-codec#commons-codec/1.18.0": {
"jar": "sha256-ugBfMEzvkqPe3iSjitWsm4r8zw2PdYOdbBM4Y0z39uQ=",
"pom": "sha256-dLkW2ksDhMYZ5t1MGN7+iqQ4f3lSBSU8+0u7L0WM3c4="
},
"commons-collections#commons-collections/3.2.2": {
"jar": "sha256-7urpF5FxRKaKdB1MDf9mqlxcX9hVk/8he87T/Iyng7g=",
"pom": "sha256-1dgfzCiMDYxxHDAgB8raSqmiJu0aES1LqmTLHWMiFws="
@ -298,10 +246,6 @@
"jar": "sha256-lhsvbYfbrMXVSr9Fq3puJJX4m3VZiWLYxyPOqbwhCQg=",
"pom": "sha256-LgFv1+MkS18sIKytg02TqkeQSG7h5FZGQTYaPoMe71k="
},
"commons-io#commons-io/2.19.0": {
"jar": "sha256-gkJokZtLYvn0DwjFQ4HeWZOwePWGZ+My0XNIrgGdcrk=",
"pom": "sha256-VCt6UC7WGVDRuDEStRsWF9NAfjpN9atWqY12Dg+MWVA="
},
"commons-lang#commons-lang/2.6": {
"jar": "sha256-UPEbCfh3wpTVbyRGP0fSj5Kc9QRPZIZhwPDPuumi9Jw=",
"pom": "sha256-7Xa4iRwwtWYonHQ2Vvik1DWYaYJDjUDFZ8YmIzJH5xE="
@ -310,42 +254,17 @@
"jar": "sha256-2t3qHqC+D1aXirMAa4rJKDSv7vvZt+TmMW/KV98PpjY=",
"pom": "sha256-yRq1qlcNhvb9B8wVjsa8LFAIBAKXLukXn+JBAHOfuyA="
},
"de/femtopedia/dex2jar#d2j-base-cmd/2.4.24": {
"jar": "sha256-npdgWaiU74QPoAMunrk+psr60vGphpifoMXqcbvZFJ0=",
"module": "sha256-65mjqSTi2DV/NXoU2RN9XX8KH0FODoH9EfVBqInq2Bs=",
"pom": "sha256-s8X4M7/XHInxWe+0DG5BtsU0qglCXme9YIQxdW0cUzk="
},
"de/femtopedia/dex2jar#d2j-external/2.4.24": {
"jar": "sha256-PVAlQnJ6wWlu6/vwttvaU4uppYIq8r9LvgtgLvAsChA=",
"pom": "sha256-iurxTkKYs3mHap/0Bshvlvb1ItTNRgX/UHVb+9Wr6nw="
},
"de/femtopedia/dex2jar#dex-ir/2.4.24": {
"jar": "sha256-5wB1C3kGWPqw1ceC9oofvcWH74op+LMsgWv5JdKUWQA=",
"module": "sha256-bwx56rQdiS++RQReuV/x6+XW9kW/j75D1TkmjCfCP6I=",
"pom": "sha256-UpoS1s+bSCpK6lMusffK4pf96ez+/EzG3Toy5BFom+A="
},
"de/femtopedia/dex2jar#dex-reader-api/2.4.24": {
"jar": "sha256-gJvNGdys1pm6BILCdNMgtp0uFHEJh1uMVXcpquWTxKw=",
"module": "sha256-9KsAw3EWGfByHsgc5PMoSI0NSHkMqmJHg23KLqmFYBQ=",
"pom": "sha256-TwVdir25YI+lmnUa4LHLa5MCMxZzXj34idrMGQugXcc="
},
"de/femtopedia/dex2jar#dex-reader/2.4.24": {
"jar": "sha256-Sh8LEZ7oU/27K55XzBBziskG0RGotrAjTaePSNzrGrI=",
"module": "sha256-qlKoHHLESSxUL/oUZVts5tBwsB4CRmi/Yu5di6WHETY=",
"pom": "sha256-Z6TS45BHREEwK1Y9RvHU9B6plqXMKOvslFq9XG29vJ0="
},
"de/femtopedia/dex2jar#dex-translator/2.4.24": {
"jar": "sha256-1Uvxla4E3v1KbMQBv1hkTTTOKccAuVOl8A9/HXsD2lU=",
"module": "sha256-0KGW3NUxqnpbEZCwyypcG6BhF137Ey2S3P5a0pCpF9s=",
"pom": "sha256-YQbcNXGfyXyPjDoBP0w3Dn4genKLKQu8bdSwiaezL5s="
},
"javax/help#javahelp/2.0.05": {
"jar": "sha256-/PSSLTj/hRhPHSMoMXu2CCbhTalIq9YG7j1bjGpw3r0=",
"pom": "sha256-uIEr4lGsoTl/S2pCO/Tt06KERONFOyIDtTSTNrmVgik="
},
"junit#junit/4.13.2": {
"jar": "sha256-jklbY0Rp1k+4rPo0laBly6zIoP/1XOHjEAe+TBbcV9M=",
"pom": "sha256-Vptpd+5GA8llwcRsMFj6bpaSkbAWDraWTdCSzYnq3ZQ="
"junit#junit/4.10": {
"jar": "sha256-NqdHyh4LhvbqiAVbhyO7hwMNYndm2mKIvwd6/e6w91o=",
"pom": "sha256-IqG/C6rothBretgCbs8nxZ5+R920nWKXUDa+rbLGLrU="
},
"junit#junit/4.12": {
"jar": "sha256-WXIfCAXiI9hLkGd4h9n/Vn3FNNfFAsqQPAwrF/BcEWo=",
"pom": "sha256-kPFj944/+28cetl96efrpO6iWAcUG4XW0SvmfKJUScQ="
},
"kr/motd/maven#os-maven-plugin/1.7.0": {
"jar": "sha256-lDBTUBpCnlPRxNYhUu7BJfo2Yg4NxmtzkKiVCXz96s4=",
@ -443,9 +362,6 @@
"org/apache#apache/27": {
"pom": "sha256-srD8aeIqZQw4kvHDZtdwdvKVdcZzjfTHpwpEhESEzfk="
},
"org/apache#apache/33": {
"pom": "sha256-14vYUkxfg4ChkKZSVoZimpXf5RLfIRETg6bYwJI6RBU="
},
"org/apache#apache/7": {
"pom": "sha256-E5fOHbQzrcnyI9vwdJbRM2gUSHUfSuKeWPaOePtLbCU="
},
@ -457,9 +373,9 @@
"jar": "sha256-Hfi5QwtcjtFD14FeQD4z71NxskAKrb6b2giDdi4IRtE=",
"pom": "sha256-JxvWc4Oa9G5zr/lX4pGNS/lvWsT2xs9NW+k/0fEnHE0="
},
"org/apache/commons#commons-compress/1.27.1": {
"jar": "sha256-KT2A9UtTa3QJXc1+o88KKbv8NAJRkoEzJJX0Qg03DRY=",
"pom": "sha256-34zBqDh9TOhCNjtyCf3G0135djg5/T/KtVig+D+dhBw="
"org/apache/commons#commons-compress/1.21": {
"jar": "sha256-auz9VFlyillWAc+gcljRMZcv/Dm0kutIvdWWV3ovJEo=",
"pom": "sha256-Z1uwI8m+7d4yMpSZebl0Kl/qlGKApVobRi1Mp4AQiM0="
},
"org/apache/commons#commons-dbcp2/2.9.0": {
"jar": "sha256-iHcgkSxcu83/bg4h1QNJN1Vfj/xZc4Hv+Pp38zzm1k4=",
@ -468,9 +384,9 @@
"org/apache/commons#commons-lang3/3.11": {
"pom": "sha256-mA1mXYP+0EZlE08FeOUHRCoOdQaRBzeEORsKeYhySnU="
},
"org/apache/commons#commons-lang3/3.17.0": {
"jar": "sha256-bucx31yOWil2ocoCO2uzIOqNNTn75kyKHVy3ZRJ8M7Q=",
"pom": "sha256-NRxuSUDpObHzMN9H9g8Tujg9uB7gCBga9UHzoqbSpWw="
"org/apache/commons#commons-lang3/3.12.0": {
"jar": "sha256-2RnZBEhsA3+NGTQS2gyS4iqfokIwudZ6V4VcXDHH6U4=",
"pom": "sha256-gtMfHcxFg+/9dE6XkWWxbaZL+GvKYj/F0bA+2U9FyFo="
},
"org/apache/commons#commons-lang3/3.9": {
"pom": "sha256-pAIkKbmEJbQwGBkVchJ5pS9hDzRki9rEh9TKy76N/rU="
@ -502,18 +418,6 @@
"org/apache/commons#commons-parent/54": {
"pom": "sha256-AA2Bh5UrIjcC/eKW33mVY/Nd6CznKttOe/FXNCN4++M="
},
"org/apache/commons#commons-parent/72": {
"pom": "sha256-Q0Xev8dnsa6saKvdcvxn0YtSHUs5A3KhG2P/DFhrIyA="
},
"org/apache/commons#commons-parent/73": {
"pom": "sha256-TtRFYLB/hEhHnf0eg6Qiuk6D5gs25RsocaxQKm1cG+o="
},
"org/apache/commons#commons-parent/79": {
"pom": "sha256-Yo3zAUis08SRz8trc8euS1mJ5VJqsTovQo3qXUrRDXo="
},
"org/apache/commons#commons-parent/81": {
"pom": "sha256-NI1OfBMb5hFMhUpxnOekQwenw5vTZghJd7JP0prQ7bQ="
},
"org/apache/commons#commons-pool2/2.11.1": {
"jar": "sha256-6gUF7nUV5YsawOaG5NGl2ffYCOJRphvDcaoFlbmWP4M=",
"pom": "sha256-wbsCmUpK34loDfepitujPFUnaDAUJy1liFuzA27NSMM="
@ -549,17 +453,17 @@
"org/apache/logging/log4j#log4j/2.17.1": {
"pom": "sha256-lnq8AkRDqcsJaTVVmvXprW8P9hN1+Esn1EDS+nCAawk="
},
"org/bouncycastle#bcpkix-jdk18on/1.80": {
"jar": "sha256-T0umqSYX6hncGD8PpdtJLu5Cb93ioKLWyUd3/9GvZBM=",
"pom": "sha256-pKEiETRntyjhjyb7DP1X8LGg18SlO4Zxis5wv4uG7Uc="
"org/bouncycastle#bcpkix-jdk15on/1.69": {
"jar": "sha256-QIN20Xqqh4nnrNBV/kBCiaEfozX9fGinUykEn7fSjtI=",
"pom": "sha256-WrvkytLCMJR0ZvsgmiJn48xqDTgKajGRWVnTqtm4F2w="
},
"org/bouncycastle#bcprov-jdk18on/1.80": {
"jar": "sha256-6K0gn4xY0pGjfKl1Dp6frGBZaVbJg+Sd2Cgjgd2LMkk=",
"pom": "sha256-oKdcdtkcQh7qVtD2Bi+49j7ff6x+xyT9QgzNytcYHUM="
"org/bouncycastle#bcprov-jdk15on/1.69": {
"jar": "sha256-5Gm9Ofk2mZ8lYAJjEAP/AioilR2p1b2Xicer+pdjopI=",
"pom": "sha256-/YHicUSVvOeeauazAp2s0kzyz/NAJB2lgQVYlae6eN4="
},
"org/bouncycastle#bcutil-jdk18on/1.80": {
"jar": "sha256-Iuymh/eVVBH0Vq8z5uqOaPxzzYDLizKqX3qLGCfXxng=",
"pom": "sha256-Qhp95L/rnFs4sfxHxCagh9kIeJVdQQf1t6gusde3R7Y="
"org/bouncycastle#bcutil-jdk15on/1.69": {
"jar": "sha256-KeQOJGbQQNgqbw6ZY10LwrujqUJRz3k5zwtpMhyu/Ak=",
"pom": "sha256-p2e8fzQtGTKJfso8i6zHAEygOAv6dSnyOpc0VJZcffw="
},
"org/checkerframework#checker-compat-qual/2.5.2": {
"pom": "sha256-da9ztewybj29yUayH9RoAtXafGEsO/Hlh1N0yY1+pP0="
@ -568,16 +472,15 @@
"jar": "sha256-ZLAmkci51OdwD47i50Lc5+osboHmYrdSLJ7jv1aMBAo=",
"pom": "sha256-3EzUOKNkYtATwjOMjiBtECoyKgDzNynolV7iGYWcnt4="
},
"org/checkerframework#checker-qual/3.31.0": {
"module": "sha256-UYkl4iqnmMH71voXwYN0aR8f57G+fdNw1Omv7us7Ds8=",
"pom": "sha256-Q1ecPr5H54NYp/MvlnN471YXWyKUszUYNYTwvSNZUjE="
},
"org/checkerframework#checker-qual/3.37.0": {
"jar": "sha256-5M4TdswnNeHd4iC2KtCRP1EpdwTarRVaM/OGvF2w2fc=",
"module": "sha256-clinadyqJrmBVNIp2FzHLls2ZrC8tjfS2vFuxJiVZjg=",
"pom": "sha256-AjkvvUziGQH5RWFUcrHU1NNZGzqr3wExBfXJLsMstPA="
},
"org/checkerframework#checker-qual/3.49.3": {
"jar": "sha256-Nn7b8v6fYGwf21qLpuHJwnYlmT4f+VTjho3nC8xkFrc=",
"module": "sha256-dv9CWNsfoaC8bOeur0coPfEGD9Q3oJvm7zxcMmnqWtM=",
"pom": "sha256-i+QBdkYoXZFCx/sibPuARFwXfcfBNjsj2UH6bJuwXc8="
},
"org/codehaus#codehaus-parent/3": {
"pom": "sha256-UOslOs0LbuBI9DLZ/Do7NiZO+z2h/6f7B/bE1LeoyjE="
},
@ -601,25 +504,6 @@
"org/codehaus/mojo#mojo-parent/40": {
"pom": "sha256-/GSNzcQE+L9m4Fg5FOz5gBdmGCASJ76hFProUEPLdV4="
},
"org/commonmark#commonmark-ext-footnotes/0.23.0": {
"jar": "sha256-YwKKfV6V7sjibuBCSxQfh+nalccYTypaSbtD371TsQQ=",
"pom": "sha256-zMoEy/7Z60gzSM+6aexh9gvdyfPjwJJLZLsZ0cqy4s0="
},
"org/commonmark#commonmark-ext-gfm-tables/0.23.0": {
"jar": "sha256-WfO2Gthywhg7guygUn14GspFThF31xmMl5WydH0XC3s=",
"pom": "sha256-x6/bJCGgs9hFDewHWaPrfBHEqZfTlLd8VR3Bgi3S2Uk="
},
"org/commonmark#commonmark-ext-heading-anchor/0.23.0": {
"jar": "sha256-7O27O1jbcgxhNXwb4boTKlweeczr4B8NPZo25VJCDL0=",
"pom": "sha256-95zHry5Zpgc70UwPNKezU0JDO5FxqhdLYzeHRaVuASw="
},
"org/commonmark#commonmark-parent/0.23.0": {
"pom": "sha256-zEC+Twqn9Lw5BEquYQVT5BfyYRkHNJVqXJl/Q50Tw94="
},
"org/commonmark#commonmark/0.23.0": {
"jar": "sha256-spUGEYOcwMDG4lwIPjprIpXrwyeDLsBzPn2bvJTnTrM=",
"pom": "sha256-3mdvxdpEpo0CntlaCSuJPVbo/ElogKIx5HHl1bKzvhY="
},
"org/fusesource#fusesource-pom/1.12": {
"pom": "sha256-xA2WDarc73sBwbHGZXr7rE//teUxaPj8sLKLhOb9zKE="
},
@ -627,10 +511,17 @@
"jar": "sha256-+dWXnFx7oxN8d/QYR16wIYn4/Ip1+nP/w/8dEv6UVWc=",
"pom": "sha256-ywU3vsxjUsFUcz22+v0JAPlYRgOgsLnPjyJFVjEs2+E="
},
"org/hamcrest#hamcrest-core/1.1": {
"jar": "sha256-A2HRST/w2U+GE1nv6pEgByBjUHITR5LvtyF/bgnVz/s=",
"pom": "sha256-OXOH9AbGjMtAP0d8y+wcgYz8a4/0+tpaM+Jhg6hBfIM="
},
"org/hamcrest#hamcrest-core/1.3": {
"jar": "sha256-Zv3vkelzk0jfeglqo4SlaF9Oh1WEzOiThqekclHE2Ok=",
"pom": "sha256-/eOGp5BRc6GxA95quCBydYS1DQ4yKC4nl3h8IKZP+pM="
},
"org/hamcrest#hamcrest-parent/1.1": {
"pom": "sha256-FOaVChpimMvLg8+UKcrEFf8nMWf28Vh2hZQTsNbAfjo="
},
"org/hamcrest#hamcrest-parent/1.3": {
"pom": "sha256-bVNflO+2Y722gsnyelAzU5RogAlkK6epZ3UEvBvkEps="
},
@ -699,17 +590,9 @@
"jar": "sha256-EhJRcOeVUZum3IAQwHC1PHaq6StIXB43Uw5Uq13QjUM=",
"pom": "sha256-EMo7z1F48YUH8hCmOtljeJaFM0OtHBKRoBmhFvIWpUg="
},
"org/junit#junit-bom/5.11.0": {
"module": "sha256-9+2+Z/IgQnCMQQq8VHQI5cR29An1ViNqEXkiEnSi7S0=",
"pom": "sha256-5nRZ1IgkJKxjdPQNscj0ouiJRrNAugcsgL6TKivkZE0="
},
"org/junit#junit-bom/5.11.0-M2": {
"module": "sha256-hkd6vPSQ1soFmqmXPLEI0ipQb0nRpVabsyzGy/Q8LM4=",
"pom": "sha256-Sj/8Sk7c/sLLXWGZInBqlAcWF5hXGTn4VN/ac+ThfMg="
},
"org/junit#junit-bom/5.11.4": {
"module": "sha256-qaTye+lOmbnVcBYtJGqA9obSd9XTGutUgQR89R2vRuQ=",
"pom": "sha256-GdS3R7IEgFMltjNFUylvmGViJ3pKwcteWTpeTE9eQRU="
"org/junit#junit-bom/5.7.1": {
"module": "sha256-mFTjiU1kskhSB+AEa8oHs9QtFp54L0+oyc4imnj67gQ=",
"pom": "sha256-C5sUo9YhBvr+jGinF7h7h60YaFiZRRt1PAT6QbaFd4Q="
},
"org/junit#junit-bom/5.7.2": {
"module": "sha256-87zrHFndT2mT9DBN/6WAFyuN9lp2zTb6T9ksBXjSitg=",
@ -735,13 +618,12 @@
"jar": "sha256-cFPFfn19iP7GuQl5o68SXh0ruEcmijKKLx7WWtCkwYU=",
"pom": "sha256-rcyK9ce+Z7BSEF4Mncq43ibaxvGbxamrcpRqMydscQA="
},
"org/ow2#ow2/1.3": {
"pom": "sha256-USFcZ9LAaNi30vb4D1E3KgmAdd7MxEjUvde5h7qDKPs="
},
"org/ow2#ow2/1.5.1": {
"pom": "sha256-Mh3bt+5v5PU96mtM1tt0FU1r+kI5HB92OzYbn0hazwU="
},
"org/ow2/asm#asm-analysis/9.7.1": {
"jar": "sha256-hbKTcYhLoxu3bt8iMjwsJOFywyZ6ZxUuuj0czC4EHvI=",
"pom": "sha256-JcI3nyv8Kh5k5iw54rk8+w5IlweFKwjW/EcLHGpSue4="
},
"org/ow2/asm#asm-bom/9.6": {
"pom": "sha256-ig5fYk/ikwt6jWmVb0OORe9TKZa01kQJthbErvSxrE4="
},
@ -749,37 +631,28 @@
"jar": "sha256-eu/Q1cCQFwHGn3UT/tp2X7a+M68s56oXxXgfyHZXxRE=",
"pom": "sha256-qYrkiVM0uvj/hr1mUWIQ29mgPxpuFeR92oKvz2tT13w="
},
"org/ow2/asm#asm-commons/9.7.1": {
"jar": "sha256-mlebVNKSrZvhcdQxP9RznGNVksK1rDpFm70QSc3exqA=",
"pom": "sha256-C/HTHaDJ+djtwvJ9u/279z8acVtyzS+ijz8ZWZTXStE="
"org/ow2/asm#asm-debug-all/5.0.3": {
"jar": "sha256-KWk1asHkD+QUGUjFY2kCOPXXnXaux/2HNTaGejMe3oE=",
"pom": "sha256-nJnXpVVyW8L4N5l3k1zboW1ofZyTtuByXhlhgNSQyZU="
},
"org/ow2/asm#asm-parent/5.0.3": {
"pom": "sha256-wu2r9BKKU030uLSwubVi6U8kK6lawk3GFIVDK4oYjjI="
},
"org/ow2/asm#asm-tree/9.6": {
"jar": "sha256-xD7PF7U5x3fhXae1uGVTs3fi05poPeYoVWfVKDiI5+8=",
"pom": "sha256-G8tIHX/Ba5VbtgygfIz6JCS87ni9xAW7oxx9b13C0RM="
},
"org/ow2/asm#asm-tree/9.7.1": {
"jar": "sha256-mSmIH1nra4QOhtVFcMd7Wc5yHRBObf16QJeJkcLTtB8=",
"pom": "sha256-E7kF9l5/1DynZ09Azao3Z5ukhYxsnZ+48Xp6/ZuqvJ4="
},
"org/ow2/asm#asm-util/9.7.1": {
"jar": "sha256-+IW+cbXJBVb18a0cT5J2spuWBXxJfUZmb+TdvsPLQ8Y=",
"pom": "sha256-f7XmM2Ky1S133KO3VK661jV1HT/FIBkelQDs6eI0W3E="
},
"org/ow2/asm#asm/9.6": {
"jar": "sha256-PG+sJCTbPUqFO2afTj0dnDxVIjXhmjGWc/iHCDwjA6E=",
"pom": "sha256-ku7iS8PIQ+SIHUbB3WUFRx7jFC+s+0ZrQoz+paVsa2A="
},
"org/ow2/asm#asm/9.7.1": {
"jar": "sha256-jK3UOsXrbQneBfrsyji5F6BAu5E5x+3rTMgcdAtxMoE=",
"pom": "sha256-cimwOzCnPukQCActnkVppR2FR/roxQ9SeEGu9MGwuqg="
"org/postgresql#postgresql/42.6.2": {
"jar": "sha256-gmKXVPMJwLVx0dQLp0+wU4VfhjdSpGyjB8ez5YYMSy4=",
"pom": "sha256-/5dcZtbZSN/YKp6SbsER7eldPkyRo6DYaQ8xox45NMY="
},
"org/postgresql#postgresql/42.7.6": {
"jar": "sha256-8qHMA1LdXlxvZdut/ye+4Awy5DLGrQMNB0R/ilmDxCo=",
"pom": "sha256-SfNzCJO2khPK99foymodjHaf9mhCHVJS3gBSvFVGp8c="
},
"org/python#jython-standalone/2.7.4": {
"jar": "sha256-H7oXae/8yLGfXhBDa8gnShWM6YhVnyV5J8JMc7sTfzw=",
"pom": "sha256-WjutObAFQl/DVMK4niUVrj0MmdizCk6UqxtaPBSF1TM="
"org/python#jython-standalone/2.7.3": {
"jar": "sha256-2n89gpsUi8+oawWdyWTjqFVv7bAhCWyNsH4wxm+qubQ=",
"pom": "sha256-moD1I2PkBVnKxMjaKsX4uil3ksbpEmN7dIUfKjMHDNI="
},
"org/slf4j#slf4j-api/1.7.25": {
"jar": "sha256-GMSgCV1cHaa4F1kudnuyPSndL1YK1033X/OWHb3iW3k=",
@ -807,6 +680,9 @@
"module": "sha256-rRt+JSAWcAXJFp2Gv8z/JvXF+b8Ls/qyRMtIIWU9wmE=",
"pom": "sha256-IKx+12/5cPUQB6IPrIvbon7IeUT9Kb2oxnQJZ5LJFFE="
},
"org/sonatype/oss#oss-parent/6": {
"pom": "sha256-tDBtE+j1OSRYobMIZvHP8WGz0uaZmojQWe6jkyyKhJk="
},
"org/sonatype/oss#oss-parent/7": {
"pom": "sha256-tR+IZ8kranIkmVV/w6H96ne9+e9XRyL+kM5DailVlFQ="
},
@ -863,8 +739,8 @@
}
},
"https://sourceforge.net/projects": {
"pydev/files/pydev/PyDev%209.3.0/PyDev%209.3.0": {
"zip": "sha256-RTmO3yrbVgeKgLyIqRmUFXjwwLNj773QEb/RWKmbES4="
"pydev/files/pydev/PyDev%206.3.1/PyDev%206.3.1": {
"zip": "sha256-TYH+nYr+dmW46iCETT9RB/RGdCknxZlz6t5PKYCbBpk="
},
"yajsw/files/yajsw/yajsw-stable-13.12/yajsw-stable-13.12": {
"zip": "sha256-xvxZgV04ANFOyXeSaor9P2BqDr100s/WBgFndGbt6qI="

11
pkgs/reverse-engineering/ghidra/extensions.nix → pkgs/ghidra-xenia-v2/extensions.nix
View File

@ -11,13 +11,11 @@ lib.makeScope newScope (self: {
buildGhidraScripts
;
binsync = self.callPackage ./extensions/binsync {};
findcrypt = self.callPackage ./extensions/findcrypt { };
ghidra-delinker-extension = self.callPackage ./extensions/ghidra-delinker-extension { };
ghidra-firmware-utils = self.callPackage ./extensions/ghidra-firmware-utils { };
ghidra-delinker-extension = self.callPackage ./extensions/ghidra-delinker-extension {
inherit ghidra;
};
ghidra-golanganalyzerextension = self.callPackage ./extensions/ghidra-golanganalyzerextension { };
@ -25,8 +23,6 @@ lib.makeScope newScope (self: {
gnudisassembler = self.callPackage ./extensions/gnudisassembler { inherit ghidra; };
kaiju = self.callPackage ./extensions/kaiju { };
lightkeeper = self.callPackage ./extensions/lightkeeper { };
machinelearning = self.callPackage ./extensions/machinelearning { inherit ghidra; };
@ -35,5 +31,4 @@ lib.makeScope newScope (self: {
sleighdevtools = self.callPackage ./extensions/sleighdevtools { inherit ghidra; };
wasm = self.callPackage ./extensions/wasm { inherit ghidra; };
})

17
pkgs/reverse-engineering/ghidra/extensions/findcrypt/default.nix → pkgs/ghidra-xenia-v2/extensions/findcrypt/default.nix
View File

@ -3,23 +3,26 @@
fetchFromGitHub,
buildGhidraExtension,
}:
buildGhidraExtension (finalAttrs: {
let
version = "3.0.2";
in
buildGhidraExtension {
pname = "findcrypt";
version = "3.1.2";
inherit version;
src = fetchFromGitHub {
owner = "antoniovazquezblanco";
repo = "GhidraFindcrypt";
rev = "v${finalAttrs.version}";
hash = "sha256-KP6Wx2U8O/37yEAcV3abKg/uWraHJJOIfb7kvcfejHA=";
rev = "v${version}";
hash = "sha256-SNmhn/X+POp6dRaB9etZ8GvpKf/5+mPg3E0HUQTthIY=";
};
meta = {
description = "Ghidra analysis plugin to locate cryptographic constants";
homepage = "https://github.com/antoniovazquezblanco/GhidraFindcrypt";
downloadPage = "https://github.com/antoniovazquezblanco/GhidraFindcrypt/releases/tag/v${finalAttrs.version}";
changelog = "https://github.com/antoniovazquezblanco/GhidraFindcrypt/releases/tag/v${finalAttrs.version}";
downloadPage = "https://github.com/antoniovazquezblanco/GhidraFindcrypt/releases/tag/v${version}";
changelog = "https://github.com/antoniovazquezblanco/GhidraFindcrypt/releases/tag/v${version}";
license = lib.licenses.gpl3;
maintainers = [ lib.maintainers.BonusPlay ];
};
})
}

43
pkgs/ghidra-xenia-v2/extensions/ghidra-delinker-extension/default.nix Normal file
View File

@ -0,0 +1,43 @@
{
lib,
ghidra,
gradle,
fetchFromGitHub,
}:
let
version = "0.5.0";
self = ghidra.buildGhidraExtension {
pname = "ghidra-delinker-extension";
inherit version;
src = fetchFromGitHub {
owner = "boricj";
repo = "ghidra-delinker-extension";
rev = "v${version}";
hash = "sha256-y0afqqIsWN33b/zGsxJYn8O+R5IP4eD300CgzMymEA0=";
};
postPatch = ''
substituteInPlace build.gradle \
--replace-fail '"''${getGitHash()}"' '"v${version}"'
'';
gradleBuildTask = "buildExtension";
__darwinAllowLocalNetworking = true;
mitmCache = gradle.fetchDeps {
pkg = self;
data = ./deps.json;
};
meta = {
description = "Ghidra extension for delinking executables back to object files";
homepage = "https://github.com/boricj/ghidra-delinker-extension";
license = lib.licenses.asl20;
maintainers = [ lib.maintainers.jchw ];
platforms = lib.platforms.unix;
};
};
in
self

0
pkgs/reverse-engineering/ghidra/extensions/ghidra-delinker-extension/deps.json → pkgs/ghidra-xenia-v2/extensions/ghidra-delinker-extension/deps.json
View File

8
pkgs/reverse-engineering/ghidra/extensions/ghidra-golanganalyzerextension/default.nix → pkgs/ghidra-xenia-v2/extensions/ghidra-golanganalyzerextension/default.nix
View File

@ -3,22 +3,22 @@
fetchFromGitHub,
buildGhidraExtension,
}:
buildGhidraExtension (finalAttrs: {
buildGhidraExtension rec {
pname = "Ghidra-GolangAnalyzerExtension";
version = "1.2.4";
src = fetchFromGitHub {
owner = "mooncat-greenpy";
repo = "Ghidra_GolangAnalyzerExtension";
rev = finalAttrs.version;
rev = version;
hash = "sha256-uxozIJ+BLcP1vBnLOCZD9ueY10hd37fON/Miii3zabo=";
};
meta = {
description = "Facilitates the analysis of Golang binaries using Ghidra";
homepage = "https://github.com/mooncat-greenpy/Ghidra_GolangAnalyzerExtension";
downloadPage = "https://github.com/mooncat-greenpy/Ghidra_GolangAnalyzerExtension/releases/tag/${finalAttrs.version}";
downloadPage = "https://github.com/mooncat-greenpy/Ghidra_GolangAnalyzerExtension/releases/tag/${version}";
license = lib.licenses.mit;
maintainers = [ lib.maintainers.ivyfanchiang ];
};
})
}

0
pkgs/reverse-engineering/ghidra/extensions/ghidraninja-ghidra-scripts/default.nix → pkgs/ghidra-xenia-v2/extensions/ghidraninja-ghidra-scripts/default.nix
View File

5
pkgs/reverse-engineering/ghidra/extensions/gnudisassembler/default.nix → pkgs/ghidra-xenia-v2/extensions/gnudisassembler/default.nix
View File

@ -25,7 +25,7 @@ buildGhidraExtension {
pname = "gnudisassembler";
version = lib.getVersion ghidra;
src = "${ghidra.lib}/lib/ghidra/Extensions/Ghidra/${ghidra.distroPrefix}_GnuDisassembler.zip";
src = "${ghidra}/lib/ghidra/Extensions/Ghidra/${ghidra.distroPrefix}_GnuDisassembler.zip";
postPatch = ''
ln -s ${binutils-src} binutils-${binutils-version}.tar.bz2
@ -42,8 +42,7 @@ buildGhidraExtension {
bison
texinfo
perl
]
++ lib.optionals stdenv.hostPlatform.isDarwin [ xcbuild ];
] ++ lib.optionals stdenv.hostPlatform.isDarwin [ xcbuild ];
buildInputs = [ zlib ];
gradleBuildTask = "assemble";

12
pkgs/reverse-engineering/ghidra/extensions/lightkeeper/default.nix → pkgs/ghidra-xenia-v2/extensions/lightkeeper/default.nix
View File

@ -3,22 +3,22 @@
fetchFromGitHub,
buildGhidraExtension,
}:
buildGhidraExtension (finalAttrs: {
buildGhidraExtension rec {
pname = "lightkeeper";
version = "1.2.4";
version = "1.1.1";
src = fetchFromGitHub {
owner = "WorksButNotTested";
repo = "lightkeeper";
rev = finalAttrs.version;
hash = "sha256-aGMWg6VQleKH/txlxpSw19QOotWZSqeW5Ve2SpWGhgA=";
rev = version;
hash = "sha256-Emyo4GBrR725jDxRsStC6/4F9mYnRo3S3QY0GeB/BvI=";
};
preConfigure = ''
cd lightkeeper
'';
meta = {
description = "Port of the Lighthouse plugin to GHIDRA";
description = "A port of the Lighthouse plugin to GHIDRA.";
homepage = "https://github.com/WorksButNotTested/lightkeeper";
license = lib.licenses.asl20;
};
})
}

2
pkgs/reverse-engineering/ghidra/extensions/machinelearning/default.nix → pkgs/ghidra-xenia-v2/extensions/machinelearning/default.nix
View File

@ -8,7 +8,7 @@ buildGhidraExtension {
pname = "machinelearning";
version = lib.getVersion ghidra;
src = "${ghidra.lib}/lib/ghidra/Extensions/Ghidra/${ghidra.distroPrefix}_MachineLearning.zip";
src = "${ghidra}/lib/ghidra/Extensions/Ghidra/${ghidra.distroPrefix}_MachineLearning.zip";
dontUnpack = true;
# Built as part ghidra

0
pkgs/reverse-engineering/ghidra/extensions/ret-sync/default.nix → pkgs/ghidra-xenia-v2/extensions/ret-sync/default.nix
View File

2
pkgs/reverse-engineering/ghidra/extensions/sleighdevtools/default.nix → pkgs/ghidra-xenia-v2/extensions/sleighdevtools/default.nix
View File

@ -9,7 +9,7 @@ buildGhidraExtension {
pname = "sleighdevtools";
version = lib.getVersion ghidra;
src = "${ghidra.lib}/lib/ghidra/Extensions/Ghidra/${ghidra.distroPrefix}_SleighDevTools.zip";
src = "${ghidra}/lib/ghidra/Extensions/Ghidra/${ghidra.distroPrefix}_SleighDevTools.zip";
dontUnpack = true;
# Built as part ghidra

6
pkgs/reverse-engineering/ghidra/with-extensions.nix → pkgs/ghidra-xenia-v2/with-extensions.nix
View File

@ -29,10 +29,8 @@ let
nativeBuildInputs = [
makeBinaryWrapper
] ++ lib.optional stdenv.hostPlatform.isDarwin desktopToDarwinBundle;
postBuild = ''
# Prevent attempted creation of plugin lock files in the Nix store.
touch $out/lib/ghidra/Ghidra/.dbDirLock
postBuild =
''
makeWrapper '${ghidra}/bin/ghidra' "$out/bin/ghidra" \
--set NIX_GHIDRAHOME "$out/lib/ghidra/Ghidra"
makeWrapper '${ghidra}/bin/ghidra-analyzeHeadless' "$out/bin/ghidra-analyzeHeadless" \

5
pkgs/kicad-xenia/addons/default.nix Normal file
View File

@ -0,0 +1,5 @@
{ kicad }:
{
kikit = kicad.callPackage ./kikit.nix { addonName = "kikit"; };
kikit-library = kicad.callPackage ./kikit.nix { addonName = "kikit-library"; };
}

52
pkgs/kicad-xenia/addons/kikit.nix Normal file
View File

@ -0,0 +1,52 @@
# For building the multiple addons that are in the kikit repo.
{ stdenv
, bc
, kikit
, zip
, python3
, addonName
, addonPath
}:
let
# This python is only used when building the package, it's not the python
# environment that will ultimately run the code packaged here. The python env defined
# in KiCad will import the python code packaged here when KiCad starts up.
python = python3.withPackages (ps: with ps; [ click ]);
kikit-module = python3.pkgs.toPythonModule (kikit.override { inherit python3; });
# The following different addons can be built from the same source.
targetSpecs = {
"kikit" = {
makeTarget = "pcm-kikit";
resultZip = "pcm-kikit.zip";
description = "KiCad plugin and a CLI tool to automate several tasks in a standard KiCad workflow";
};
"kikit-library" = {
makeTarget = "pcm-lib";
resultZip = "pcm-kikit-lib.zip";
description = "KiKit uses these symbols and footprints to annotate your boards (e.g., to place a tab in a panel).";
};
};
targetSpec = targetSpecs.${addonName};
in
stdenv.mkDerivation {
name = "kicadaddon-${addonName}";
inherit (kikit-module) src version;
nativeBuildInputs = [ python bc zip ];
propagatedBuildInputs = [ kikit-module ];
buildPhase = ''
patchShebangs scripts/setJson.py
make ${targetSpec.makeTarget}
'';
installPhase = ''
mkdir $out
mv build/${targetSpec.resultZip} $out/${addonPath}
'';
meta = kikit-module.meta // {
description = targetSpec.description;
};
}

211
pkgs/kicad-xenia/base.nix Normal file
View File

@ -0,0 +1,211 @@
{ lib
, stdenv
, cmake
, libGLU
, libGL
, zlib
, wxGTK
, gtk3
, libX11
, gettext
, glew
, glm
, cairo
, curl
, openssl
, boost
, pkg-config
, doxygen
, graphviz
, pcre
, libpthreadstubs
, libXdmcp
, unixODBC
, libgit2
, libsecret
, libgcrypt
, libgpg-error
, util-linux
, libselinux
, libsepol
, libthai
, libdatrie
, libxkbcommon
, libepoxy
, dbus
, at-spi2-core
, libXtst
, pcre2
, libdeflate
, swig4
, python
, wxPython
, opencascade-occt_7_6
, libngspice
, valgrind
, stable
, testing
, baseName
, kicadSrc
, kicadVersion
, withNgspice
, withScripting
, withI18n
, debug
, sanitizeAddress
, sanitizeThreads
}:
assert lib.assertMsg (!(sanitizeAddress && sanitizeThreads))
"'sanitizeAddress' and 'sanitizeThreads' are mutually exclusive, use one.";
assert testing -> !stable
-> throw "testing implies stable and cannot be used with stable = false";
let
opencascade-occt = opencascade-occt_7_6;
inherit (lib) optional optionals optionalString;
in
stdenv.mkDerivation rec {
pname = "kicad-base";
version = if (stable) then kicadVersion else builtins.substring 0 10 src.rev;
src = kicadSrc;
patches = [
# upstream issue 12941 (attempted to upstream, but appreciably unacceptable)
./writable.patch
# https://gitlab.com/kicad/code/kicad/-/issues/15687
./runtime_stock_data_path.patch
];
# tagged releases don't have "unknown"
# kicad testing and nightlies use git describe --dirty
# nix removes .git, so its approximated here
postPatch = lib.optionalString (!stable || testing) ''
substituteInPlace cmake/KiCadVersion.cmake \
--replace "unknown" "${builtins.substring 0 10 src.rev}"
substituteInPlace cmake/CreateGitVersionHeader.cmake \
--replace "0000000000000000000000000000000000000000" "${src.rev}"
'';
makeFlags = optionals (debug) [ "CFLAGS+=-Og" "CFLAGS+=-ggdb" ];
cmakeFlags = [
"-DKICAD_USE_EGL=ON"
"-DOCC_INCLUDE_DIR=${opencascade-occt}/include/opencascade"
# https://gitlab.com/kicad/code/kicad/-/issues/17133
"-DCMAKE_CTEST_ARGUMENTS='--exclude-regex;qa_spice'"
]
++ optional (stdenv.hostPlatform.system == "aarch64-linux")
"-DCMAKE_CTEST_ARGUMENTS=--exclude-regex;'qa_spice|qa_cli'"
++ optional (stable && !withNgspice) "-DKICAD_SPICE=OFF"
++ optionals (!withScripting) [
"-DKICAD_SCRIPTING_WXPYTHON=OFF"
]
++ optionals (withI18n) [
"-DKICAD_BUILD_I18N=ON"
]
++ optionals (!doInstallCheck) [
"-DKICAD_BUILD_QA_TESTS=OFF"
]
++ optionals (debug) [
"-DKICAD_STDLIB_DEBUG=ON"
"-DKICAD_USE_VALGRIND=ON"
]
++ optionals (sanitizeAddress) [
"-DKICAD_SANITIZE_ADDRESS=ON"
]
++ optionals (sanitizeThreads) [
"-DKICAD_SANITIZE_THREADS=ON"
];
cmakeBuildType = if debug then "Debug" else "Release";
nativeBuildInputs = [
cmake
doxygen
graphviz
pkg-config
libgit2
libsecret
libgcrypt
libgpg-error
]
# wanted by configuration on linux, doesn't seem to affect performance
# no effect on closure size
++ optionals (stdenv.isLinux) [
util-linux
libselinux
libsepol
libthai
libdatrie
libxkbcommon
libepoxy
dbus
at-spi2-core
libXtst
pcre2
];
buildInputs = [
libGLU
libGL
zlib
libX11
wxGTK
gtk3
pcre
libXdmcp
gettext
glew
glm
libpthreadstubs
cairo
curl
openssl
boost
swig4
python
unixODBC
libdeflate
opencascade-occt
]
++ optional (withScripting) wxPython
++ optional (withNgspice) libngspice
++ optional (debug) valgrind;
# some ngspice tests attempt to write to $HOME/.cache/
# this could be and was resolved with XDG_CACHE_HOME = "$TMP";
# but failing tests still attempt to create $HOME
# and the newer CLI tests seem to also use $HOME...
HOME = "$TMP";
# debug builds fail all but the python test
doInstallCheck = !(debug);
installCheckTarget = "test";
nativeInstallCheckInputs = [
(python.withPackages(ps: with ps; [
numpy
pytest
cairosvg
pytest-image-diff
]))
];
dontStrip = debug;
meta = {
description = "Just the built source without the libraries";
longDescription = ''
Just the build products, the libraries are passed via an env var in the wrapper, default.nix
'';
homepage = "https://www.kicad.org/";
license = lib.licenses.gpl3Plus;
platforms = lib.platforms.all;
};
}

298
pkgs/kicad-xenia/default.nix Normal file
View File

@ -0,0 +1,298 @@
{ lib, stdenv
, runCommand
, newScope
, fetchFromGitLab
, fetchgit
, makeWrapper
, symlinkJoin
, callPackage
, callPackages
, gnome
, dconf
, gtk3
, wxGTK32
, librsvg
, cups
, gsettings-desktop-schemas
, hicolor-icon-theme
, unzip
, jq
, pname ? "kicad"
, stable ? true
, testing ? false
, withNgspice ? !stdenv.isDarwin
, libngspice
, withScripting ? true
, python3
, addons ? [ ]
, debug ? false
, sanitizeAddress ? false
, sanitizeThreads ? false
, with3d ? true
, withI18n ? true
, srcs ? { }
}:
# `addons`: https://dev-docs.kicad.org/en/addons/
#
# ```nix
# kicad = pkgs.kicad.override {
# addons = with pkgs.kicadAddons; [ kikit kikit-library ];
# };
# ```
# The `srcs` parameter can be used to override the kicad source code
# and all libraries, which are otherwise inaccessible
# to overlays since most of the kicad build expression has been
# refactored into base.nix, most of the library build expressions have
# been refactored into libraries.nix. Overrides are only applied when
# building `kicad-unstable`. The `srcs` parameter has
# no effect for stable `kicad`. `srcs` takes an attribute set in which
# any of the following attributes are meaningful (though none are
# mandatory): "kicad", "kicadVersion", "symbols", "templates",
# "footprints", "packages3d", and "libVersion". "kicadVersion" and
# "libVersion" should be set to a string with the desired value for
# the version attribute in kicad's `mkDerivation` and the version
# attribute in any of the library's `mkDerivation`, respectively.
# "kicad", "symbols", "templates", "footprints", and "packages3d"
# should be set to an appropriate fetcher (e.g. `fetchFromGitLab`).
# So, for example, a possible overlay for kicad is:
#
# final: prev:
# {
# kicad-unstable = (prev.kicad-unstable.override {
# srcs = {
# kicadVersion = "2020-10-08";
# kicad = prev.fetchFromGitLab {
# group = "kicad";
# owner = "code";
# repo = "kicad";
# rev = "fd22fe8e374ce71d57e9f683ba996651aa69fa4e";
# sha256 = "sha256-F8qugru/jU3DgZSpQXQhRGNFSk0ybFRkpyWb7HAGBdc=";
# };
# };
# });
# }
let
baseName = if (testing) then "kicad-testing"
else if (stable) then "kicad"
else "kicad-unstable";
versionsImport = import ./versions.nix;
# versions.nix does not provide us with version, src and rev. We
# need to turn this into approprate fetcher calls.
#kicadSrcFetch = fetchFromGitLab {
# group = "kicad";
# owner = "code";
# repo = "kicad";
# rev = versionsImport.${baseName}.kicadVersion.src.rev;
# sha256 = versionsImport.${baseName}.kicadVersion.src.sha256;
#};
kicadSrcFetch = fetchgit {
url = "https://git.lain.faith/haskal/kicad.git";
rev = versionsImport.${baseName}.kicadVersion.src.rev;
sha256 = versionsImport.${baseName}.kicadVersion.src.sha256;
};
libSrcFetch = name: fetchFromGitLab {
group = "kicad";
owner = "libraries";
repo = "kicad-${name}";
rev = versionsImport.${baseName}.libVersion.libSources.${name}.rev;
sha256 = versionsImport.${baseName}.libVersion.libSources.${name}.sha256;
};
# only override `src` or `version` if building `kicad-unstable` with
# the appropriate attribute defined in `srcs`.
srcOverridep = attr: (!stable && builtins.hasAttr attr srcs);
# use default source and version (as defined in versions.nix) by
# default, or use the appropriate attribute from `srcs` if building
# unstable with `srcs` properly defined.
kicadSrc =
if srcOverridep "kicad" then srcs.kicad
else kicadSrcFetch;
kicadVersion =
if srcOverridep "kicadVersion" then srcs.kicadVersion
else versionsImport.${baseName}.kicadVersion.version;
libSrc = name: if srcOverridep name then srcs.${name} else libSrcFetch name;
# TODO does it make sense to only have one version for all libs?
libVersion =
if srcOverridep "libVersion" then srcs.libVersion
else versionsImport.${baseName}.libVersion.version;
wxGTK = wxGTK32;
python = python3;
wxPython = python.pkgs.wxpython;
addonPath = "addon.zip";
addonsDrvs = map (pkg: pkg.override { inherit addonPath python3; }) addons;
addonsJoined =
runCommand "addonsJoined"
{
inherit addonsDrvs;
nativeBuildInputs = [ unzip jq ];
} ''
mkdir $out
for pkg in $addonsDrvs; do
unzip $pkg/addon.zip -d unpacked
folder_name=$(jq .identifier unpacked/metadata.json --raw-output | tr . _)
for d in unpacked/*; do
if [ -d "$d" ]; then
dest=$out/share/kicad/scripting/$(basename $d)/$folder_name
mkdir -p $(dirname $dest)
mv $d $dest
fi
done
rm -r unpacked
done
'';
inherit (lib) concatStringsSep flatten optionalString optionals;
in
stdenv.mkDerivation rec {
# Common libraries, referenced during runtime, via the wrapper.
passthru.libraries = callPackages ./libraries.nix { inherit libSrc; };
passthru.callPackage = newScope { inherit addonPath python3; };
base = callPackage ./base.nix {
inherit stable testing baseName;
inherit kicadSrc kicadVersion;
inherit wxGTK python wxPython;
inherit withNgspice withScripting withI18n;
inherit debug sanitizeAddress sanitizeThreads;
};
inherit pname;
version = if (stable) then kicadVersion else builtins.substring 0 10 src.src.rev;
src = base;
dontUnpack = true;
dontConfigure = true;
dontBuild = true;
dontFixup = true;
pythonPath = optionals (withScripting)
[ wxPython python.pkgs.six python.pkgs.requests ] ++ addonsDrvs;
nativeBuildInputs = [ makeWrapper ]
++ optionals (withScripting)
[ python.pkgs.wrapPython ];
# KICAD7_TEMPLATE_DIR only works with a single path (it does not handle : separated paths)
# but it's used to find both the templates and the symbol/footprint library tables
# https://gitlab.com/kicad/code/kicad/-/issues/14792
template_dir = symlinkJoin {
name = "KiCad_template_dir";
paths = with passthru.libraries; [
"${templates}/share/kicad/template"
"${footprints}/share/kicad/template"
"${symbols}/share/kicad/template"
];
};
# We are emulating wrapGAppsHook3, along with other variables to the wrapper
makeWrapperArgs = with passthru.libraries; [
"--prefix XDG_DATA_DIRS : ${base}/share"
"--prefix XDG_DATA_DIRS : ${hicolor-icon-theme}/share"
"--prefix XDG_DATA_DIRS : ${gnome.adwaita-icon-theme}/share"
"--prefix XDG_DATA_DIRS : ${gtk3}/share/gsettings-schemas/${gtk3.name}"
"--prefix XDG_DATA_DIRS : ${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}"
# wrapGAppsHook3 did these two as well, no idea if it matters...
"--prefix XDG_DATA_DIRS : ${cups}/share"
"--prefix GIO_EXTRA_MODULES : ${dconf}/lib/gio/modules"
# required to open a bug report link in firefox-wayland
"--set-default MOZ_DBUS_REMOTE 1"
"--set-default KICAD8_FOOTPRINT_DIR ${footprints}/share/kicad/footprints"
"--set-default KICAD8_SYMBOL_DIR ${symbols}/share/kicad/symbols"
"--set-default KICAD8_TEMPLATE_DIR ${template_dir}"
]
++ optionals (addons != [ ]) (
let stockDataPath = symlinkJoin {
name = "kicad_stock_data_path";
paths = [
"${base}/share/kicad"
"${addonsJoined}/share/kicad"
];
};
in
[ "--set-default NIX_KICAD8_STOCK_DATA_PATH ${stockDataPath}" ]
)
++ optionals (with3d)
[
"--set-default KICAD8_3DMODEL_DIR ${packages3d}/share/kicad/3dmodels"
]
++ optionals (withNgspice) [ "--prefix LD_LIBRARY_PATH : ${libngspice}/lib" ]
# infinisil's workaround for #39493
++ [ "--set GDK_PIXBUF_MODULE_FILE ${librsvg}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache" ]
;
# why does $makeWrapperArgs have to be added explicitly?
# $out and $program_PYTHONPATH don't exist when makeWrapperArgs gets set?
installPhase =
let
bin = if stdenv.isDarwin then "*.app/Contents/MacOS" else "bin";
tools = [ "kicad" "pcbnew" "eeschema" "gerbview" "pcb_calculator" "pl_editor" "bitmap2component" ];
utils = [ "dxf2idf" "idf2vrml" "idfcyl" "idfrect" "kicad-cli" ];
in
(concatStringsSep "\n"
(flatten [
"runHook preInstall"
(optionalString (withScripting) "buildPythonPath \"${base} $pythonPath\" \n")
# wrap each of the directly usable tools
(map
(tool: "makeWrapper ${base}/${bin}/${tool} $out/bin/${tool} $makeWrapperArgs"
+ optionalString (withScripting) " --set PYTHONPATH \"$program_PYTHONPATH\""
)
tools)
# link in the CLI utils
(map (util: "ln -s ${base}/${bin}/${util} $out/bin/${util}") utils)
"runHook postInstall"
])
)
;
postInstall = ''
mkdir -p $out/share
ln -s ${base}/share/applications $out/share/applications
ln -s ${base}/share/icons $out/share/icons
ln -s ${base}/share/mime $out/share/mime
ln -s ${base}/share/metainfo $out/share/metainfo
'';
passthru.updateScript = {
command = [ ./update.sh "${pname}" ];
supportedFeatures = [ "commit" ];
};
meta = rec {
description = (if (stable)
then "Open Source Electronics Design Automation suite"
else if (testing) then "Open Source EDA suite, latest on stable branch"
else "Open Source EDA suite, latest on master branch")
+ (lib.optionalString (!with3d) ", without 3D models");
homepage = "https://www.kicad.org/";
longDescription = ''
KiCad is an open source software suite for Electronic Design Automation.
The Programs handle Schematic Capture, and PCB Layout with Gerber output.
'';
license = lib.licenses.gpl3Plus;
maintainers = with lib.maintainers; [ evils ];
platforms = lib.platforms.all;
broken = stdenv.isDarwin;
mainProgram = "kicad";
};
}

39
pkgs/kicad-xenia/libraries.nix Normal file
View File

@ -0,0 +1,39 @@
{ lib, stdenv
, cmake
, gettext
, libSrc
, stepreduce
, parallel
, zip
}:
let
mkLib = name:
stdenv.mkDerivation {
pname = "kicad-${name}";
version = builtins.substring 0 10 (libSrc name).rev;
src = libSrc name;
nativeBuildInputs = [ cmake ]
++ lib.optionals (name == "packages3d") [
stepreduce
parallel
zip
];
postInstall = lib.optional (name == "packages3d") ''
find $out -type f -name '*.step' | parallel 'stepreduce {} {} && zip -9 {.}.stpZ {} && rm {}'
'';
meta = rec {
license = lib.licenses.cc-by-sa-40;
platforms = lib.platforms.all;
};
};
in
{
symbols = mkLib "symbols";
templates = mkLib "templates";
footprints = mkLib "footprints";
packages3d = mkLib "packages3d";
}

15
pkgs/kicad-xenia/runtime_stock_data_path.patch Normal file
View File

@ -0,0 +1,15 @@
diff --git a/common/paths.cpp b/common/paths.cpp
index a74cdd9..790cc58 100644
--- a/common/paths.cpp
+++ b/common/paths.cpp
@@ -151,6 +151,10 @@ wxString PATHS::GetStockDataPath( bool aRespectRunFromBuildDir )
{
wxString path;
+ if( wxGetEnv( wxT( "NIX_KICAD8_STOCK_DATA_PATH" ), &path ) ) {
+ return path;
+ }
+
if( aRespectRunFromBuildDir && wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )
{
// Allow debugging from build dir by placing relevant files/folders in the build root

260
pkgs/kicad-xenia/update.sh Executable file
View File

@ -0,0 +1,260 @@
#!/usr/bin/env nix-shell
#!nix-shell -i bash -p coreutils git nix curl jq
# shellcheck shell=bash enable=all
set -e
shopt -s inherit_errexit
# this script will generate versions.nix in the right location
# this should contain the versions' revs and hashes
# the stable revs are stored only for ease of skipping
# by default nix-prefetch-url uses XDG_RUNTIME_DIR as tmp
# which is /run/user/1000, which defaults to 10% of your RAM
# unless you have over 64GB of ram that'll be insufficient
# resulting in "tar: no space left on device" for packages3d
# hence:
export TMPDIR=/tmp
# if something goes unrepairably wrong, run 'update.sh all clean'
# TODO
# support parallel instances for each pname
# currently risks reusing old data
# no getting around manually checking if the build product works...
# if there is, default to commiting?
# won't work when running in parallel?
# remove items left in /nix/store?
# reuse hashes of already checked revs (to avoid redownloading testing's packages3d)
# nixpkgs' update.nix passes in UPDATE_NIX_PNAME to indicate which package is being updated
# assigning a default value to that as shellcheck doesn't like the use of unassigned variables
: "${UPDATE_NIX_PNAME:=""}"
# update.nix can also parse JSON output of this script to formulate a commit
# this requires we collect the version string in the old versions.nix for the updated package
old_version=""
new_version=""
# get the latest tag that isn't an RC or *.99
latest_tags="$(git ls-remote --tags --sort -version:refname https://gitlab.com/kicad/code/kicad.git)"
# using a scratch variable to ensure command failures get caught (SC2312)
scratch="$(grep -o 'refs/tags/[0-9]*\.[0-9]*\.[0-9]*$' <<< "${latest_tags}")"
scratch="$(grep -ve '\.99' -e '\.9\.9' <<< "${scratch}")"
scratch="$(sed -n '1p' <<< "${scratch}")"
latest_tag="$(cut -d '/' -f 3 <<< "${scratch}")"
# get the latest branch name for testing
branches="$(git ls-remote --heads --sort -version:refname https://gitlab.com/kicad/code/kicad.git)"
scratch="$(grep -o 'refs/heads/[0-9]*\.[0-9]*$' <<< "${branches}")"
scratch="$(sed -n '1p' <<< "${scratch}")"
testing_branch="$(cut -d '/' -f 3 <<< "${scratch}")"
# "latest_tag" and "master" directly refer to what we want
# "testing" uses "testing_branch" found above
all_versions=( "${latest_tag}" testing master )
prefetch="nix-prefetch-url --unpack --quiet"
clean=""
check_stable=""
check_testing=1
check_unstable=1
commit=""
for arg in "$@" "${UPDATE_NIX_PNAME}"; do
case "${arg}" in
help|-h|--help) echo "Read me!" >&2; exit 1; ;;
kicad|kicad-small|release|tag|stable|5*|6*|7*|8*) check_stable=1; check_testing=""; check_unstable="" ;;
*testing|kicad-testing-small) check_testing=1; check_unstable="" ;;
*unstable|*unstable-small|master|main) check_unstable=1; check_testing="" ;;
latest|now|today) check_unstable=1; check_testing=1 ;;
all|both|full) check_stable=1; check_testing=1; check_unstable=1 ;;
clean|fix|*fuck) check_stable=1; check_testing=1; check_unstable=1; clean=1 ;;
commit) commit=1 ;;
*) ;;
esac
done
here="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
commit_date() {
gitlab_json="$(curl -s https://gitlab.com/api/v4/projects/kicad%2Fcode%2Fkicad/repository/commits/"$1")"
commit_created="$(jq .created_at --raw-output <<< "${gitlab_json}")"
date --date="${commit_created}" --iso-8601 --utc
}
file="${here}/versions.nix"
# just in case this runs in parallel
tmp="${here}/,versions.nix.${RANDOM}"
libs=( symbols templates footprints packages3d )
get_rev() {
git ls-remote "$@"
}
gitlab="https://gitlab.com/kicad"
# append commit hash or tag
src_pre="https://gitlab.com/api/v4/projects/kicad%2Fcode%2Fkicad/repository/archive.tar.gz?sha="
lib_pre="https://gitlab.com/api/v4/projects/kicad%2Flibraries%2Fkicad-"
lib_mid="/repository/archive.tar.gz?sha="
# number of items updated
count=0
printf "Latest tag is %s\n" "${latest_tag}" >&2
if [[ ! -f ${file} ]]; then
echo "No existing file, generating from scratch" >&2
check_stable=1; check_testing=1; check_unstable=1; clean=1
fi
printf "Writing %s\n" "${tmp}" >&2
# not a dangling brace, grouping the output to redirect to file
{
printf "# This file was generated by update.sh\n\n"
printf "{\n"
for version in "${all_versions[@]}"; do
src_version=${version};
lib_version=${version};
# testing is the stable branch on the main repo
# but the libraries don't have such a branch
# only the latest release tag and a master branch
if [[ ${version} == "testing" ]]; then
src_version=${testing_branch};
lib_version=${latest_tag};
fi
if [[ ${version} == "master" ]]; then
pname="kicad-unstable"
elif [[ ${version} == "testing" ]]; then
pname="kicad-testing"
else
pname="kicad"
fi
# skip a version if we don't want to check it
if [[ (-n ${check_stable} && ${version} != "master" && ${version} != "testing") \
|| (-n ${check_testing} && ${version} == "testing") \
|| (-n ${check_unstable} && ${version} == "master" ) ]]; then
now=$(commit_date "${src_version}")
if [[ ${version} == "master" ]]; then
pname="kicad-unstable"
new_version="${now}"
elif [[ ${version} == "testing" ]]; then
pname="kicad-testing"
new_version="${testing_branch}-${now}"
else
pname="kicad"
new_version="${version}"
fi
printf "\nChecking %s\n" "${pname}" >&2
printf "%2s\"%s\" = {\n" "" "${pname}"
printf "%4skicadVersion = {\n" ""
printf "%6sversion =\t\t\t\"%s\";\n" "" "${new_version}"
printf "%6ssrc = {\n" ""
echo "Checking src" >&2
scratch="$(get_rev "${gitlab}"/code/kicad.git "${src_version}")"
src_rev="$(cut -f1 <<< "${scratch}")"
has_rev="$(grep -sm 1 "\"${pname}\"" -A 4 "${file}" | grep -sm 1 "${src_rev}" || true)"
has_hash="$(grep -sm 1 "\"${pname}\"" -A 5 "${file}" | grep -sm 1 "sha256" || true)"
old_version="$(grep -sm 1 "\"${pname}\"" -A 3 "${file}" | grep -sm 1 "version" | awk -F "\"" '{print $2}' || true)"
if [[ -n ${has_rev} && -n ${has_hash} && -z ${clean} ]]; then
echo "Reusing old ${pname}.src.sha256, already latest .rev at ${old_version}" >&2
scratch=$(grep -sm 1 "\"${pname}\"" -A 5 "${file}")
grep -sm 1 "rev" -A 1 <<< "${scratch}"
else
prefetched="$(${prefetch} "${src_pre}${src_rev}")"
printf "%8srev =\t\t\t\"%s\";\n" "" "${src_rev}"
printf "%8ssha256 =\t\t\"%s\";\n" "" "${prefetched}"
count=$((count+1))
fi
printf "%6s};\n" ""
printf "%4s};\n" ""
printf "%4slibVersion = {\n" ""
printf "%6sversion =\t\t\t\"%s\";\n" "" "${new_version}"
printf "%6slibSources = {\n" ""
for lib in "${libs[@]}"; do
echo "Checking ${lib}" >&2
url="${gitlab}/libraries/kicad-${lib}.git"
scratch="$(get_rev "${url}" "${lib_version}")"
scratch="$(cut -f1 <<< "${scratch}")"
lib_rev="$(tail -n1 <<< "${scratch}")"
has_rev="$(grep -sm 1 "\"${pname}\"" -A 19 "${file}" | grep -sm 1 "${lib_rev}" || true)"
has_hash="$(grep -sm 1 "\"${pname}\"" -A 20 "${file}" | grep -sm 1 "${lib}.sha256" || true)"
if [[ -n ${has_rev} && -n ${has_hash} && -z ${clean} ]]; then
echo "Reusing old kicad-${lib}-${new_version}.src.sha256, already latest .rev" >&2
scratch="$(grep -sm 1 "\"${pname}\"" -A 20 "${file}")"
grep -sm 1 "${lib}" -A 1 <<< "${scratch}"
else
prefetched="$(${prefetch} "${lib_pre}${lib}${lib_mid}${lib_rev}")"
printf "%8s%s.rev =\t" "" "${lib}"
case "${lib}" in
symbols|templates) printf "\t" ;; *) ;;
esac
printf "\"%s\";\n" "${lib_rev}"
printf "%8s%s.sha256 =\t\"%s\";\n" "" "${lib}" "${prefetched}"
count=$((count+1))
fi
done
printf "%6s};\n" ""
printf "%4s};\n" ""
printf "%2s};\n" ""
else
printf "\nReusing old %s\n" "${pname}" >&2
grep -sm 1 "\"${pname}\"" -A 21 "${file}"
fi
done
printf "}\n"
} > "${tmp}"
if grep '""' "${tmp}"; then
echo "empty value detected, out of space?" >&2
exit "1"
fi
mv "${tmp}" "${file}"
printf "\nFinished\nMoved output to %s\n\n" "${file}" >&2
if [[ ${count} -gt 0 ]]; then
if [[ ${count} -gt 1 ]]; then s="s"; else s=""; fi
echo "${count} revision${s} changed" >&2
if [[ -n ${commit} ]]; then
git commit -am "$(printf "kicad: automatic update of %s item%s\n" "${count}" "${s}")"
fi
echo "Please confirm the new versions.nix works before making a PR." >&2
else
echo "No changes, those checked are up to date" >&2
fi
# using UPDATE_NIX_ATTR_PATH to detect if this is being called from update.nix
# and output JSON to describe the changes
if [[ -n ${UPDATE_NIX_ATTR_PATH} ]]; then
if [[ ${count} -eq 0 ]]; then echo "[{}]"; exit 0; fi
jq -n \
--arg attrpath "${UPDATE_NIX_PNAME}" \
--arg oldversion "${old_version}" \
--arg newversion "${new_version}" \
--arg file "${file}" \
'[{
"attrPath": $attrpath,
"oldVersion": $oldversion,
"newVersion": $newversion,
"files": [ $file ]
}]'
fi

70
pkgs/kicad-xenia/versions.nix Normal file
View File

@ -0,0 +1,70 @@
# This file was generated by update.sh
{
"kicad" = {
kicadVersion = {
version = "8.0.2";
src = {
rev = "2d5434e9abf570ffd19b22c90963ea71cfb91d3d";
sha256 = "1n1jj7559xd4ib4c6ybya75a5hbarnkfy8gxzxfw58wdb4lxxmzz";
};
};
libVersion = {
version = "8.0.2";
libSources = {
symbols.rev = "099ac0c8ac402a685fde00b1369e34a116e29661";
symbols.sha256 = "0w333f89yw2m0zlpkg0k6hfwlj10snm8laihdjnsb22asyz4pbhn";
templates.rev = "2e2da58e02707d327d59d4101c401a82dc9a26f6";
templates.sha256 = "073a6cyvzzy0vmkj3ip4ziq7b7pcizs70nm5acw838dxghjfyv3v";
footprints.rev = "e8c30550cde4945cbe1bf30cccf0b3c1e2bda6c6";
footprints.sha256 = "10j8qjljc1fv8k4zp3zn0da33g57hn6pgrgmbgp18dsa539xvxcz";
packages3d.rev = "249f7947587529026e1676cd70c8d7493a8d8162";
packages3d.sha256 = "04gvfb54jhnww2qwrxc27wpyrvmjasdc4xhr0ridl7dglh4qcp35";
};
};
};
# "kicad-testing" = {
# kicadVersion = {
# version = "8.0-2024-02-23";
# src = {
# rev = "14d71c8ca6b48d2eb956bb069acf05a37b1b2652";
# sha256 = "0xqd0xbpnvsvba75526nwgzr8l2cfxy99sjmg13sjxfx7rq16kqi";
# };
# };
# libVersion = {
# version = "8.0-2024-02-23";
# libSources = {
# symbols.rev = "e228d4e8b295364e90e36c57f4023d8285ba88cd";
# symbols.sha256 = "049h2a7yn6ks8sybppixa872dbvyd0rwf9r6nixvdg6d13fl6rwf";
# templates.rev = "2e00c233b67e35323f90d04c190bf70237a252f2";
# templates.sha256 = "0m9bggz3cm27kqpjjwxy19mqzk0c69bywcjkqcni7kafr21c6k4z";
# footprints.rev = "6e5329a6d4aaa81290e23af3eba88f505c2f61b0";
# footprints.sha256 = "0ypjlbmzmcl3pha3q2361va70c988b1drxy8320gm66jkzfc21a1";
# packages3d.rev = "d1e521228d9f5888836b1a6a35fb05fb925456fa";
# packages3d.sha256 = "0lcy1av7ixg1f7arflk50jllpc1749sfvf3h62hkxsz97wkr97xj";
# };
# };
# };
# "kicad-unstable" = {
# kicadVersion = {
# version = "2024-02-23";
# src = {
# rev = "b7b64d959f37f00bb0d14b007c3b3908196e1024";
# sha256 = "1gl7mjqpmqq4m55z6crwb77983g00gi2161ichsc7hsfhs4c8grh";
# };
# };
# libVersion = {
# version = "2024-02-23";
# libSources = {
# symbols.rev = "8b0c343d8694fe0a968e5c4af69fd161bacf7da1";
# symbols.sha256 = "049h2a7yn6ks8sybppixa872dbvyd0rwf9r6nixvdg6d13fl6rwf";
# templates.rev = "0a6c4f798a68a5c639d54b4d3093460ab9267816";
# templates.sha256 = "0m9bggz3cm27kqpjjwxy19mqzk0c69bywcjkqcni7kafr21c6k4z";
# footprints.rev = "ded6b053460faae5783c538a38e91e2b4bddcf2e";
# footprints.sha256 = "035bf37n4vrihaj4zfdncisdx9fly1vya7lhkxhlsbv5blpi4a5y";
# packages3d.rev = "984667325076d4e50dab14e755aeacf97f42194c";
# packages3d.sha256 = "0lkaxv02h4sxrnm8zr17wl9d07mazlisad78r35gry741i362cdg";
# };
# };
# };
}

49
pkgs/kicad-xenia/writable.patch Normal file
View File

@ -0,0 +1,49 @@
commit 6a72fd032405515e468797be91b5a6ebcbbb5fd8
Author: Evils <evils.devils@protonmail.com>
Date: Wed Nov 23 19:49:13 2022 +0100
ensure new projects are writable
diff --git a/kicad/kicad_manager_frame.cpp b/kicad/kicad_manager_frame.cpp
index 7ee8090858..391514519c 100644
--- a/kicad/kicad_manager_frame.cpp
+++ b/kicad/kicad_manager_frame.cpp
@@ -638,6 +638,12 @@ void KICAD_MANAGER_FRAME::CreateNewProject( const wxFileName& aProjectFileName,
// wxFFile dtor will close the file
}
+
+ if( destFileName.IsOk() && !destFileName.IsFileWritable() )
+ {
+ destFileName.SetPermissions(0644);
+ }
+
}
}
diff --git a/kicad/project_template.cpp b/kicad/project_template.cpp
index bf951fcddb..2bef94326b 100644
--- a/kicad/project_template.cpp
+++ b/kicad/project_template.cpp
@@ -282,6 +282,21 @@ bool PROJECT_TEMPLATE::CreateProject( wxFileName& aNewProjectPath, wxString* aEr
result = false;
}
+ else if( !destFile.IsFileWritable() && !destFile.SetPermissions(0644) )
+ {
+ if( aErrorMsg )
+ {
+ if( !aErrorMsg->empty() )
+ *aErrorMsg += "\n";
+
+ wxString msg;
+
+ msg.Printf( _( "Cannot make file writable: '%s'." ), destFile.GetFullPath() );
+ *aErrorMsg += msg;
+ }
+
+ result = false;
+ }
}
return result;

25
pkgs/lix/lix-plugins/0001-implement-lix-support.patch
View File

@ -1,14 +1,14 @@
From d9e022548aff94e90914baa921ddb4cd939c0e5c Mon Sep 17 00:00:00 2001
From 10a24d7831f51549d8c05193a0fbc329cc327fbe Mon Sep 17 00:00:00 2001
From: xenia <xenia@awoo.systems>
Date: Sat, 21 Dec 2024 15:33:10 -0500
Subject: [PATCH] implement lix support
---
CMakeLists.txt | 27 ------------
extra-builtins.cc | 91 ++++++++++++++++-------------------------
meson.build | 18 ++++++++
CMakeLists.txt | 27 -------------
extra-builtins.cc | 87 ++++++++++++++++-------------------------
meson.build | 18 +++++++++
nix-plugins-config.h.in | 3 --
4 files changed, 53 insertions(+), 86 deletions(-)
4 files changed, 51 insertions(+), 84 deletions(-)
delete mode 100644 CMakeLists.txt
create mode 100644 meson.build
delete mode 100644 nix-plugins-config.h.in
@ -47,7 +47,7 @@ index 9674fe8..0000000
-
-install(TARGETS nix-extra-builtins DESTINATION lib/nix/plugins)
diff --git a/extra-builtins.cc b/extra-builtins.cc
index 3a0f90e..95aef5e 100644
index 3a0f90e..f2978f8 100644
--- a/extra-builtins.cc
+++ b/extra-builtins.cc
@@ -1,12 +1,8 @@
@ -68,12 +68,8 @@ index 3a0f90e..95aef5e 100644
using namespace nix;
@@ -21,42 +17,41 @@ static ExtraBuiltinsSettings extraBuiltinsSettings;
static GlobalConfig::Register rp(&extraBuiltinsSettings);
-static void extraBuiltins(EvalState & state, const PosIdx pos,
+static void extraBuiltins(EvalState & state,
@@ -24,39 +20,38 @@ static GlobalConfig::Register rp(&extraBuiltinsSettings);
static void extraBuiltins(EvalState & state, const PosIdx pos,
Value ** _args, Value & v)
{
- static auto extraBuiltinsFile = state.rootPath(CanonPath(extraBuiltinsSettings.extraBuiltinsFile.to_string()));
@ -134,9 +130,8 @@ index 3a0f90e..95aef5e 100644
+ Value* arg = state.ctx.mem.allocValue();
+ arg->mkAttrs(attrs);
v.mkApp(fun, arg);
- state.forceValue(v, pos);
state.forceValue(v, pos);
- } catch (FileNotFound &) {
+ state.forceValue(v, noPos);
+ } catch (SysError &) {
v.mkNull();
}
@ -195,5 +190,5 @@ index 459fea8..0000000
-#define NIX_CFLAGS_OTHER "@NIX_CFLAGS_OTHER@"
-#define BOOST_INCLUDE_DIR "@BOOST_INCLUDE_DIR@"
--
2.49.0
2.47.2

2
pkgs/lix/lix-plugins/default.nix
View File

@ -7,7 +7,6 @@
pkg-config,
lix,
capnproto,
boost182,
}: stdenv.mkDerivation {
name = "lix-plugins";
@ -31,7 +30,6 @@
buildInputs = [
lix
boost182
capnproto
];
meta = {

12
pkgs/ocaml/patdiff-bin/default.nix
View File

@ -1,12 +0,0 @@
{
runCommand,
patdiff,
}: runCommand "patdiff-bin-${patdiff.version}" {
nativeBuildInputs = [];
strictDeps = true;
meta.mainProgram = "patdiff";
} ''
mkdir -p $out
cp -r ${patdiff}/bin $out
cp -r ${patdiff}/share $out
''

3
pkgs/ocaml/ppx_unicode/default.nix
View File

@ -1,5 +1,4 @@
{
lib,
fetchgit,
buildDunePackage,
@ -25,7 +24,7 @@ buildDunePackage rec {
meta = {
description = "opinionated ppx for string literals";
homepage = "https://git.lain.faith/haskal/ppx_unicode";
license = lib.licenses.fyptl;
license = lib.licenses.cc-by-nc-sa-40;
maintainers = [];
platforms = with lib.platforms; linux ++ darwin;
};

1
pkgs/ocaml/xlog/default.nix
View File

@ -1,5 +1,4 @@
{
lib,
fetchgit,
buildDunePackage,

75
pkgs/reverse-engineering/binsync/binsync.nix
View File

@ -1,75 +0,0 @@
{
lib,
fetchFromGitHub,
buildPythonPackage,
setuptools,
libbs,
filelock,
gitpython,
prompt-toolkit,
pycparser,
sortedcontainers,
toml,
tqdm,
ply,
wordfreq,
pyside6,
pytestCheckHook,
pytest-qt,
}: buildPythonPackage rec {
pname = "binsync";
version = "5.7.10+dev";
pyproject = true;
src = fetchFromGitHub {
owner = "binsync";
repo = "binsync";
rev = "e67da5ab9cddc2743f7462c9543ba7100e25eeb5";
hash = "sha256-QDOfbo2yjfjLsLILMhl/ckKwXDusXfE8+YmFpW5djN0=";
};
build-system = [ setuptools ];
dependencies = [
libbs
filelock
gitpython
prompt-toolkit
pycparser
sortedcontainers
toml
tqdm
ply
wordfreq
];
optional-dependencies = {
ghidra = [ pyside6 ];
};
nativeCheckInputs = [
pytestCheckHook
pytest-qt
pyside6
];
disabledTestPaths = [
# Test tries to import angrmanagement
"tests/test_angr_gui.py"
];
pythonImportsCheck = [ "binsync" ];
meta = {
description = "Reversing plugin for cross-decompiler collaboration, built on git";
homepage = "https://github.com/binsync/binsync";
changelog = "https://github.com/binsync/binsync/releases/tag/${src.tag}";
license = lib.licenses.bsd2;
};
}

77
pkgs/reverse-engineering/binsync/libbs.nix
View File

@ -1,77 +0,0 @@
{
lib,
fetchFromGitHub,
buildPythonPackage,
setuptools,
filelock,
ghidra-bridge,
jfx-bridge,
networkx,
platformdirs,
prompt-toolkit,
psutil,
pycparser,
pyhidra,
toml,
tqdm,
ply,
pytestCheckHook,
writableTmpDirAsHomeHook,
}: buildPythonPackage rec {
pname = "libbs";
version = "2.16.4+dev";
pyproject = true;
src = fetchFromGitHub {
owner = "binsync";
repo = "libbs";
rev = "0ce5c351cc81c1a0120f763aeba584fdb9dc2820";
hash = "sha256-if27Tg5S0Esrw9xHi6nr+kDIw4OTz7yZ2256/4Kbkeo=";
};
build-system = [ setuptools ];
dependencies = [
filelock
ghidra-bridge
jfx-bridge
networkx
platformdirs
prompt-toolkit
psutil
pycparser
pyhidra
toml
tqdm
ply
];
nativeCheckInputs = [
pytestCheckHook
writableTmpDirAsHomeHook
];
pythonImportsCheck = [ "libbs" ];
disabledTests = [
"test_change_watcher_plugin_cli"
"test_ghidra_artifact_watchers"
"TestHeadlessInterfaces"
];
disabledTestPaths = [
"tests/test_decompilers.py"
"tests/test_remote_ghidra.py"
];
meta = {
description = "Library for writing plugins in any decompiler: includes API lifting, common data formatting, and GUI abstraction";
homepage = "https://github.com/binsync/libbs";
changelog = "https://github.com/binsync/libbs/releases/tag/${src.tag}";
license = lib.licenses.bsd2;
};
}

46
pkgs/reverse-engineering/ghidra/extensions/binsync/default.nix
View File

@ -1,46 +0,0 @@
{
lib,
fetchFromGitHub,
buildGhidraScripts,
runCommand,
rsync,
python311,
}: let
python = python311;
libbs_path = "${python.pkgs.libbs}/${python.sitePackages}";
binsync_path = "${python.pkgs.binsync}/${python.sitePackages}";
binsync_env = python.withPackages (ps: with ps; ([
binsync
] ++ binsync.optional-dependencies.ghidra));
in buildGhidraScripts {
pname = "BinSync";
inherit (python.pkgs.binsync) version;
src = runCommand "binsync-ghidra-scripts" {
nativeBuildInputs = [ rsync ];
strictDeps = true;
} ''
mkdir -p $out
rsync -r \
--exclude='__pycache__' \
--exclude='/__init__.py' \
${libbs_path}/libbs/decompiler_stubs/ghidra_libbs/. $out/.
cp ${binsync_path}/binsync/binsync_plugin.py $out
'';
postPatch = ''
substituteInPlace binsync_plugin.py \
--replace-fail 'plugin_command = "binsync -s ghidra"' \
'plugin_command = "${lib.getExe' binsync_env "binsync"} -s ghidra"'
'';
meta = {
description = "Reversing plugin for cross-decompiler collaboration, built on git";
homepage = "https://github.com/binsync/binsync";
license = lib.licenses.bsd2;
};
}

39
pkgs/reverse-engineering/ghidra/extensions/ghidra-delinker-extension/default.nix
View File

@ -1,39 +0,0 @@
{
lib,
buildGhidraExtension,
gradle,
fetchFromGitHub,
}:
buildGhidraExtension (finalAttrs: {
pname = "ghidra-delinker-extension";
version = "0.5.1";
src = fetchFromGitHub {
owner = "boricj";
repo = "ghidra-delinker-extension";
rev = "v${finalAttrs.version}";
hash = "sha256-h6F50Z7S6tPOl9mIhChLKoFxHuAkq/n36ysUEFwWGxI=";
};
postPatch = ''
substituteInPlace build.gradle \
--replace-fail '"''${getGitHash()}"' '"v${finalAttrs.version}"'
'';
gradleBuildTask = "buildExtension";
__darwinAllowLocalNetworking = true;
mitmCache = gradle.fetchDeps {
pkg = finalAttrs.finalPackage;
data = ./deps.json;
};
meta = {
description = "Ghidra extension for delinking executables back to object files";
homepage = "https://github.com/boricj/ghidra-delinker-extension";
license = lib.licenses.asl20;
maintainers = [ lib.maintainers.jchw ];
platforms = lib.platforms.unix;
};
})

24
pkgs/reverse-engineering/ghidra/extensions/ghidra-firmware-utils/default.nix
View File

@ -1,24 +0,0 @@
{
buildGhidraExtension,
fetchFromGitHub,
lib,
}:
buildGhidraExtension (finalAttrs: {
pname = "ghidra-firmware-utils";
version = "2024.04.20";
src = fetchFromGitHub {
owner = "al3xtjames";
repo = "ghidra-firmware-utils";
rev = finalAttrs.version;
hash = "sha256-BbPRSD1EzgMA3TCKHyNqLjzEgiOm67mLJuOeFOTvd0I=";
};
meta = {
description = "Ghidra utilities for analyzing PC firmware";
homepage = "https://github.com/al3xtjames/ghidra-firmware-utils";
downloadPage = "https://github.com/al3xtjames/ghidra-firmware-utils/releases/tag/${finalAttrs.version}";
license = lib.licenses.asl20;
maintainers = with lib.maintainers; [ timschumi ];
};
})

82
pkgs/reverse-engineering/ghidra/extensions/kaiju/default.nix
View File

@ -1,82 +0,0 @@
{
lib,
stdenv,
fetchFromGitHub,
buildGhidraExtension,
z3,
gradle,
}:
let
ghidraPlatformName =
{
x86_64-linux = "linux_x86_64";
aarch64-linux = "linux_x86_64";
x86_64-darwin = "mac_x86_64";
aarch64-darwin = "mac_arm_64";
}
.${stdenv.hostPlatform.system}
or (throw "${stdenv.hostPlatform.system} is an unsupported platform");
z3_lib = (
z3.override {
javaBindings = true;
jdk = gradle.jdk;
}
);
self = buildGhidraExtension (finalAttrs: {
pname = "kaiju";
version = "250828";
src = fetchFromGitHub {
owner = "CERTCC";
repo = "kaiju";
rev = finalAttrs.version;
hash = "sha256-edsQIBoOTY+WxVBtH1bbM7TZZHhA0jgVb2iJKC66iVM=";
};
buildInputs = [
z3_lib
];
# used to copy java bindings from nixpkgs z3 package instead of having kaiju's build.gradle build gradle from source
# https://github.com/CERTCC/kaiju/blob/c9dbb55484b3d2a6abd9dfca2197cd00fb7ee3c1/build.gradle#L189
preBuild = ''
mkdir -p build/cmake/z3/java-bindings
ln -s ${lib.getOutput "java" z3_lib}/share/java/com.microsoft.z3.jar build/cmake/z3/java-bindings
mkdir -p os/${ghidraPlatformName}
cp ${lib.getOutput "java" z3_lib}/lib/* os/${ghidraPlatformName}
'';
postInstall = ''
kaiju_path=$out/lib/ghidra/Ghidra/Extensions/kaiju
rm $kaiju_path/os/linux_x86_64/*.so
rm $kaiju_path/lib/com.microsoft.z3.jar
ln -s ${lib.getOutput "java" z3_lib}/share/java/com.microsoft.z3.jar $kaiju_path/lib
ln -s ${lib.getOutput "java" z3_lib}/lib/libz3java.so $kaiju_path/os/linux_x86_64
ln -s ${lib.getOutput "lib" z3_lib}/lib/libz3.so $kaiju_path/os/linux_x86_64
'';
gradleFlags = [ "-PKAIJU_SKIP_Z3_BUILD=true" ];
mitmCache = gradle.fetchDeps {
pkg = self;
data = ./deps.json;
};
meta = {
description = "Java implementation of some features of the CERT Pharos Binary Analysis Framework for Ghidra";
homepage = "https://github.com/CERTCC/kaiju";
downloadPage = "https://github.com/CERTCC/kaiju/releases/tag/${finalAttrs.version}";
license = lib.licenses.bsd3;
maintainers = [ lib.maintainers.ivyfanchiang ];
platforms = [
"x86_64-linux"
"aarch64-linux"
"x86_64-darwin"
"aarch64-darwin"
];
};
});
in
self

163
pkgs/reverse-engineering/ghidra/extensions/kaiju/deps.json
View File

@ -1,163 +0,0 @@
{
"!comment": "This is a nixpkgs Gradle dependency lockfile. For more details, refer to the Gradle section in the nixpkgs manual.",
"!version": 1,
"https://plugins.gradle.org/m2": {
"com/adarshr#gradle-test-logger-plugin/4.0.0": {
"jar": "sha256-5nhoOjPSvINWcb3U5YcQAErR2TFqqfmlTP4iQZpPbvk=",
"module": "sha256-jERLLH/UQgDNSrMYJyJwHCCXWkOyPH6e35sCJgSavcI=",
"pom": "sha256-ienBpTqmJS2mx9fZscN/t/j8qQuysaNq+Ti8cNni3GE="
},
"com/adarshr/test-logger#com.adarshr.test-logger.gradle.plugin/4.0.0": {
"pom": "sha256-sobTcqzS2uG4vHsg/ouoT49kiXMdiBpB83NqYCCFotc="
},
"com/github/tomtzook#castle/2.0.0": {
"jar": "sha256-00zgaBUmlsBRQcXYStVP4PhRNglOxFNf7P+kBr0A7hg=",
"pom": "sha256-3uocEIH4TsePK074yLEPseyHxbdkreKq1Uelx+60//0="
},
"com/google/code/gson#gson-parent/2.8.5": {
"pom": "sha256-jx/scrkaceo57Dn193jE0RJLawl8bVWzpQtVSlIjeyc="
},
"com/google/code/gson#gson/2.8.5": {
"jar": "sha256-IzoBSfw2XJ9u29aDz+JmsZvcdzvpjqva9rPJJLSOfYE=",
"pom": "sha256-uDCFV6f8zJLZ/nyM0FmSWLNhKF0uzedontqYhDJVoJI="
},
"de/undercouch#gradle-download-task/5.5.0": {
"jar": "sha256-q/7DKUbJfz8N62qP5HDon99K7FYneLm/bPp8RAehPiI=",
"module": "sha256-5q+RV5vPUg0udBmtEPB4j13RBsCLzLCc40sNB3UvlEc=",
"pom": "sha256-HXoKzY/wjdfQnruzxz1j1mYYyFGNudC9J0J7/BjL9Hs="
},
"de/undercouch/download#de.undercouch.download.gradle.plugin/5.5.0": {
"pom": "sha256-WNFNTmP4TrzAgj/2tk1804/2bFRtUp9gLj3ML1xPEZk="
},
"io/github/tomtzook#plugin/1.2.2": {
"jar": "sha256-tTNTLIWad6fNX4McGhtFiTkQqujQ14MXhv4llB2TjYs=",
"module": "sha256-91tklOgQk0ObuwzAs8+kumszoLjzK36bNUIChrb91Cc=",
"pom": "sha256-HliRlUYwjo3HQu/JqktYsiJy/TJTdvYTSuyHPH/3xys="
},
"io/github/tomtzook/gradle-cmake#io.github.tomtzook.gradle-cmake.gradle.plugin/1.2.2": {
"pom": "sha256-xqnleYCaGEjSEkRXp5CwK67T9sAJaxIIliGoxZTnDJo="
},
"org/fusesource#fusesource-pom/1.12": {
"pom": "sha256-xA2WDarc73sBwbHGZXr7rE//teUxaPj8sLKLhOb9zKE="
},
"org/fusesource/jansi#jansi/2.4.0": {
"jar": "sha256-bNkZkTI917L7KMqT16wSr1qGovUyeeKzWCezAxP9C58=",
"pom": "sha256-rECp8tDB7mMfw7CO+OLwvRS6IgEcp2/xvPZftWnq3zU="
},
"org/slf4j#slf4j-api/1.7.25": {
"jar": "sha256-GMSgCV1cHaa4F1kudnuyPSndL1YK1033X/OWHb3iW3k=",
"pom": "sha256-fNnXoLXZPf1GGhSIkbQ1Cc9AOpx/n7SQYNNVTfHIHh4="
},
"org/slf4j#slf4j-parent/1.7.25": {
"pom": "sha256-GPXFISDbA26I1hNviDnIMtB0vdqVx1bG9CkknS21SsY="
},
"org/sonatype/oss#oss-parent/7": {
"pom": "sha256-tR+IZ8kranIkmVV/w6H96ne9+e9XRyL+kM5DailVlFQ="
}
},
"https://repo.maven.apache.org/maven2": {
"com/google/code/gson#gson-parent/2.8.6": {
"pom": "sha256-NzZGOFnsGSZyleiUlAroKo9oRBMDESL+Nc58/34wp3Q="
},
"com/google/code/gson#gson/2.8.6": {
"jar": "sha256-yPtIOQVNKAswM/gA0fWpfeLwKOuLoutFitKH5Tbz8l8=",
"pom": "sha256-IXRBWmRzMtMP2gS9HPxwij7MhOr3UX9ZYYjYJE4QORE="
},
"junit#junit/4.12": {
"pom": "sha256-kPFj944/+28cetl96efrpO6iWAcUG4XW0SvmfKJUScQ="
},
"junit#junit/4.13.2": {
"jar": "sha256-jklbY0Rp1k+4rPo0laBly6zIoP/1XOHjEAe+TBbcV9M=",
"pom": "sha256-Vptpd+5GA8llwcRsMFj6bpaSkbAWDraWTdCSzYnq3ZQ="
},
"net/sf/jopt-simple#jopt-simple/5.0.4": {
"jar": "sha256-3ybMWPI19HfbB/dTulo6skPr5Xidn4ns9o3WLqmmbCg=",
"pom": "sha256-amd2O3avzZyAuV5cXiR4LRjMGw49m0VK0/h1THa3aBU="
},
"org/apiguardian#apiguardian-api/1.1.2": {
"jar": "sha256-tQlEisUG1gcxnxglN/CzXXEAdYLsdBgyofER5bW3Czg=",
"module": "sha256-4IAoExN1s1fR0oc06aT7QhbahLJAZByz7358fWKCI/w=",
"pom": "sha256-MjVQgdEJCVw9XTdNWkO09MG3XVSemD71ByPidy5TAqA="
},
"org/commonmark#commonmark-parent/0.17.1": {
"pom": "sha256-VQ6X1IOuWsZblW66NsnxqdlIV/bHs+qVmta7R2N4DiI="
},
"org/commonmark#commonmark/0.17.1": {
"jar": "sha256-5jrQgyZPWHdSJ0c8NduGbs3DhDxHvSvy8kdan65e938=",
"pom": "sha256-UFfBCkUrXNVyngvDZU+0vAx+VGAgCv/BqN1PfGOWPXI="
},
"org/hamcrest#hamcrest-core/1.3": {
"jar": "sha256-Zv3vkelzk0jfeglqo4SlaF9Oh1WEzOiThqekclHE2Ok=",
"pom": "sha256-/eOGp5BRc6GxA95quCBydYS1DQ4yKC4nl3h8IKZP+pM="
},
"org/hamcrest#hamcrest-parent/1.3": {
"pom": "sha256-bVNflO+2Y722gsnyelAzU5RogAlkK6epZ3UEvBvkEps="
},
"org/junit#junit-bom/5.9.2": {
"module": "sha256-qxN7pajjLJsGa/kSahx23VYUtyS6XAsCVJdyten0zx8=",
"pom": "sha256-LtB9ZYRRMfUzaoZHbJpAVrWdC1i5gVqzZ5uw82819wU="
},
"org/junit/jupiter#junit-jupiter-api/5.9.2": {
"jar": "sha256-92ehcPlxJ7CtNYK/M1jqu7vpgdn5ZBGFPmKdknaSb9U=",
"module": "sha256-y9Ae2F1HTMhbIT/iBrzpgmbWdZzSjWxeQb/kUJCepHs=",
"pom": "sha256-EK9g+mkKzNzr85TsWECdzs/x3sNwJopnA2ChFfcxxVw="
},
"org/junit/jupiter#junit-jupiter-engine/5.9.2": {
"jar": "sha256-dM/Ek4j3YEE/80jKLJqzlSdIS1fe7NFX8idaX4pf6XE=",
"module": "sha256-WmigqdMTI0BieAXap0YY+zTEXMUZp8LsgzQedDixOTM=",
"pom": "sha256-nfOOgj4a3Zplas+5Wc5zsHAE32yffANnwmt0PmVrWa8="
},
"org/junit/jupiter#junit-jupiter-migrationsupport/5.9.2": {
"jar": "sha256-1DTOe1gzyuX+9ovSfSfyABPrJ9U7bcl9eL8yS7YaDgQ=",
"module": "sha256-0tnRvL9p+RLgxT3fNO/HonM/0gCAhCA0d3Sig2ZFVZM=",
"pom": "sha256-KkAZMJh5lh9z788rZrJsF3TSjqF1U/72qAbA9sNbgqY="
},
"org/junit/platform#junit-platform-commons/1.9.2": {
"jar": "sha256-Yko9dF7x0o6VWmpnr47boP38XJutaApz9npwu5UKaD0=",
"module": "sha256-a6TIRhPluJ5mjuaomXHw2Q0OG4FyG4tf4MgAWPDOue4=",
"pom": "sha256-JAI/IMI1ppYJ+y+Vpgc4VX/PlBPzrpKpLhMpVH1hRck="
},
"org/junit/platform#junit-platform-engine/1.9.2": {
"jar": "sha256-JfI9xTWgkencgMAI+vKdy5K+kC5pEfd6c2+68BmQg2c=",
"module": "sha256-HehRQa+fWBU+JFdQaaE3X7vt169dhEy+MoeWU0nLofc=",
"pom": "sha256-LflCCmsk5fTzFCNeAc2cO49kYoXbL26C2G7gbvevTiQ="
},
"org/junit/vintage#junit-vintage-engine/5.9.2": {
"jar": "sha256-QeFt0yyPRiu8AysrefI5RBkbMuw5jQWFi6212r/9BhI=",
"module": "sha256-jMz93WRdDOdyFmeJhOtqEruXJQk0SVgOepIxTIxj0qQ=",
"pom": "sha256-n0TiazxEQSZXNjh58YscZBQX6nrCm66O5yfi8g2w9Ck="
},
"org/opentest4j#opentest4j/1.2.0": {
"jar": "sha256-WIEt5giY2Xb7ge87YtoFxmBMGP1KJJ9QRCgkefwoavI=",
"pom": "sha256-qW5nGBbB/4gDvex0ySQfAlvfsnfaXStO4CJmQFk2+ZQ="
},
"org/sonatype/oss#oss-parent/7": {
"pom": "sha256-tR+IZ8kranIkmVV/w6H96ne9+e9XRyL+kM5DailVlFQ="
},
"systems/manifold#manifold-core-parent/2023.1.28": {
"pom": "sha256-ahN15Fn/32/sBPQOta1Tp+cScHjqREz7iUUTtPCfdJA="
},
"systems/manifold#manifold-deps-parent/2023.1.28": {
"pom": "sha256-DE+CPr0aN18k0zh2D7G5WreDvyrnO5Wd0wDt88AJbkY="
},
"systems/manifold#manifold-parent/2023.1.28": {
"pom": "sha256-J0ChX+GyGJ9xJMda85n+tR1IfdE6Ij0hhtaHYSOtU6w="
},
"systems/manifold#manifold-preprocessor/2023.1.28": {
"jar": "sha256-vRIrrVT6SX3zuMVcfSwhL9nHE0oqfrtMNXuKzli2UB8=",
"pom": "sha256-Ov7/Z6wWQo+0mSc5K9t4Yw0aehDcnQEBDSpy9fnGMiU="
},
"systems/manifold#manifold-rt/2023.1.28": {
"jar": "sha256-4cn28jDYci2C2tUEizvJkdv6LRe/BrLwypEC6N0sGl0=",
"pom": "sha256-SAJid1Td0/ltrFi7w2YDNDlWhggDxFB+jynCG/rYaok="
},
"systems/manifold#manifold-util/2023.1.28": {
"jar": "sha256-WjY+1jmh4gvUHjvEbreQqoIB54HBfoNoOIILZs3IT80=",
"pom": "sha256-CF4FlMbIuKBRMfa1OjcnIQ7EVgulP739XXFkui2/JR0="
},
"systems/manifold#manifold/2023.1.28": {
"jar": "sha256-kPQeNEgFGZkZPz3zejWHU9+npn6RYRpMgOftt+bksRw=",
"pom": "sha256-R2kHxQVkoYLTSSIm/jJhjeRx4uObTuHlTSWVp+jBkpw="
}
}
}

40
pkgs/reverse-engineering/ghidra/extensions/wasm/default.nix
View File

@ -1,40 +0,0 @@
{
lib,
fetchFromGitHub,
buildGhidraExtension,
ghidra,
ant,
}:
buildGhidraExtension (finalAttrs: {
pname = "wasm";
version = "2.3.2";
src = fetchFromGitHub {
owner = "nneonneo";
repo = "ghidra-wasm-plugin";
rev = "v${finalAttrs.version}";
hash = "sha256-JFUPhh4WUcfxYow3kLMyva1Ni/cQBIit983o/KbbKps=";
};
nativeBuildInputs = [ ant ];
configurePhase = ''
runHook preConfigure
# this doesn't really compile, it compresses sinc into sla
pushd data
ant -f build.xml -Dghidra.install.dir=${ghidra.lib}/lib/ghidra sleighCompile
popd
runHook postConfigure
'';
meta = {
description = "Ghidra Wasm plugin with disassembly and decompilation support";
homepage = "https://github.com/nneonneo/ghidra-wasm-plugin";
downloadPage = "https://github.com/nneonneo/ghidra-wasm-plugin/releases/tag/v${finalAttrs.version}";
changelog = "https://github.com/nneonneo/ghidra-wasm-plugin/releases/tag/v${finalAttrs.version}";
license = lib.licenses.gpl3;
maintainers = [ lib.maintainers.BonusPlay ];
};
})

184
pkgs/reverse-engineering/idapro9/default.nix
View File

@ -1,184 +0,0 @@
{
lib,
stdenv,
fetchurl,
autoPatchelfHook,
copyDesktopItems,
python311,
qt6,
cairo,
dbus,
fontconfig,
freetype,
glib,
gtk3,
libdrm,
libGL,
libkrb5,
libsecret,
libunwind,
libxkbcommon,
openssl,
gcc,
clang,
xorg,
zlib,
curl,
gnutar,
makeDesktopItem,
makeBinaryWrapper,
runCommand,
_errorMessage ? builtins.throw ''
No source and/or version for package `idapro` was provided.
Please provide a source file and version number using, for example:
pkgs.idapro.override {
idaSource = pkgs.requireFile rec {
name = "my-idapro-source.tar.xz";
hash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
message = '''
Please run `nix store add-file ''${name}`
The value of `nix hash file ''${name}` should be ''${hash}
''';
};
idaVersion = "9.x.y";
}
The source file must be a tarball with a single directory inside containing the IDA Pro
installation. This will be extracted and patched to be able to run on NixOS.
Version 9.2 is currently supported by this derivation.
'',
# the IDA Pro tarball to extract, patch and repackage
# the reason i'm not providing an exact requireFile spec is that people's IDA Pro tarballs
# may vary, and this derivation nominally allows packaging many different versions of IDA Pro
# (though it's actually just 9.2 for now)
idaSource ? _errorMessage,
# the version of IDA pro being built
idaVersion ? _errorMessage,
# the python version to use for idapython
pythonPackage ? python311,
# additional python packages to make available to idapython
pythonDeps ? [],
# dirs to prepend to IDAUSR
plugins ? [],
}: let
defaultPythonDeps = ps: with ps; [
rpyc
];
pythonEnv =
pythonPackage.withPackages
(ps: (defaultPythonDeps ps) ++ pythonDeps);
in stdenv.mkDerivation (self: {
pname = "idapro";
version = idaVersion;
src = idaSource;
nativeBuildInputs = [
autoPatchelfHook
copyDesktopItems
makeBinaryWrapper
];
# Add everything to the RPATH, in case IDA decides to dlopen things.
runtimeDependencies = [
cairo
dbus
fontconfig
freetype
glib
gtk3
libdrm
libGL
libkrb5
libsecret
libunwind
libxkbcommon
openssl.out
(if stdenv.cc.isGNU then gcc else clang).cc
xorg.libICE
xorg.libSM
xorg.libX11
xorg.libXau
xorg.libxcb
xorg.libXext
xorg.libXi
xorg.libXrender
xorg.xcbutilimage
xorg.xcbutilkeysyms
xorg.xcbutilrenderutil
xorg.xcbutilwm
zlib
curl.out
qt6.qtwayland
pythonEnv
];
buildInputs = self.runtimeDependencies;
qtWrapperArgs = [];
installPhase = ''
runHook preInstall
mkdir -p $out/opt $out/lib $out/bin
cp -a * $out/opt
# Link the exported libraries to the output.
for lib in $out/opt/libida*; do
ln -s $lib $out/lib/$(basename $lib)
done
ln -s $out/opt/ida $out/bin/ida
mkdir -p $out/share/icons/hicolor/128x128/apps
cp $out/opt/appico.png $out/share/icons/hicolor/128x128/apps/idapro.png
runHook postInstall
'';
preFixup = ''
# Some libraries come with the installer.
addAutoPatchelfSearchPath $out/opt
# Manually patch libraries that dlopen stuff.
patchelf --add-needed libpython${pythonEnv.pythonVersion}.so $out/lib/libida.so
patchelf --add-needed libpython${pythonEnv.pythonVersion}.so $out/opt/plugins/idapython3.so
patchelf --add-needed libcrypto.so $out/lib/libida.so
patchelf --add-needed libcrypto.so $out/opt/plugins/idapython3.so
wrapProgram "$out/opt/ida" \
--prefix PYTHONPATH : $out/opt/idalib/python \
--prefix PATH : ${pythonEnv}/bin \
--suffix IDAUSR : "${lib.makeSearchPath "" plugins}"
'';
dontWrapQtApps = true;
desktopItem = makeDesktopItem {
name = "ida-pro";
exec = "ida";
icon = "idapro";
comment = self.meta.description;
desktopName = "IDA Pro";
genericName = "Interactive Disassembler";
categories = [ "Development" ];
startupWMClass = "IDA";
};
desktopItems = [ self.desktopItem ];
passthru = {
inherit pythonEnv;
};
meta = with lib; {
description = "A powerful disassembler, decompiler and a versatile debugger.";
homepage = "https://hex-rays.com/ida-pro";
mainProgram = "ida";
platforms = [ "x86_64-linux" ];
sourceProvenance = with sourceTypes; [ binaryNativeCode ];
license = lib.licenses.unfree;
};
})

2
pkgs/rust/zbasefind/default.nix
View File

@ -12,7 +12,7 @@ rustPlatform.buildRustPackage rec {
hash = "sha256-orvXNhM1WKlJ6j5Nuap0kZarydcujoEmF+OrdX7iFmA=";
};
cargoHash = "sha256-m8lXHfj6W/qltK+WrT0rE0gDNvvhghcXkeiX3Slx9X8=";
cargoHash = "sha256-7/SP+drJWg2c4bsd3d4ge8E9BJZykbWfjgC2lSJhqas=";
meta = {
description = "A firmware base address search tool";

94
pkgs/tex/moloch/default.nix
View File

@ -1,94 +0,0 @@
{
fetchFromGitea,
writeShellScript,
writableTmpDirAsHomeHook,
stdenvNoCC,
texlivePackages,
texliveBasic,
}:
let
texEnv = texliveBasic.withPackages (ps: with ps; [
# l3build
beamer
biblatex
enumitem
fileinfo
hypdoc
hyperref
listings
metalogo
parskip
pgf
pgfopts
setspace
xurl
microtype
latexmk
]);
in stdenvNoCC.mkDerivation rec {
pname = "moloch";
version = "1.0.2-DEV-xenia";
outputs = [
"tex"
"texdoc"
];
passthru.tlDeps = with texlivePackages; [ latex ];
src = fetchFromGitea {
domain = "git.lain.faith";
owner = "haskal";
repo = "${pname}-dragon";
rev = "v${version}";
hash = "sha256-eMlhJj4a2HTDhDzkS9KR+d76lt81iH7x//WZOA39tno=";
};
dontConfigure = true;
nativeBuildInputs = [
texEnv
# multiple-outputs.sh fails if $out is not defined
(writeShellScript "force-tex-output.sh" ''
out="''${tex-}"
'')
writableTmpDirAsHomeHook # Need a writable $HOME for latexmk
];
# we just build manually, but moloch's own method of building is using l3build
# i have no idea how to get that working, so for now just do it normal style
buildPhase = ''
runHook preBuild
# Generate the style files
cd src
latex beamertheme${pname}.ins
# Generate the documentation
cp ../doc/${pname}.tex .
latexmk -pdf ${pname}.tex
cd ..
runHook postBuild
'';
installPhase = ''
runHook preInstall
path="$tex/tex/latex/${pname}"
mkdir -p "$path"
cp src/*.{cls,def,clo,sty} "$path/"
path="$texdoc/doc/tex/latex/${pname}"
mkdir -p "$path"
cp src/${pname}.pdf "$path/"
runHook postInstall
'';
}

25
pkgs/zfs/0001-ZED-add-support-for-desktop-notifications-D-Bus.patch
View File

@ -1,18 +1,18 @@
From bf7fcd7f1213b4690dc95453117c55e12e5fa523 Mon Sep 17 00:00:00 2001
From 4ec38cf16ad4cc5f7bb00b93c32cd8f1d313c14c Mon Sep 17 00:00:00 2001
From: xenia <xenia@awoo.systems>
Date: Mon, 3 Feb 2025 21:36:29 -0500
Subject: [PATCH] ZED: add support for desktop notifications (D-Bus)
---
cmd/zed/zed.d/zed-functions.sh | 85 ++++++++++++++++++++++++++++++++++
cmd/zed/zed.d/zed.rc | 8 ++++
2 files changed, 93 insertions(+)
cmd/zed/zed.d/zed.rc | 7 +++
2 files changed, 92 insertions(+)
diff --git a/cmd/zed/zed.d/zed-functions.sh b/cmd/zed/zed.d/zed-functions.sh
index 6e00f153b..472941d10 100644
index 3a2519633..d47ef070b 100644
--- a/cmd/zed/zed.d/zed-functions.sh
+++ b/cmd/zed/zed.d/zed-functions.sh
@@ -213,6 +213,10 @@ zed_notify()
@@ -209,6 +209,10 @@ zed_notify()
[ "${rv}" -eq 0 ] && num_success=$((num_success + 1))
[ "${rv}" -eq 1 ] && num_failure=$((num_failure + 1))
@ -23,7 +23,7 @@ index 6e00f153b..472941d10 100644
[ "${num_success}" -gt 0 ] && return 0
[ "${num_failure}" -gt 0 ] && return 1
return 2
@@ -724,6 +728,87 @@ zed_notify_gotify()
@@ -624,6 +628,87 @@ zed_notify_ntfy()
}
@ -112,14 +112,13 @@ index 6e00f153b..472941d10 100644
# zed_rate_limit (tag, [interval])
#
diff --git a/cmd/zed/zed.d/zed.rc b/cmd/zed/zed.d/zed.rc
index af56147a9..7917552c5 100644
index 859c6f9cb..567cd556a 100644
--- a/cmd/zed/zed.d/zed.rc
+++ b/cmd/zed/zed.d/zed.rc
@@ -197,3 +197,11 @@ ZED_SYSLOG_SUBCLASS_EXCLUDE="history_event"
# Gotify application associated with ZED_GOTIFY_APPTOKEN.
# Value is an integer 0 and up.
#ZED_GOTIFY_PRIORITY=""
+
@@ -176,3 +176,10 @@ ZED_SYSLOG_SUBCLASS_EXCLUDE="history_event"
# <https://docs.ntfy.sh/install/>
# https://ntfy.sh by default; uncomment to enable an alternative service url.
#ZED_NTFY_URL="https://ntfy.sh"
+
+##
+# Whether to send desktop notifications via D-Bus
@ -128,5 +127,5 @@ index af56147a9..7917552c5 100644
+# Disabled by default; uncomment to enable.
+#ZED_USE_DBUS=1
--
2.47.2
2.47.0

1
templates/beamer/.envrc
View File

@ -1 +0,0 @@
use flake

16
templates/beamer/.gitignore vendored
View File

@ -1,16 +0,0 @@
/my-beamer-presentation.pdf
*.aux
*.fdb_latexmk
*.fls
*.log
*.nav
*.out
*.snm
*.synctex.gz
*.toc
result
result-tex
.direnv

46
templates/beamer/flake.nix
View File

@ -1,46 +0,0 @@
{
description = "A very basic presentation with Beamer";
outputs = { self, dragnpkgs } @ inputs: dragnpkgs.lib.mkFlake {
# Define a texlive environment to use
packages.texlive-custom = { texliveMedium, texliveDragonPackages }:
texliveMedium.withPackages (ps: with ps; [
fontawesome5
texliveDragonPackages.moloch
]);
# Package definition for building the PDF
packages.default = { system, stdenvNoCC }: stdenvNoCC.mkDerivation rec {
pname = "my-beamer-presentation";
name = "${pname}.pdf";
nativeBuildInputs = [
self.packages.${system}.texlive-custom
];
src = self;
buildPhase = ''
latexmk -pdf ${pname}.tex
'';
installPhase = ''
cp ${pname}.pdf $out
'';
};
# Runnable package (ie `nix run`) to start the presentation
apps.default = { lib, system, writeShellScript, pympress }: {
type = "app";
program = "${writeShellScript "start-presentation" ''
exec ${lib.getExe pympress} ${self.packages.${system}.default}
''}";
};
# Devshell definition to expose the texlive environment to eg nvim
devShells.default = { mkShell, system }: mkShell {
packages = [ self.packages.${system}.texlive-custom ];
};
};
}

93
templates/beamer/my-beamer-presentation.tex
View File

@ -1,93 +0,0 @@
\documentclass[aspectratio=169]{beamer}
\usepackage[english]{babel}
\usepackage{fontawesome5}
\usepackage{tikz}
\usetikzlibrary{arrows,calc,fit,positioning}
\usetheme{moloch}
\usefonttheme[onlymath]{serif}
% this can be commented out to produce a slide deck with no notes
\setbeameroption{show notes}
% useful tikz styles from previous slide decks
\tikzset{%
icon/.value required,
icon/.style={%
node contents={\faIcon{#1}},
icon size=normal,
},
icon size/.is choice,
icon size/.default=normal,
icon size/normal/.style={%
font={\fontsize{20.74}{20.74}\selectfont}
},
icon size/small/.style={%
font={\fontsize{12}{12}\selectfont}
},
rounded box/.style={%
inner sep=0.3em,
draw,
rounded corners,
line width=0.1em
},
sequence diagram/.style={%
font=\small,
line width=1pt,
sequence/.style={%
every to/.style={%
to path={(\tikztostart) -- (\tikztostart -| \tikztotarget) \tikztonodes} % chktex 1 chktex 8
},
->/.style={-stealth,every node/.style={above}},
<-/.style={stealth-,every node/.style={below}},
},
note/.style={%
color=example text.fg,
},
},
}
\title{My Beamer Presentation}
\subtitle{(From the template)}
\author{You}
\institute{Institute of Swag Nix Templates}
\date{Now}
\begin{document}
\maketitle
\section{My Section}
\subsection{My Subsection}
\begin{frame}
\frametitle{Some Slide Title}
Sample text
\end{frame}
\begin{frame}
\frametitle{Some Other Slide Title}
Sample text 2
\end{frame}
\appendix
\begin{frame}[standout]
Backup Slides
\end{frame}
\begin{frame}
\frametitle{Backup slide 1}
Some backup slide content
\end{frame}
\end{document}