jasypt | Java Simplified Encryption ) is a java library | Cryptography library

Your actual problem is that your first hash is wrong; you need to take .digest after doing the two .updates. (Your iterated hashes are correct.) In addition your unpadding is poor: PKCS5 padding should not exceed one block which for DES is 8 bytes. Even better would be to check all the padding bytes if more than 1, but I didn't bother.

Looks like the password is not set and is null in SimplePBEConfig.java(line no. 434) causing NullPointerException.

Reference - https://github.com/jboss-fuse/jasypt/blob/master/jasypt/src/main/java/org/jasypt/encryption/pbe/config/SimplePBEConfig.java

There are known (probably difficult to solve) issues related to sharing folders with docker containers.

I don't know the details but more often than not applications running inside containers have hard time tracking file changes or file additions if said changes have been made in the host machine.

When modifying config files for Karaf running inside docker I often have to resort to docker exec -it karaf /bin/bash and use some touch or cp command trickery before karaf detects the new configurations. This is also the case when I am installing features that add configs from my local maven repository to karaf running.

Trickery:

1. use touch command on modified file (doesn't always work).
2. when touch fails I usually have to copy the configuration file to new file, delete the original and rename the copy to original name.

These are not exclusive to docker and plague podman as well.

One way to get around these issues is to use karaf shell to add the user

Preface: Although it's possible to create a fat/uber JAR file which includes JavaFX, this is not the preferred approach. That results in JavaFX being loaded from the class-path, which is not a supported configuration. However, if you really want to create a fat/uber JAR file then skip to the "Creating a Fat/Uber JAR" section.

The preferred approach for deploying a JavaFX application these days, is to create a custom run-time image and package it into a platform-specific installer/executable.

The jlink tool is used to create custom run-time images. That's really just a fancy way of saying "a custom JRE that contains only the modules you need". The result is a self-contained application, though not a very user-friendly one, in my opinion.

Note the jlink tool only works with explicitly named modules (i.e. there's a module-info.class file present).

The jpackage tool essentially takes a custom run-time image and generates a platform-specific executable for it (e.g. a .exe file on Windows). Then the application is packaged into a platform-specific installation file (e.g. a .msi file on Windows). This tool has a user guide.

Note the jpackage tool supports creating non-modular applications. You can even configure it so all modules end up in the custom run-time image, while your non-modular application and any other non-modular dependencies are placed on the class-path.

The JavaFX framework requires platform-specific native code to work. This means you need to make sure that native code is included in the custom run-time image. There are two ways you can do this:

1. Use the JavaFX JAR files from Maven Central, not the JavaFX SDK.

   • The JAR files published to Maven Central embed the native code. However, JavaFX will have to extract the native code to some place on your computer in order to use it.

2. (Preferred) Use the JavaFX JMOD files, which can be downloaded from gluonhq.com.

   • You would point jlink / jpackage at the JMOD files instead of the regular JAR files.
   • This results in the native code being included in the same way as all the native code needed by the JRE itself. Now there's no need to extract the native code, which makes this the better option in my opinion.

There are two plugins I'd recommend for using jlink / jpackage from Gradle.

• The Badass JLink Plugin (for modular applications)
• The Badass Runtime Plugin (for non-modular applications)

When using Gradle, I recommend the Gradle Shadow Plugin for creating so-called fat/uber JAR files. It does much of the configuration for you, such as excluding signature files. And it pulls appropriate defaults from the already-existing jar task. It also adds the shadowJar task for building the fat/uber JAR file.

Here is a sample application that creates a fat/uber JAR file. Note I use the Kotlin DSL for Gradle instead of the Groovy DSL, but you can use whichever.

Used:

• Gradle 7.3
• Java 17.0.1 (JavaFX not included)

settings.gradle.kts

You are accessing the injected property in the constructor. This does not work because here Spring will instantiate the bean, and then inject the property. So, if you access the property in the constructor you will get the default value before the injection which is null. If you want to access the property in the constructor, then you can use constructor injection like so:

use

This command line worked for me.

You can use the mvn command to get the encrypted value to your config file.

For example, if you want to encrypt the value mySecret place the value as a property in the application.properties file enclosed within brackets and prefixed by DEC.

ARG in Dockerfile is only available in the build stage.

When you want to run it as a container, ARG values will not be available but ENV will be. This means you can not directly access those values in ENTRYPOINT (also not available in CMD). You can read this similar question for more info.

If you want to pass environment parameters to the container using the build arguments (ARG), the simple solution will be to do something like this: