UnlegitDqrk/unlegitlibrary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored using IntelliJ

Browse Source
This commit is contained in:
UnlegitDqrk
2026-02-21 19:49:27 +01:00
parent 66c87f4f28
commit fb0b8ecf76
16 changed files with 499 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
README.MD
View File

@@ -1,20 +1,49 @@
# UnlegitLibrary
## Overview
UnlegitLibrary is a general-purpose Java utility library that bundles a modular
event system, command framework, addon loader, networking (TCP/UDP with optional TLS),
and a wide set of math/number/string/file/reflection helpers.
UnlegitLibrary is a modular Java library focused on reusable core building blocks:
event handling, commands, addon loading, network communication (TCP/UDP with optional
TLS), and various utility classes.
## Modules
- Addon system: loader + lifecycle events
## Contents
- Features
- Maven Integration
- ArgumentParser
- NetworkSystem (TCP/UDP + TLS/mTLS)
- Create Certificates
- License
## Features
- Addon system: loader, lifecycle, addon events
- Event system: listeners, priorities, cancellable events
- Command system: command manager, permissions, execution events
- Network system: TCP/UDP transport, packet handling, optional TLS, UDP encryption
- Utilities: math/number helpers, strings, colors, files, reflection, logging
- Argument parsing: register arguments, validate values, run callbacks
- Command system: command manager, permissions, execute events
- NetworkSystem: TCP/UDP, packet handling, optional TLS security, UDP encryption
- Utilities: number/math, strings/colors, files, reflection, logging
- ArgumentParser: registration, validation, and execution of arguments
## Maven Integration
```xml
<repositories>
<repository>
<id>repounlegitdqrk</id>
<url>https://repo.unlegitdqrk.dev/api/packages/unlegitdqrk/maven</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>dev.unlegitdqrk</groupId>
<artifactId>unlegitlibrary</artifactId>
<version>VERSION</version>
</dependency>
</dependencies>
```
## ArgumentParser
Basic usage
### Basic Example
```java
ArgumentParser parser = new ArgumentParser(args);
@@ -29,76 +58,61 @@ parser.registerArgument(mode);
parser.runArguments();
```
Value rules
### Value Rules
- Constructor: `Argument(name, description, required, requireValue, optionalValue, values)`
- `requireValue=false` and `optionalValue=false`: argument has no value
- `requireValue=true` and `optionalValue=false`: value must be present
- `requireValue=false` and `optionalValue=false`: no value allowed
- `requireValue=true` and `optionalValue=false`: value is required
- `requireValue=false` and `optionalValue=true`: value is optional
- `requireValue=true` and `optionalValue=true` is not allowed
- If `values` is not empty, the provided value must be in that list
## License Information
GNU General Public License v3.0 (GPLv3)<br />
The default license. Applies to all users, projects, and distributions unless explicitly stated otherwise.<br />
-> https://repo.unlegitdqrk.dev/UnlegitDqrk/UnlegitLibrary/src/LICENSE
Open Autonomous Public License (OAPL)<br />
A special exception applies exclusively to the project Open Autonomous Connection (OAC).<br />
Within OAC, the UnlegitLibrary is also licensed under the OAPL.<br />
In this context, OAPL terms take precedence.<br />
-> https://repo.open-autonomous-connection.org/Open-Autonomous-Connection/OAPL
## Include in own projects
````
<repositories>
<repository>
<id>repounlegitdqrk</id>
<url>https://repo.unlegitdqrk.dev/api/packages/unlegitdqrk/maven</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>dev.unlegitdqrk</groupId>
<artifactId>unlegitlibrary</artifactId>
<version>VERSION</version>
</dependency>
</dependencies>
````
- `requireValue=true` and `optionalValue=true`: invalid combination
- If `values` is not empty, the provided value must be in the list
## NetworkSystem (TCP/UDP + TLS)
- TCP is the control channel (handshake, packet routing).
- UDP is optional and encrypted with a symmetric key negotiated over TCP.
- TLS can be enabled or disabled. For TLS, configure KeyStore/TrustStore explicitly.
- mTLS is supported: set client auth mode to REQUIRED and provide a TrustStore on the server.
- TCP is the control channel (handshake, routing, session data).
- UDP is optional and encrypted using a symmetric key negotiated over TCP.
- TLS can be enabled or disabled.
- mTLS is supported (`ClientAuthMode.REQUIRED` + TrustStore on the server side).
### Basic usage
### Basic Example
```java
PacketHandler packetHandler = new PacketHandler();
packetHandler.registerPacket(() -> new ExamplePacket(""));
EventManager eventManager = new EventManager();
NetworkServer server = new NetworkServer(packetHandler);
server.configureSSL(false, ClientAuthMode.NONE);
NetworkServer server = new NetworkServer.Builder()
.packetHandler(packetHandler)
.eventManager(eventManager)
.sslEnabled(false)
.clientAuthMode(ClientAuthMode.NONE)
.build();
server.start(25565, 25566);
NetworkClient client = new NetworkClient(packetHandler);
client.configureSSL(false);
NetworkClient client = new NetworkClient.Builder()
.packetHandler(packetHandler)
.sslEnabled(false)
.build();
client.connect("127.0.0.1", 25565);
```
### TLS with TrustStore (server validation)
### TLS with TrustStore (Server Validation)
```java
KeyStore serverKeyStore = loadStore("certs/server.p12", "changeit".toCharArray());
KeyStore clientTrustStore = loadStore("certs/client-trust.p12", "changeit".toCharArray());
EventManager eventManager = new EventManager();
NetworkServer server = new NetworkServer(packetHandler);
server.configureSSL(true, ClientAuthMode.NONE, serverKeyStore, "changeit".toCharArray(), null);
NetworkServer server = new NetworkServer.Builder()
.packetHandler(packetHandler)
.eventManager(eventManager)
.sslEnabled(true)
.clientAuthMode(ClientAuthMode.NONE)
.keyStore(serverKeyStore, "changeit".toCharArray())
.build();
server.start(25565, 25566);
NetworkClient client = new NetworkClient(packetHandler);
client.configureSSL(true, null, null, clientTrustStore);
NetworkClient client = new NetworkClient.Builder()
.packetHandler(packetHandler)
.sslEnabled(true)
.trustStore(clientTrustStore)
.build();
client.connect("127.0.0.1", 25565);
```
@@ -108,54 +122,55 @@ KeyStore serverKeyStore = loadStore("certs/server.p12", "changeit".toCharArray()
KeyStore serverTrustStore = loadStore("certs/server-trust.p12", "changeit".toCharArray());
KeyStore clientKeyStore = loadStore("certs/client.p12", "changeit".toCharArray());
KeyStore clientTrustStore = loadStore("certs/client-trust.p12", "changeit".toCharArray());
EventManager eventManager = new EventManager();
NetworkServer server = new NetworkServer(packetHandler);
server.configureSSL(true, ClientAuthMode.REQUIRED, serverKeyStore, "changeit".toCharArray(), serverTrustStore);
NetworkServer server = new NetworkServer.Builder()
.packetHandler(packetHandler)
.eventManager(eventManager)
.sslEnabled(true)
.clientAuthMode(ClientAuthMode.REQUIRED)
.keyStore(serverKeyStore, "changeit".toCharArray())
.trustStore(serverTrustStore)
.build();
server.start(25565, 25566);
NetworkClient client = new NetworkClient(packetHandler);
client.configureSSL(true, clientKeyStore, "changeit".toCharArray(), clientTrustStore);
NetworkClient client = new NetworkClient.Builder()
.packetHandler(packetHandler)
.sslEnabled(true)
.keyStore(clientKeyStore, "changeit".toCharArray())
.trustStore(clientTrustStore)
.build();
client.connect("127.0.0.1", 25565);
```
## Certificate generation for NetworkSystem
### Creating Root-CA:
````
## Certificates for NetworkSystem
### Create Root CA
```bash
openssl genrsa -out myCA.key 4096
openssl req -x509 -new -key myCA.key -sha256 -days 365 -out myCA.pem -addtext basicConstraints=critical,CA:TRUE -addtext keyUsage=critical,keyCertSign,cRLSign
```
- `myCA.key`: private CA key (keep secret)
- `myCA.pem`: public root certificate
myCA.key = private Key for CA (keep secret)
myCA.pem = public Root-Certificate for signing server and client certificates
````
### Creating Server Certificate based on Root-CA:
````
### Create Server Certificate Based on Root CA
```bash
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr
openssl x509 -req -in server.csr -CA myCA.pem -CAkey myCA.key -CAcreateserial -out server.crt -days 365 -sha256
```
- `server.key`: private server key
- `server.crt`: server certificate signed by your root CA
server.key = private Key for Server
server.crt = Server-Certificate signed by Root-CA
````
### Optional: Creating Client Certificate based on Root-CA:
````
### Optional: Create Client Certificate Based on Root CA
```bash
openssl genrsa -out client.key 2048
openssl req -new -key client.key -out client.csr
openssl x509 -req -in client.csr -CA myCA.pem -CAkey myCA.key -CAcreateserial -out client.crt -days 365 -sha256
```
- `client.key`: private client key
- `client.crt`: client certificate signed by your root CA
client.key = private Key for Client
client.crt = Client-Certificate signed by Root-CA
````
1. Generate a Root-CA. Every client and server NEED this Root-CA *.pem-File. Keep the *.key file private<br />
2. Generate a Server-Certificate
3. Optional: Generate a Client-Certificate
4. Put the Root-CA on your server and client in "certificates/ca"-Folder
5. Put the Server-Certificate-Key in "certificates/key"-Folder
6. Put the Server-Certificate in "certificates/server"-Folder
7. Optional: Put the Client-Certificate-Key in "certificates/key"-Folder
8. Optional: Put the Client-Certificate in "certificates/client"-Folder
### Helper: load PKCS12 stores in Java
### Helper: Load PKCS12 Store in Java
```java
private static KeyStore loadStore(String path, char[] password) throws Exception {
KeyStore store = KeyStore.getInstance("PKCS12");
@@ -165,3 +180,17 @@ private static KeyStore loadStore(String path, char[] password) throws Exception
return store;
}
```
## License
### GNU General Public License v3.0 (GPLv3)
Default license for all users, projects, and distributions unless explicitly
agreed otherwise.
- License file in project: `LICENSE`
- Reference: https://repo.unlegitdqrk.dev/UnlegitDqrk/UnlegitLibrary/src/LICENSE
### Open Autonomous Public License (OAPL)
Special exception exclusively for the Open Autonomous Connection (OAC) project.
Within that context, OAPL terms take precedence.
- Reference: https://repo.open-autonomous-connection.org/Open-Autonomous-Connection/OAPL