Thibaut/ffsaf-site
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Activity

setup ffsaf server

Browse Source
This commit is contained in:
Thibaut Valentin
2024-01-11 22:48:19 +01:00
commit 1d2d4626a5
34 changed files with 2323 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

229
src/main/java/fr/titionfire/ffsaf/net2/Client_Thread.java Normal file
View File

@@ -0,0 +1,229 @@
package fr.titionfire.ffsaf.net2;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import fr.titionfire.ffsaf.utils.JsonConsumer;
import fr.titionfire.ffsaf.utils.Pair;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import org.jboss.logging.Logger;
import org.quartz.*;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.util.Base64;
import java.util.HashMap;
import java.util.UUID;
public class Client_Thread extends Thread {
private static final Logger LOGGER = Logger.getLogger(Client_Thread.class);
public static final ObjectMapper MAPPER = new ObjectMapper();
private final Socket s;
private final OutputStreamWriter dos;
private final BufferedReader br;
public final ServerCustom serv;
private boolean isAuth;
private final HashMap<UUID, JsonConsumer<Object>> waitResult = new HashMap<>();
public Client_Thread(ServerCustom serv, Socket s, PublicKey publicKey) throws IOException {
this.serv = serv;
this.s = s;
this.isAuth = false;
dos = new OutputStreamWriter(s.getOutputStream(), StandardCharsets.UTF_8); // to send data to the client
br = new BufferedReader(new InputStreamReader(s.getInputStream(), StandardCharsets.UTF_8)); // to read data
// coming from the client
LOGGER.infof("Connection established to %s", s.getInetAddress().getHostAddress());
String auth_code = UUID.randomUUID() + "-" + UUID.randomUUID();
JsonConsumer<Object> consumer = new JsonConsumer<>(Object.class, t -> {
if (t.equals(auth_code)) {
isAuth = true;
LOGGER.infof("Client %s is auth", s.getInetAddress().getHostAddress());
} else {
LOGGER.warnf("Client %s is not auth", s.getInetAddress().getHostAddress());
stopSoket();
}
});
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] bytes = cipher.doFinal(auth_code.getBytes(StandardCharsets.UTF_8));
sendReq(new String(Base64.getEncoder().encode(bytes)), "auth", consumer);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException | InvalidKeyException e) {
LOGGER.error(e.getMessage(), e);
}
}
@Override
public void run() {
while (!s.isClosed()) {
String jsonmessage;
// read from client
try {
if ((jsonmessage = br.readLine()) != null) {
jsonmessage = jsonmessage.replace('¤', '\n');
process_message(jsonmessage);
} else {
s.close();
}
} catch (IOException e) {
if (e.getMessage().equals("Stream closed") || e.getMessage().equals("Connection reset")) {
break;
}
LOGGER.error(e.getMessage(), e);
}
}
serv.onCloseClient(this);
// close connection
try {
dos.close();
br.close();
LOGGER.infof("Connection closed for %s", s.getInetAddress().getHostAddress());
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
}
}
private void process_message(String jsonmessage) {
try {
JsonNode node = MAPPER.readTree(jsonmessage);
if (node.has("uuid") && node.has("code") && node.has("type")) {
Message<JsonNode> message = new Message<>(UUID.fromString(node.get("uuid").asText()),
node.get("code").asText(), MessageType.valueOf(node.get("type").asText()),
(node.has("data")) ? node.get("data") : null);
LOGGER.debugf("Message Received of %s: %s", s.getInetAddress().getHostAddress(), message);
if (message.type() == MessageType.REQUEST || message.type() == MessageType.NOTIFY) {
if (serv.iMap.containsKey(message.code())) {
if (isAuth) {
UUID uuid = UUID.randomUUID();
serv.jobData.put(uuid, new Pair<>(this, message));
JobKey jobKey = JobKey.jobKey(uuid.toString(), "client-request");
JobDetail job = JobBuilder.newJob(CallSyncJob.class)
.usingJobData("uuid", uuid.toString())
.storeDurably(true)
.withIdentity(jobKey)
.build();
serv.quartz.addJob(job, true);
serv.quartz.triggerJob(jobKey);
}
} else {
this.sendErr("No receiver found", message.code(), message.uuid());
LOGGER.warnf("No receiver found for %s", message.code());
}
} else {
if (waitResult.containsKey(message.uuid())) {
if (waitResult.get(message.uuid()) != null)
waitResult.get(message.uuid()).castAndAccept(message.data());
waitResult.remove(message.uuid());
} else {
LOGGER.warnf("No waiting message found for %s", message.uuid());
}
}
} else {
LOGGER.debugf("Message format incorrect: %s", jsonmessage);
}
} catch (Exception e) {
LOGGER.debug(jsonmessage);
LOGGER.error(e.getMessage(), e);
}
}
public void sendNotify(Object object, String type) {
sendMessage(new Message<>(UUID.randomUUID(), type, MessageType.NOTIFY, object));
}
public void sendReq(Object object, String type) {
sendReq(object, type, null);
}
public void sendReq(Object object, String code, JsonConsumer<Object> consumer) {
UUID uuid;
do {
uuid = UUID.randomUUID();
} while (waitResult.containsKey(uuid));
waitResult.put(uuid, consumer);
sendMessage(new Message<>(uuid, code, MessageType.REQUEST, object));
}
public void sendRepTo(Object object, Message<?> in) {
sendMessage(new Message<>(in.uuid(), in.code(), MessageType.REPLY, object));
}
public void sendErr(String msg, String type, UUID uuid) {
sendMessage(new Message<>(uuid, type, MessageType.ERROR, msg));
}
public void sendErrTo(String msg, Message<?> in) {
sendMessage(new Message<>(in.uuid(), in.code(), MessageType.ERROR, msg));
}
public void sendMessage(Message<?> message) {
try {
synchronized (dos) {
dos.write(MAPPER.writeValueAsString(message).replace('¤', ' ').replace('\n', '¤') + '\n');
dos.flush();
}
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
}
LOGGER.tracef("Send message type: %s, code: %s, uuid: %s, to: %s", message.type(), message.code(),
message.uuid(), s.getInetAddress().getHostAddress());
}
public void stopSoket() {
try {
s.close();
} catch (IOException ignored) {
}
}
public static class CallSyncJob implements Job {
@Inject
ServerCustom socket;
@Transactional
public void execute(JobExecutionContext context) {
UUID uuid = UUID.fromString(context.getMergedJobDataMap().getString("uuid"));
Pair<Client_Thread, Message<JsonNode>> pair = socket.jobData.get(uuid);
if (pair != null) {
try {
socket.iMap.get(pair.getValue().code()).castAndCall(pair.getKey(), pair.getValue());
} catch (JsonProcessingException e) {
LOGGER.error(e.getMessage(), e);
}
socket.jobData.remove(uuid);
} else {
LOGGER.errorf("no get found %d", socket.jobData.size());
}
}
}
}

19
src/main/java/fr/titionfire/ffsaf/net2/Message.java Normal file
View File

@@ -0,0 +1,19 @@
package fr.titionfire.ffsaf.net2;
import io.quarkus.runtime.annotations.RegisterForReflection;
import java.util.UUID;
@RegisterForReflection
public record Message<T> (UUID uuid, String code, MessageType type, T data){
@Override
public String toString() {
return "Message{" +
"uuid=" + uuid +
", code='" + code + '\'' +
", type=" + type +
", data=" + data +
'}';
}
}

5
src/main/java/fr/titionfire/ffsaf/net2/MessageType.java Normal file
View File

@@ -0,0 +1,5 @@
package fr.titionfire.ffsaf.net2;
public enum MessageType {
REQUEST, REPLY, ERROR, NOTIFY
}

148
src/main/java/fr/titionfire/ffsaf/net2/ServerCustom.java Normal file
View File

@@ -0,0 +1,148 @@
package fr.titionfire.ffsaf.net2;
import com.fasterxml.jackson.databind.JsonNode;
import fr.titionfire.ffsaf.net2.packet.IAction;
import fr.titionfire.ffsaf.net2.packet.RegisterAction;
import fr.titionfire.ffsaf.utils.Pair;
import io.quarkus.runtime.ShutdownEvent;
import io.quarkus.runtime.StartupEvent;
import jakarta.enterprise.event.Observes;
import jakarta.inject.Singleton;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import org.jboss.logging.Logger;
import org.quartz.Scheduler;
import javax.net.ssl.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.security.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;
import jakarta.inject.Inject;
@Singleton
public class ServerCustom extends Thread {
private static final Logger LOGGER = Logger.getLogger("SocketServer");
protected ConcurrentHashMap<UUID, Pair<Client_Thread, Message<JsonNode>>> jobData = new ConcurrentHashMap<>();
protected HashMap<String, IAction> iMap = new HashMap<>();
public final ArrayList<Client_Thread> clients = new ArrayList<>();
private SSLServerSocket server;
private boolean run;
@ConfigProperty(name = "internal-port")
int port;
@ConfigProperty(name = "certificate_password")
String certificate_password;
@ConfigProperty(name = "certificate_file")
String certificate_file;
@Inject
protected Scheduler quartz;
private PublicKey publicKey;
private X509TrustManager tm(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException {
TrustManagerFactory trustMgrFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustMgrFactory.init(keystore);
TrustManager[] trustManagers = trustMgrFactory.getTrustManagers();
for (TrustManager trustManager : trustManagers) {
if (trustManager instanceof X509TrustManager) {
return (X509TrustManager) trustManager;
}
}
return null;
}
private X509KeyManager km(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException, UnrecoverableKeyException {
KeyManagerFactory keyMgrFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyMgrFactory.init(keystore, certificate_password.toCharArray());
KeyManager[] keyManagers = keyMgrFactory.getKeyManagers();
for (KeyManager keyManager : keyManagers) {
if (keyManager instanceof X509KeyManager) {
return (X509KeyManager) keyManager;
}
}
return null;
}
private SSLServerSocket getServerSocketWithCert(int port, InputStream pathToCert) throws Exception {
TrustManager[] tmm = new TrustManager[1];
KeyManager[] kmm = new KeyManager[1];
KeyStore ks = KeyStore.getInstance("JKS");
ks.load(pathToCert, certificate_password.toCharArray());
tmm[0] = tm(ks);
kmm[0] = km(ks);
SSLContext ctx = SSLContext.getInstance("TLSv1.2");
ctx.init(kmm, tmm, null);
publicKey = ks.getCertificate("ffsaf").getPublicKey();
SSLServerSocketFactory socketFactory = ctx.getServerSocketFactory();
return (SSLServerSocket) socketFactory.createServerSocket(port);
}
@Override
public void run() {
try {
this.run = true;
this.server = getServerSocketWithCert(this.port, new FileInputStream(new File(this.certificate_file)));
RegisterAction.register(iMap);
LOGGER.info("Starting socket server!!");
while (this.run) {
Socket socket = this.server.accept();
Client_Thread cThread = new Client_Thread(this, socket, publicKey);
synchronized (clients) {
this.clients.add(cThread);
}
cThread.start();
}
LOGGER.info("Shutting down Socket server!!");
} catch (Exception e) {
LOGGER.info("Server start failed! (" + e.getMessage() + ")");
this.interrupt();
}
}
public void onCloseClient(Client_Thread cThread) {
synchronized (clients) {
clients.remove(cThread);
}
}
public void stop2() {
this.run = false;
try {
this.server.close();
clients.forEach(Client_Thread::stopSoket);
} catch (IOException ignored) {
}
}
void onStart(@Observes StartupEvent ev) {
LOGGER.info("The server is starting...");
this.start();
}
void onStop(@Observes ShutdownEvent ev) {
LOGGER.info("The server is stopping...");
this.stop2();
}
public Stream<Client_Thread> get_clients() {
return clients.stream();
}
}

25
src/main/java/fr/titionfire/ffsaf/net2/packet/CIA.java Normal file
View File

@@ -0,0 +1,25 @@
package fr.titionfire.ffsaf.net2.packet;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import fr.titionfire.ffsaf.net2.Client_Thread;
import fr.titionfire.ffsaf.net2.Message;
import java.util.function.BiConsumer;
import static fr.titionfire.ffsaf.net2.Client_Thread.MAPPER;
public class CIA<T> implements IAction{
private final Class<T> clazz;
private final BiConsumer<Client_Thread, Message<T>> iAction;
public CIA(Class<T> clazz, BiConsumer<Client_Thread, Message<T>> iAction){
this.clazz = clazz;
this.iAction = iAction;
}
@Override
public void dataIn(Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException {
iAction.accept(client_Thread, new Message<>(message.uuid(), message.code(), message.type(), MAPPER.treeToValue(message.data(), clazz)));
}
}

14
src/main/java/fr/titionfire/ffsaf/net2/packet/IAction.java Normal file
View File

@@ -0,0 +1,14 @@
package fr.titionfire.ffsaf.net2.packet;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import fr.titionfire.ffsaf.net2.Client_Thread;
import fr.titionfire.ffsaf.net2.Message;
public interface IAction {
void dataIn(Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException;
default void castAndCall (Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException {
this.dataIn(client_Thread, message);
}
}

11
src/main/java/fr/titionfire/ffsaf/net2/packet/RegisterAction.java Normal file
View File

@@ -0,0 +1,11 @@
package fr.titionfire.ffsaf.net2.packet;
import java.util.HashMap;
public class RegisterAction {
public static void register(HashMap<String, IAction> iMap) {
iMap.clear();
}
}