lightcontainer/FileFrontEnd
2
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Merge branch 'dev'

Browse Source
This commit is contained in:
Benjamin 2022-03-12 19:09:24 +01:00
commit 2c6a2564b5
51 changed files with 1643 additions and 397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
app/src/main/java/lightcontainer/App.java
View File

@ -12,68 +12,44 @@ import lightcontainer.repository.ClientHandlerRepository;
import lightcontainer.repository.FileFrontEnd;
import lightcontainer.repository.ProtocolRepositoryImpl;
import lightcontainer.repository.StoreProcessorRepository;
import lightcontainer.storage.AppData;
import lightcontainer.storage.JsonAdapter;
import lightcontainer.storage.Repository;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class App {
// Constant config server
// -- Unicast client port
private static final int UNICAST_PORT = 8000;
// -- Multicast listener ip, port
private static final String MULTICAST_IP = "226.66.66.1";
private static final int MULTICAST_PORT = 15502;
/*
private static Thread t1 = null;
public static void main(String[] args) {
setupVM();
Repository repositoryStorage = prepareStorage();
public static void main(String[] args) throws InterruptedException {
t1 = new Thread(new Runnable() {
@Override
public void run() {
int i = 0;
while (true) {
System.out.println("HEY " + i++);
try {
synchronized (t1) {
System.out.println("SUSPEND");
t1.wait();
}
} catch (InterruptedException e) {}
}
}
});
t1.start();
System.out.println("START");
Thread.sleep(1000);
synchronized (t1) {
t1.notify();
}
}
*/
public static void main(String[] args) throws InterruptedException {
// Create all repository
ClientHandlerRepository clientRep = new ClientHandlerRepository();
StoreProcessorRepository storeRep = new StoreProcessorRepository();
ProtocolRepository protocolRep = new ProtocolRepositoryImpl();
protocolRep.addReader(new HelloRule());
protocolRep.addReader(new SigninRule(protocolRep));
protocolRep.addReader(new SignupRule(protocolRep));
protocolRep.addReader(new SignoutRule());
protocolRep.addReader(new FilelistRule(protocolRep));
protocolRep.addReader(new SavefileRule(protocolRep));
protocolRep.addReader(new SavefileRule(protocolRep, repositoryStorage.getStoragePath()));
protocolRep.addReader(new SendOkRule(protocolRep));
protocolRep.addWriter(new SignOkRule());
protocolRep.addWriter(new SignErrorRule());
protocolRep.addWriter(new SignoutRule());
protocolRep.addWriter(new FilesRule());
protocolRep.addWriter(new SaveFileOkRule());
protocolRep.addWriter(new SaveFileErrorRule());
protocolRep.addWriter(new SendfileRule());
protocolRep.addWriter(new SendfileRule(repositoryStorage.getStoragePath()));
FileFrontEnd ffe = new FileFrontEnd(clientRep, storeRep, protocolRep);
new UnicastServerListener(ffe, clientRep, protocolRep, UNICAST_PORT);
new MulticastServerListener(ffe, storeRep, protocolRep, MULTICAST_IP, MULTICAST_PORT);
new UnicastServerListener(ffe, clientRep, protocolRep, repositoryStorage, repositoryStorage.getUnicastPort());
new MulticastServerListener(ffe, storeRep, protocolRep, repositoryStorage.getMulticastIp(), repositoryStorage.getMulticastPort());
// close repo et client et server.
@ -83,4 +59,21 @@ public class App {
// storeRep.close();
}
private static Repository prepareStorage() {
AppData appData = AppData.getInstance();
Repository repository = new Repository(
Paths.get("src", "main", "resources", "appdata.json").toAbsolutePath().toString(),
appData, new JsonAdapter()
);
repository.load();
return repository;
}
private static void setupVM() {
System.setProperty("javax.net.ssl.keyStore","../ffe.labo.swilabus.com.p12");
System.setProperty("javax.net.ssl.keyStorePassword","labo2022");
System.setProperty("https.protocols","TLSv1.3");
}
}

48
app/src/main/java/lightcontainer/domains/Task.java
View File

@ -1,24 +1,37 @@
package lightcontainer.domains;
import lightcontainer.domains.client.Context;
import lightcontainer.enumerations.TaskStatus;
import lightcontainer.enumerations.TaskType;
import lightcontainer.protocol.ProtocolWriter;
/**
* Une tâche exécutable
*/
public class Task {
// Variables
private TaskStatus status;
private ProtocolWriter.ProtocolResult command;
private String client;
private String storeDomain;
public Task(TaskStatus status, ProtocolWriter.ProtocolResult command, String client) {
/**
* Défini le context courrant dans laquelle la tâche opère
*/
private Context context;
public Task(Context context, TaskStatus status, ProtocolWriter.ProtocolResult command) {
this.context = context;
this.status = status;
this.command = command;
this.client = client;
}
public static Task newInstance(ProtocolWriter.ProtocolResult command, String client) {
Task task = new Task(TaskStatus.PENDING, command, client);
/**
* Permet de créer une instance de la class {@link Task}
* @param context Context à utiliser pour cette tâche
* @param command Commande à exécuter
* @return L'instance de la tâche créée
*/
public static Task newInstance(Context context, ProtocolWriter.ProtocolResult command) {
Task task = new Task(context, TaskStatus.PENDING, command);
return task;
}
@ -28,7 +41,7 @@ public class Task {
* @return TRUE si le client doit recevoir cette réponse.
*/
public boolean isResponseOfClient(String storeDomain) {
return (status == TaskStatus.PROCESSING && this.storeDomain.equals(storeDomain));
return (status == TaskStatus.PROCESSING && context.getDomain().equals(storeDomain));
}
/**
@ -36,17 +49,32 @@ public class Task {
* @return Login du client
*/
public String getClient() {
return client;
return context.getLogin();
}
/**
* Permet de récupérer la commande à executer
* @return Commande à exécuter
*/
public ProtocolWriter.ProtocolResult getCommand() {
return this.command;
}
/**
* Permet de définir le StorBackEnd à utiliser pour cette tâche
* @param storeDomain Le StorBackEnd à utiliser
*/
public void setDomain(String storeDomain) {
this.storeDomain = storeDomain;
context.setDomain(storeDomain);
if (storeDomain != null) {
this.status = TaskStatus.PROCESSING;
}
}
/**
* Défini le context courrant dans laquelle la tâche opère
*/
public Context getContext() {
return this.context;
}
}

159
app/src/main/java/lightcontainer/domains/client/ClientHandler.java
View File

@ -1,13 +1,19 @@
package lightcontainer.domains.client;
import lightcontainer.domains.server.UnicastServerListener;
import lightcontainer.interfaces.ClientHandlerFFE;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.interfaces.UnicastCHR;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.ProtocolWriter;
import lightcontainer.protocol.rules.reader.SigninRule;
import lightcontainer.protocol.rules.reader.SignoutRule;
import lightcontainer.protocol.rules.reader.SignupRule;
import lightcontainer.protocol.rules.writer.SignErrorRule;
import lightcontainer.protocol.rules.writer.SignOkRule;
import javax.crypto.BadPaddingException;
import javax.net.ssl.SSLHandshakeException;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
@ -31,23 +37,22 @@ public class ClientHandler implements Runnable, AutoCloseable {
private ClientHandlerFFE fileFrontEnd;
private final Socket client;
private ProtocolRepository protocolRep;
private Context context;
private boolean client_run;
private UnicastCHR repository;
/**
* Login of client.
* State : NULL if not connected and Login string if connected
*/
private String login;
private BufferedReader reader;
private PrintWriter writer;
private ProtocolWriter.ProtocolResult response;
// Constructor
public ClientHandler(Socket client, ClientHandlerFFE ffe, ProtocolRepository protocolRep) {
public ClientHandler(UnicastCHR repository, Socket client, ClientHandlerFFE ffe, ProtocolRepository protocolRep, Context context) {
this.repository = repository;
this.fileFrontEnd = ffe;
this.client = client;
this.protocolRep = protocolRep;
this.context = context;
this.client_run = false;
initClient();
}
@ -61,6 +66,7 @@ public class ClientHandler implements Runnable, AutoCloseable {
* @see PrintWriter
*/
private void initClient() {
// Start the thread
try {
this.reader = new BufferedReader(new InputStreamReader(
this.client.getInputStream(),
@ -85,22 +91,31 @@ public class ClientHandler implements Runnable, AutoCloseable {
public void run() {
this.client_run = true;
while (this.client_run) {
// Signifie le démarrage d'une nouvelle rquête
context.newBundle();
try {
String command = this.reader.readLine();
if (command != null) System.out.println("Client: " + command);
if (command != null) {
System.out.println("Client: " + command);
} else {
repository.disconnect(this);
break;
}
ProtocolReader.ProtocolResult ruleResult = protocolRep.executeReader(command + "\r\n");
ProtocolReader.ProtocolResult ruleResult = protocolRep.executeReader(context, command + "\r\n");
if (ruleResult == null) {
repository.disconnect(this);
break;
}
if (checkAccess(ruleResult)) {
ruleResult.read(this.client.getInputStream());
if (isConnected()) {
ruleResult.read(
this.client.getInputStream()
);
ProtocolWriter.ProtocolResult writerCommand = ruleResult.getResultCommand();
if (ruleResult.getReceiver() == ProtocolReader.ResultCmdReceiver.STOREBACKEND) {
fileFrontEnd.newCommand(
writerCommand,
getLogin()); // Envoie dans la file de tâche FileFrontEnd en attente d'un traitement d'un StorBackEnd
fileFrontEnd.newCommand(context, writerCommand); // Envoie dans la file de tâche FileFrontEnd en attente d'un traitement d'un StorBackEnd
// Attend la fin de la réalisation de la tâche
waitTaskResponse();
@ -109,15 +124,82 @@ public class ClientHandler implements Runnable, AutoCloseable {
writer.flush();
response.write(this.client.getOutputStream()); // Ecrit au client si nécessaire
} else {
writer.write(writerCommand.getCommand()); // Renvoye au client
writer.print(writerCommand.getCommand()); // Renvoye au client
writer.flush();
}
} else {
authentication(ruleResult);
System.out.println(4);
accessDenied();
}
} catch (IOException ignore) { }
} catch (IOException ignore) {
ignore.printStackTrace();
repository.disconnect(this);
break;
}
}
try {
this.reader.close();
this.writer.close();
this.client.close();
System.out.printf("[CLIENT] %s s'est déconnecté\n", context.getLogin());
} catch (IOException ignored) { }
}
/**
* Permet de vérifier si le client possède l'accès demandé
* @param ruleResult La règle
* @return TRUE si le client possède l'accès demandé
*/
private boolean checkAccess(ProtocolReader.ProtocolResult ruleResult) {
checkSignout(ruleResult);
if (context.isConnected())
return true;
try {
ruleResult
.getClass()
.asSubclass(SignupRule.Result.class);
return true;
} catch (ClassCastException e) {
try {
ruleResult.getClass().asSubclass(SigninRule.Result.class);
return true;
} catch (ClassCastException e2) { }
}
return false;
}
/**
* Lorsque l'accès à été refusé.
*/
private void accessDenied() {
ProtocolWriter.ProtocolResult signErrorResult = protocolRep.executeWriter(context, SignErrorRule.NAME);
writer.write(signErrorResult.getCommand()); // Envoie SignError car echec de la connection
writer.flush();
}
/**
* Vérifie s'il s'âgit d'une demande de déconnexion
* @param ruleResult
*/
private void checkSignout(ProtocolReader.ProtocolResult ruleResult) {
try {
ruleResult.getClass().asSubclass(SignoutRule.Result.class);
repository.disconnect(this);
} catch (ClassCastException e2) { }
}
/**
* Vérifie s'il s'âgit d'une demande de déconnexion
* @param ruleResult
*/
private void checkSignError(ProtocolWriter.ProtocolResult ruleResult) {
if (ruleResult.getCommand().startsWith(SignErrorRule.NAME)) {
System.out.println("Pas pu connecter");
repository.disconnect(this);
}
}
@ -132,6 +214,10 @@ public class ClientHandler implements Runnable, AutoCloseable {
}
}
/**
* Permet d'envoyer la réponse au client.
* @param response La réponse
*/
public void respond(ProtocolWriter.ProtocolResult response) {
this.response = response;
synchronized (this) {
@ -139,32 +225,6 @@ public class ClientHandler implements Runnable, AutoCloseable {
}
}
private void authentication(ProtocolReader.ProtocolResult ruleResult) {
try {
SigninRule.Result signinResult = (SigninRule.Result) ruleResult;
if (signinResult.checkCredentials()) {
this.login = signinResult.getLogin();
ProtocolWriter.ProtocolResult signokResult = protocolRep.executeWriter(SignOkRule.NAME);
writer.write(signokResult.getCommand());
writer.flush();
return;
}
} catch (ClassCastException ignored) {}
ProtocolWriter.ProtocolResult signErrorResult = protocolRep.executeWriter(SignErrorRule.NAME);
writer.write(signErrorResult.getCommand()); // Envoie SignError car echec de la connection
writer.flush();
this.close(); // Fermeture de la connection
}
/**
* Permet de savoir si l'utilisateur s'est connecté (Avec login et mdp)
* @return
*/
private boolean isConnected() {
return login != null;
}
/**
* AutoClosable Function
* Close the Client thread and resources.
@ -173,15 +233,12 @@ public class ClientHandler implements Runnable, AutoCloseable {
*/
@Override
public void close() {
if (this.client_run) {
try {
this.client_run = false;
this.client.close();
} catch (IOException ignored) { }
}
System.out.println("Call close");
this.client_run = false;
}
public String getLogin() {
return this.login;
return this.context.getLogin();
}
}

190
app/src/main/java/lightcontainer/domains/client/Context.java Normal file
View File

@ -0,0 +1,190 @@
package lightcontainer.domains.client;
import lightcontainer.storage.AppData;
import lightcontainer.storage.File;
import lightcontainer.storage.Repository;
import lightcontainer.storage.User;
import lightcontainer.utils.AES_GCM;
import lightcontainer.utils.ShaHasher;
import java.security.NoSuchAlgorithmException;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
/**
* Contexte associé à la requête d'un utilisateur.
* Permet de récupérer les données à celui-ci et d'effectuer des actions sur le context courant.
*/
public class Context {
private Repository repository;
private RequestBundle requestBundle;
/**
* Login de l'utilisateur
*/
private String login;
/**
* Domain s'occupant de la requête
*/
private String domain;
// Constructeur
public Context(Repository repository) {
this.repository = repository;
}
/**
* Permet de créer un utilisateur.
*
* @param login Login de l'utilisateur
* @param password Mot de passe de l'utilisateur
* @return TRUE si l'utilisateur a pu être créé
*/
public boolean createUser(String login, String password) {
try {
String key = AES_GCM.generateSecretKey();
ShaHasher hasher = new ShaHasher(password);
password = hasher.nextHashing();
String passwordSalt = hasher.getSalt();
if (this.repository.addUser(login, password, key, passwordSalt)) {
this.login = login;
return true;
}
} catch (AES_GCM.AesGcmException e) {
}
return false;
}
/**
* Login de l'utilisateur
*
* @return Login de l'utilisateur
*/
public String getLogin() {
return this.login;
}
/**
* Permet de demander la connection de l'utilisateur
*
* @param login Login
* @param password Mot de passe
* @return TRUE si l'utilisateur a été authentifié
*/
public boolean signIn(String login, String password) {
String passwordSalt = this.repository.getUserPasswordSalt(login);
if (passwordSalt != null) {
ShaHasher hasher = new ShaHasher(password);
if (this.repository.verifyUser(login, hasher.fromSalt(hasher.saltToByte(passwordSalt)))) {
this.login = login;
return true;
}
}
return false;
}
/**
* Permet de savoir si l'utilisateur s'est connecté (Avec login et mdp)
*
* @return TRUE si l'utilisateur est connecté
*/
public boolean isConnected() {
return this.getLogin() != null;
}
/**
* Clé AES de l'utilisateur
*
* @return Clé AES de l'utilisateur
*/
public String getAesKey() {
return this.repository.getUserAesKey(getLogin());
}
/**
* Permet de régénérer le Requestbundle courant. Méthode appelée lorsque l'on souhaite
*/
public void newBundle() {
requestBundle = new RequestBundle();
}
/**
* Permet d'ajouter des données pour la requête courrante
*
* @param key La clé permettant de retrouver la valeur
* @param value La valeur associée à la clé
*/
public void putDataString(String key, String value) {
requestBundle.putString(key, value);
}
/**
* Permet d'ajouter des données pour la requête courrante
*
* @param key La clé permettant de retrouver la valeur
* @param value La valeur associée à la clé
*/
public void putDataInt(String key, int value) {
requestBundle.putInt(key, value);
}
/**
* Permet de récupérer des données pour la requête courrante
*
* @param key La clé permettant de retrouver la valeur
* @return La valeur associée à la clé ou null
*/
public String getDataString(String key) {
return requestBundle.getString(key);
}
/**
* Permet de récupérer des données pour la requête courrante
*
* @param key La clé permettant de retrouver la valeur
* @return La valeur associée à la clé
*/
public int getDataInt(String key) {
return requestBundle.getInt(key);
}
/**
* Permet d'ajouter un fichier à l'utilisateur
*
* @param fileName Nom du fichier hashé
* @param fileNameSalt Salt appliqué sur le nom du fichier
* @param size Taille du fichier
* @param iv IV du fichier
* @param domain Domain dans lequel est stocké le fichier
* @return TRUE si le fichier a pu être enregistré.
*/
public boolean addFile(String fileName, String fileNameSalt, int size, String iv, String domain) {
return this.repository.addFileFor(new File(fileName, fileNameSalt, size, iv, Set.of(domain)), getLogin());
}
public List<String> getStringifiedFilesOf() {
return repository.getStringifiedFilesOf(login);
}
public boolean canAddFile() {
return repository.canAddFile(login);
}
public String getDomain() {
return this.domain;
}
public void setDomain(String domain) {
this.domain = domain;
}
}

48
app/src/main/java/lightcontainer/domains/client/RequestBundle.java Normal file
View File

@ -0,0 +1,48 @@
package lightcontainer.domains.client;
import java.util.HashMap;
import java.util.Map;
public class RequestBundle {
private Map<String, String> stringData = new HashMap<>();
private Map<String, Integer> intData = new HashMap<>();
/**
* Permet d'ajouter des String
* @param key La clé permettant de retrouver la valeur
* @param value La valeur associée à la clé
*/
public void putString(String key, String value) {
stringData.put(key, value);
}
/**
* Permet d'ajouter des int
* @param key La clé permettant de retrouver la valeur
* @param value La valeur associée à la clé
*/
public void putInt(String key, int value) {
intData.put(key, value);
}
/**
* Permet de récupérer des données string
* @param key La clé permettant de retrouver la valeur
* @return La valeur associée à la clé ou null
*/
public String getString(String key) {
return stringData.get(key);
}
/**
* Permet de récupérer des données int
* @param key La clé permettant de retrouver la valeur
* @return La valeur associée à la clé
*/
public int getInt(String key) {
return intData.get(key);
}
}

7
app/src/main/java/lightcontainer/domains/client/StoreProcessor.java
View File

@ -33,6 +33,7 @@ public class StoreProcessor extends Thread implements AutoCloseable {
private boolean client_run;
private BufferedReader reader;
private Context context;
private PrintWriter writer;
private ProtocolWriter.ProtocolResult protocolResult;
private ProtocolRepository protocolRep;
@ -95,7 +96,7 @@ public class StoreProcessor extends Thread implements AutoCloseable {
String responseCommand = this.reader.readLine() + "\r\n";
if (responseCommand != null)
System.out.println("StoreBackEnd: " + responseCommand);
ProtocolReader.ProtocolResult responseResult = protocolRep.executeReader(responseCommand);
ProtocolReader.ProtocolResult responseResult = protocolRep.executeReader(context, responseCommand);
responseResult.read(
this.store.getInputStream()
);
@ -111,9 +112,10 @@ public class StoreProcessor extends Thread implements AutoCloseable {
* Permet de demander au StoreBackEnd d'effectuer une commande
* @param protocolResult La commande à effectuer
*/
public void executeCommand(ProtocolWriter.ProtocolResult protocolResult) {
public void executeCommand(Context context, ProtocolWriter.ProtocolResult protocolResult) {
synchronized (this) {
this.protocolResult = protocolResult;
this.context = context;
this.notify();
}
}
@ -125,7 +127,6 @@ public class StoreProcessor extends Thread implements AutoCloseable {
synchronized (this) {
this.protocolResult = null;
fileFrontEnd.onStoreAvailable(this, responseCommand);
waitAction();
}
}

2
app/src/main/java/lightcontainer/domains/server/MulticastServerListener.java
View File

@ -67,7 +67,7 @@ public class MulticastServerListener implements Runnable {
// Create a new StoreBacked (try used in the case of an error to maintain the listening loop)
try {
// TODO Récupérer le port du message du packet et le setup (add description of the line).
HelloRule.Result readerResult = protocolRep.executeReader(data);
HelloRule.Result readerResult = protocolRep.executeReader(null, data);
System.out.printf("Nouveau SBE : Domain=%s | Port=%d\n", readerResult.getDomain(), readerResult.getPort());
Socket socket = new Socket(packet.getAddress(), readerResult.getPort());

31
app/src/main/java/lightcontainer/domains/server/UnicastServerListener.java
View File

@ -1,10 +1,16 @@
package lightcontainer.domains.server;
import lightcontainer.domains.client.ClientHandler;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.interfaces.UnicastCHR;
import lightcontainer.repository.FileFrontEnd;
import lightcontainer.storage.AppData;
import lightcontainer.storage.Repository;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.SSLSocket;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
@ -17,12 +23,14 @@ public class UnicastServerListener implements Runnable {
private ProtocolRepository protocolRep;
private final int server_port;
private boolean server_run;
private Repository repositoryStorage;
// Constructor
public UnicastServerListener(FileFrontEnd ffe, UnicastCHR repository, ProtocolRepository protocolRep, int port) {
public UnicastServerListener(FileFrontEnd ffe, UnicastCHR repository, ProtocolRepository protocolRep, Repository repositoryStorage, int port) {
this.ffe = ffe;
this.repository = repository;
this.protocolRep = protocolRep;
this.repositoryStorage = repositoryStorage;
this.server_port = port;
this.server_run = false;
repository.setServerListener(this);
@ -31,23 +39,23 @@ public class UnicastServerListener implements Runnable {
/**
* Initializes the server and starts it on the previously selected port.
*
* @since 1.0
*
* @see Thread#start()
* @see ClientHandler
* @see Thread#start()
* @see ClientHandler
* @since 1.0
*/
@Override
public void run() {
try {
// Allow looping in the loop and create a socket server
SSLServerSocketFactory sslserversocketfactory = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
this.server = sslserversocketfactory.createServerSocket(this.server_port);
this.server_run = true;
this.server = new ServerSocket(this.server_port);
while (this.server_run) {
// Accepting connection requests (blocking)
Socket client = this.server.accept();
System.out.println("New Client");
SSLSocket client = (SSLSocket) this.server.accept();
// Create a new Handler client by passing these dependencies to it
ClientHandler clientHandler = new ClientHandler(client, ffe, protocolRep); // TODO passer FileFrontEnd ou faire ca dans le repository ?!
ClientHandler clientHandler = new ClientHandler(this.repository, client, ffe, protocolRep, new Context(repositoryStorage));
// Add the client handler to its repository (clienthandlerrepository)
this.repository.addClient(clientHandler);
// Start the thread
@ -61,14 +69,15 @@ public class UnicastServerListener implements Runnable {
/**
* Stops the server and terminates the new connection.
*
* @since 1.0
* @since 1.0
*/
public void stop() {
if (this.server_run) {
try {
this.server_run = false;
this.server.close();
} catch (IOException ignored) { }
} catch (IOException ignored) {
}
}
}

5
app/src/main/java/lightcontainer/interfaces/ClientHandlerFFE.java
View File

@ -1,6 +1,7 @@
package lightcontainer.interfaces;
import lightcontainer.domains.client.ClientHandler;
import lightcontainer.domains.client.Context;
import lightcontainer.protocol.ProtocolWriter;
import lightcontainer.repository.FileFrontEnd;
@ -12,9 +13,9 @@ public interface ClientHandlerFFE {
/**
* Demande le traitement d'une commande
* @param context Context de la requête
* @param command Commande à traiter
* @param client identifiant du client à qui est affilié cette commande
*/
void newCommand(ProtocolWriter.ProtocolResult command, String client);
void newCommand(Context context, ProtocolWriter.ProtocolResult command);
}

5
app/src/main/java/lightcontainer/interfaces/ProtocolRepository.java
View File

@ -1,13 +1,14 @@
package lightcontainer.interfaces;
import lightcontainer.domains.client.Context;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.ProtocolWriter;
public interface ProtocolRepository {
<T extends ProtocolReader.ProtocolResult> T executeReader(String data);
<T extends ProtocolReader.ProtocolResult> T executeReader(Context context, String data);
<T extends ProtocolWriter.ProtocolResult> T executeWriter(String cmdName, String... data);
<T extends ProtocolWriter.ProtocolResult> T executeWriter(Context context, String cmdName, String... data);
void addReader(ProtocolReader reader);

6
app/src/main/java/lightcontainer/interfaces/UnicastCHR.java
View File

@ -22,5 +22,11 @@ public interface UnicastCHR {
*/
void addClient(ClientHandler client);
/**
* Permet de demander la déconnection d'un client
* @param client Le client à déconnecter
*/
void disconnect(ClientHandler client);
void respondToClient(String client, ProtocolWriter.ProtocolResult response);
}

80
app/src/main/java/lightcontainer/protocol/ProtocolReader.java
View File

@ -1,15 +1,22 @@
package lightcontainer.protocol;
import lightcontainer.domains.client.Context;
import java.io.InputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Permet de construire des règles ayant pour but de parser une commande en un résultat utilisable par celle-ci
*/
public abstract class ProtocolReader {
private final String name;
// Variables
private final Pattern rulePattern;
// Constructor
protected ProtocolReader(String pattern) {
protected ProtocolReader(String name, String pattern) {
this.name = name;
this.rulePattern = Pattern.compile(pattern);
}
@ -29,6 +36,15 @@ public abstract class ProtocolReader {
*/
private ProtocolWriter.ProtocolResult resultCommand;
/**
* Le context courant
*/
private Context context;
public ProtocolResult(Context context) {
this.context = context;
}
/**
* Désigne vers ou cette commande est envoyée.
* ResultCmdReceiver.CLIENT : Signifie que cette commande va être directement revoyée au client.
@ -42,6 +58,7 @@ public abstract class ProtocolReader {
/**
* Récupérer la commande à envoyer
*
* @return Commande
*/
public ProtocolWriter.ProtocolResult getResultCommand() {
@ -50,8 +67,9 @@ public abstract class ProtocolReader {
/**
* Mettre la commande à envoyer
*
* @param resultCommand Commande à envoyer
* @param receiver Le receveur de cette commande
* @param receiver Le receveur de cette commande
*/
public void setResultCommand(ProtocolWriter.ProtocolResult resultCommand, ResultCmdReceiver receiver) {
this.resultCommand = resultCommand;
@ -61,32 +79,72 @@ public abstract class ProtocolReader {
/**
* Permet de lire un fichier. Cad reçevoir le contenu d'un fichier provenant du réseau.
* Redéfinissez cette méthode pour l'utiliser
*
* @param reader Buffer rempli du fichier
*/
public void read(InputStream reader) {}
public void read(InputStream reader) {
}
/**
* Permet de récupérer le context courant
* @return Context courant
*/
protected Context getContext() {
return context;
}
}
/**
* Permet de lancer la décomposition d'une commande pour en extraire les données
*
* @param data Contenu de la commande
*/
public <T extends ProtocolResult> T execute(String data) {
Matcher ruleMatcher = this.rulePattern.matcher(data);
public <T extends ProtocolResult> T execute(Context context, String data) {
String name = extractName(data);
if (ruleMatcher.matches()) {
String[] groups = new String[ruleMatcher.groupCount()];
if (name != null && name.equals(this.name)) {
Matcher ruleMatcher = this.rulePattern.matcher(data);
// Vérifier que la commande match
if (ruleMatcher.matches()) {
String[] groups = new String[ruleMatcher.groupCount()];
for (int i = 1; i <= groups.length; ++i)
groups[i - 1] = ruleMatcher.group(i);
for (int i = 1; i <= groups.length; ++i)
groups[i - 1] = ruleMatcher.group(i);
return onExecuted(groups);
return onExecuted(context, groups);
} else {
return onError(context);
}
}
return null;
}
private String extractName(String data) {
String name;
int endIndex = data.indexOf(' ');
if (endIndex > 0) {
name = data.substring(0, endIndex);
} else {
endIndex = data.indexOf('\r');
name = data.substring(0, endIndex);
}
return name;
}
/**
* Cette méthode est appelée lors de l'exécution de la règle
*
* @param data Paramètres pour créer la commande.
*/
protected abstract <T> T onExecuted(String... data);
protected abstract <T extends ProtocolResult> T onExecuted(Context context, String... data);
/**
* Cette méthode est appelée lors d'une erreur de la règle
*/
protected <T extends ProtocolResult> T onError(Context context) {
return null;
}
}

33
app/src/main/java/lightcontainer/protocol/ProtocolWriter.java
View File

@ -1,11 +1,14 @@
package lightcontainer.protocol;
import java.io.InputStream;
import lightcontainer.domains.client.Context;
import java.io.OutputStream;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Représente une construction de tâche.
*/
public abstract class ProtocolWriter {
// Variables
private final Pattern rulePattern;
@ -27,8 +30,14 @@ public abstract class ProtocolWriter {
public static class ProtocolResult {
private final Context context;
private String command;
public ProtocolResult(Context context) {
this.context = context;
}
public String getCommand() {
return command;
}
@ -43,14 +52,22 @@ public abstract class ProtocolWriter {
* @param writer Buffer à remplir qui sera envoyer via le réseau
*/
public void write(OutputStream writer) {}
/**
* Accesseur au contexte courant sur lequel opère la commande
* @return Context
*/
public Context getContext() {
return context;
}
}
/**
* Permet de contruire une commande selon une règle établie.
* @param data Les données à ajouter dans la commande; L'ordre défini leur position dans la commande
* @return La commande construite
* @return La commande construites
*/
public final <T extends ProtocolResult> T execute(String... data) {
public final <T extends ProtocolResult> T execute(Context context, String... data) {
// Concatatène le nom de la commande avec les données (trim), avec un espace entre chaque
StringBuilder builder = new StringBuilder(this.cmdName);
@ -59,9 +76,9 @@ public abstract class ProtocolWriter {
String command = builder + "\r\n";
Matcher ruleMatcher = this.rulePattern.matcher(command); // Vérifie que tout match (cf. Matcher). Si match alors on retourne la commande build, sinon on retourne NULL
System.out.println("Essaye : " + command);
if (ruleMatcher.matches()) {
ProtocolResult result = onExecuted(data);
ProtocolResult result = onExecuted(context, data);
result.setCommand(command);
return (T) result;
}
@ -72,8 +89,8 @@ public abstract class ProtocolWriter {
/**
* Cette méthode est appelée lors de l'exécution de la règle
*/
protected <T extends ProtocolResult> T onExecuted(String... data) {
return (T) new ProtocolResult();
protected <T extends ProtocolResult> T onExecuted(Context context, String... data) {
return (T) new ProtocolResult(context);
}
}

35
app/src/main/java/lightcontainer/protocol/rules/reader/FilelistRule.java
View File

@ -1,33 +1,54 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.ProtocolWriter;
import lightcontainer.protocol.rules.writer.FilesRule;
import lightcontainer.protocol.rules.writer.SignOkRule;
import java.util.List;
/**
* Règle permettant de récupérer la liste des fichiers d'un utilisateur
*/
public class FilelistRule extends ProtocolReader {
// Constants
private static final String PATTERN = "^FILELIST\r\n$";
private static final String NAME = "FILELIST";
private ProtocolRepository protocolRep;
// Constructor
public FilelistRule(ProtocolRepository protocolRep) {
super(PATTERN);
super(NAME, PATTERN);
this.protocolRep = protocolRep;
}
public class Result extends ProtocolResult { }
public class Result extends ProtocolResult {
public Result(Context context) {
super(context);
}
}
/**
* Cette méthode est appelée lors de l'exécution de la règle
*
* @param data Paramètres pour créer la commande.
*/
@Override
protected FilelistRule.Result onExecuted(String... data) {
FilelistRule.Result result = new Result();
result.setResultCommand(this.protocolRep.executeWriter(FilesRule.NAME, "endbenja.txt!500"), ResultCmdReceiver.CLIENT);
protected FilelistRule.Result onExecuted(Context context, String... data) {
FilelistRule.Result result = new Result(context);
List<String> files = context.getStringifiedFilesOf();
if (files != null) {
result.setResultCommand(this.protocolRep.executeWriter(context, FilesRule.NAME, files.toArray(new String[0])), ResultCmdReceiver.CLIENT);
} else {
result.setResultCommand(this.protocolRep.executeWriter(context, FilesRule.NAME), ResultCmdReceiver.CLIENT);
}
return result;
}
@Override
protected <T extends ProtocolResult> T onError(Context context) {
return super.onError(context);
}
}

20
app/src/main/java/lightcontainer/protocol/rules/reader/HelloRule.java
View File

@ -1,15 +1,17 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.protocol.ProtocolReader;
import java.io.BufferedReader;
import java.util.ArrayList;
import java.util.List;
/**
* Règle permettant d'être alerter de l'annoncement d'un SBE
*/
public class HelloRule extends ProtocolReader {
private static final String PATTERN = "^HELLO ([A-Za-z0-9]{5,20}) ([0-9]{1,5})\r\n$";
private static final String NAME = "HELLO";
// Index du domain dans le tableau de donnée
private static final int DOMAIN = 0;
@ -17,7 +19,7 @@ public class HelloRule extends ProtocolReader {
private static final int PORT = 1;
public HelloRule() {
super(PATTERN);
super(NAME, PATTERN);
}
@ -26,7 +28,8 @@ public class HelloRule extends ProtocolReader {
private final String domain;
private final int port;
public Result(String domain, int port) {
public Result(Context context, String domain, int port) {
super(context);
this.domain = domain;
this.port = port;
}
@ -39,16 +42,15 @@ public class HelloRule extends ProtocolReader {
return port;
}
}
@Override
protected HelloRule.Result onExecuted(String... data) {
protected HelloRule.Result onExecuted(Context context, String... data) {
String domain = data[DOMAIN];
int port = Integer.parseInt(data[PORT]);
return new HelloRule.Result(domain, port);
return new HelloRule.Result(context, domain, port);
}
}

79
app/src/main/java/lightcontainer/protocol/rules/reader/SavefileRule.java
View File

@ -1,36 +1,52 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.rules.writer.SaveFileErrorRule;
import lightcontainer.protocol.rules.writer.SaveFileOkRule;
import lightcontainer.protocol.rules.writer.SendfileRule;
import lightcontainer.utils.AES_GCM;
import lightcontainer.utils.FileReceiver;
import lightcontainer.utils.SHA;
import lightcontainer.utils.ShaHasher;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.security.NoSuchAlgorithmException;
/**
* Règle permettant de sauvegarder un fichier sur le SBE.
* Celui-ci va chiffre le contenu du fichier à l'aide de AES.
*/
public class SavefileRule extends ProtocolReader {
// Constants
private static final String PATTERN = "^SAVEFILE ([^ !]{1,20}) ([0-9]{1,10})\r\n$";
private static final String NAME = "SAVEFILE";
private static final int FILE_NAME = 0; // Index file name.
private static final int FILE_SIZE = 1; // Index file size.
private ProtocolRepository protocolRep;
private String storagePath;
// Constructor
public SavefileRule(ProtocolRepository protocolRep) {
super(PATTERN);
public SavefileRule(ProtocolRepository protocolRep, String storagePath) {
super(NAME, PATTERN);
this.protocolRep = protocolRep;
this.storagePath = storagePath;
}
public class Result extends ProtocolResult {
// Variables
private final String filename;
private final int size;
private String filename;
private int size;
// Construct
public Result(String filename, int size) {
public Result(Context context, String filename, int size) {
super(context);
this.filename = filename;
this.size = size;
}
@ -40,27 +56,60 @@ public class SavefileRule extends ProtocolReader {
super.read(reader);
System.out.printf("Sauvegarde du fichier : %s %d\n", filename, size);
try {
FileReceiver fileReceiver = new FileReceiver("/home/benjamin/ffe"); // "D:\\");
if (!fileReceiver.receiveFile(reader, this.filename, this.size))
throw new IOException();
if (getContext().canAddFile()) {
try {
FileReceiver fileReceiver = new FileReceiver(storagePath);
getContext().putDataString("fileName", this.filename);
this.setResultCommand(protocolRep.executeWriter(SendfileRule.NAME, this.filename, String.valueOf(this.size), "EMPREINTEBLBLBLBLBLABLABLBALBALBALBALBALBALBALBALBALABLBALBALBALABLABLABLABLABLABLABALBLABALABLABLABLABKJABKAHBHKBHJbhjvgkh"), ResultCmdReceiver.STOREBACKEND);
} catch (IOException e) {
this.setResultCommand(protocolRep.executeWriter(SaveFileErrorRule.NAME), ResultCmdReceiver.CLIENT);
e.printStackTrace();
// Ajout login devant le nom du fichier
this.filename = getContext().getLogin() + "_" + this.filename;
// Hashage du nom du fichier
ShaHasher hasher = new ShaHasher(this.filename);
this.filename = hasher.nextHashing();
String fileNameSalt = hasher.getSalt();
String key = getContext().getAesKey();
String iv = AES_GCM.generateIV();
// retrieve file and new size
int encryptedFileSize = fileReceiver.receiveFile(reader, this.filename, this.size, key, iv);
if (encryptedFileSize < 0) throw new IOException();
String fileHash = SHA.hashFile(storagePath, this.filename);
// On met les données de la requête actuelle
getContext().putDataInt("size", size);
getContext().putDataString("iv", iv);
getContext().putDataString("fileNameSalt", fileNameSalt);
this.setResultCommand(protocolRep.executeWriter(getContext(), SendfileRule.NAME, this.filename, String.valueOf(encryptedFileSize), fileHash), ResultCmdReceiver.STOREBACKEND);
} catch (IOException | SHA.ShaException e) {
this.setResultCommand(protocolRep.executeWriter(getContext(), SaveFileErrorRule.NAME), ResultCmdReceiver.CLIENT);
e.printStackTrace();
}
} else {
this.setResultCommand(protocolRep.executeWriter(getContext(), SaveFileErrorRule.NAME), ResultCmdReceiver.CLIENT);
}
}
}
/**
* Cette méthode est appelée lors de l'exécution de la règle
*
* @param data Paramètres pour créer la commande.
*/
@Override
protected SavefileRule.Result onExecuted(String... data) {
SavefileRule.Result result = new SavefileRule.Result(data[FILE_NAME], Integer.parseInt(data[FILE_SIZE]));
protected SavefileRule.Result onExecuted(Context context, String... data) {
SavefileRule.Result result = new SavefileRule.Result(context, data[FILE_NAME], Integer.parseInt(data[FILE_SIZE]));
return result;
}
@Override
protected ProtocolReader.ProtocolResult onError(Context context) {
ProtocolReader.ProtocolResult result = new ProtocolReader.ProtocolResult(context);
// Commande renvoyée en cas d'erreur
result.setResultCommand(protocolRep.executeWriter(context, SaveFileErrorRule.NAME), ResultCmdReceiver.CLIENT);
return result;
}
}

35
app/src/main/java/lightcontainer/protocol/rules/reader/SendErrorRule.java Normal file
View File

@ -0,0 +1,35 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.rules.writer.SaveFileErrorRule;
import lightcontainer.protocol.rules.writer.SaveFileOkRule;
/**
* Règle permettant de de confirmer la sauvegrade d'un fichier.
*/
public class SendErrorRule extends ProtocolReader {
// Constants
private static final String PATTERN = "^SEND_ERROR\r\n$";
private static final String NAME = "SEND_ERROR";
private ProtocolRepository protocolRep;
// Constructor
public SendErrorRule(ProtocolRepository protocolRep) {
super(NAME, PATTERN);
this.protocolRep = protocolRep;
}
@Override
protected ProtocolResult onExecuted(Context context, String... data) {
ProtocolResult result = new ProtocolResult(context);
result.setResultCommand(protocolRep.executeWriter(context, SaveFileErrorRule.NAME), ResultCmdReceiver.CLIENT);
return result;
}
}

21
app/src/main/java/lightcontainer/protocol/rules/reader/SendOkRule.java
View File

@ -1,29 +1,38 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.ProtocolWriter;
import lightcontainer.protocol.rules.writer.SaveFileOkRule;
/**
* Règle permettant de de confirmer la sauvegrade d'un fichier.
*/
public class SendOkRule extends ProtocolReader {
// Constants
private static final String PATTERN = "^SEND_OK\r\n$";
private static final String NAME = "SEND_OK";
private ProtocolRepository protocolRep;
// Constructor
public SendOkRule(ProtocolRepository protocolRep) {
super(PATTERN);
super(NAME, PATTERN);
this.protocolRep = protocolRep;
}
@Override
protected ProtocolReader.ProtocolResult onExecuted(String... data) {
ProtocolReader.ProtocolResult result = new ProtocolReader.ProtocolResult();
result.setResultCommand(protocolRep.executeWriter(SaveFileOkRule.NAME), ResultCmdReceiver.CLIENT);
protected ProtocolReader.ProtocolResult onExecuted(Context context, String... data) {
ProtocolReader.ProtocolResult result = new ProtocolReader.ProtocolResult(context);
result.setResultCommand(protocolRep.executeWriter(context, SaveFileOkRule.NAME), ResultCmdReceiver.CLIENT);
// Sauvegarder dans JSON
System.out.println("Save en json du fichier");
context.addFile(context.getDataString("fileName"), context.getDataString("fileNameSalt"), context.getDataInt("size"), context.getDataString("iv"), context.getDomain());
return result;
}
}

44
app/src/main/java/lightcontainer/protocol/rules/reader/SigninRule.java
View File

@ -1,15 +1,20 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.rules.writer.SignErrorRule;
import lightcontainer.protocol.rules.writer.SignOkRule;
import java.io.InputStream;
/**
* Règle permettant de gérer la connection d'un utilisateur
*/
public class SigninRule extends ProtocolReader {
// Constants
private static final String PATTERN = "^SIGNIN ([A-Za-z0-9]{2,20}) ([^ !]{5,50})\r\n$";
private static final String PATTERN = "^SIGNIN ([A-Za-z0-9]{5,20}) ([^ !]{5,50})\r\n$";
private static final String NAME = "SIGNIN";
private static final int LOGIN = 0; // Index du domain dans le tableau de données
private static final int PASSWORD = 1; // Index du port dans le tableau de données
@ -17,7 +22,7 @@ public class SigninRule extends ProtocolReader {
// Constructor
public SigninRule(ProtocolRepository protocolRep) {
super(PATTERN);
super(NAME, PATTERN);
this.protocolRep = protocolRep;
}
@ -27,7 +32,8 @@ public class SigninRule extends ProtocolReader {
private final String password;
// Result constructor
public Result(String login, String password) {
public Result(Context context, String login, String password) {
super(context);
this.login = login;
this.password = password;
}
@ -40,26 +46,26 @@ public class SigninRule extends ProtocolReader {
return password;
}
public boolean checkCredentials() {
return getLogin().equals("aa") && getPassword().equals("aaaaa");
}
@Override
public void read(InputStream reader) {
}
}
@Override
protected SigninRule.Result onExecuted(String... data) {
SigninRule.Result result = new SigninRule.Result(data[LOGIN], data[PASSWORD]);
protected SigninRule.Result onExecuted(Context context, String... data) {
SigninRule.Result result = new SigninRule.Result(context, data[LOGIN], data[PASSWORD]);
// TODO : Création d'une règle d'écriture SIGN_OK et SIGN_ERROR proprement
if (result.checkCredentials()) {
result.setResultCommand(this.protocolRep.executeWriter(SignOkRule.NAME), ResultCmdReceiver.CLIENT);
if (context.signIn(result.getLogin(), result.getPassword())) {
result.setResultCommand(this.protocolRep.executeWriter(context, SignOkRule.NAME), ResultCmdReceiver.CLIENT);
} else {
result.setResultCommand(this.protocolRep.executeWriter(SignErrorRule.NAME), ResultCmdReceiver.CLIENT);
result.setResultCommand(this.protocolRep.executeWriter(context, SignErrorRule.NAME), ResultCmdReceiver.CLIENT);
}
return result;
}
@Override
protected ProtocolReader.ProtocolResult onError(Context context) {
ProtocolReader.ProtocolResult result = new ProtocolReader.ProtocolResult(context);
result.setResultCommand(protocolRep.executeWriter(context, SignErrorRule.NAME), ResultCmdReceiver.CLIENT);
return result;
}
}

30
app/src/main/java/lightcontainer/protocol/rules/reader/SignoutRule.java Normal file
View File

@ -0,0 +1,30 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.protocol.ProtocolReader;
/**
* Règle demandant la déconnexion du client
*/
public class SignoutRule extends ProtocolReader {
private static final String PATTERN = "^SIGNOUT\r\n$";
public static final String NAME = "SIGNOUT";
public SignoutRule() {
super(NAME, PATTERN);
}
public class Result extends ProtocolResult {
public Result(Context context) {
super(context);
}
}
@Override
protected <T extends ProtocolResult> T onExecuted(Context context, String... data) {
return null;
}
}

68
app/src/main/java/lightcontainer/protocol/rules/reader/SignupRule.java Normal file
View File

@ -0,0 +1,68 @@
package lightcontainer.protocol.rules.reader;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.rules.writer.SignErrorRule;
import lightcontainer.protocol.rules.writer.SignOkRule;
/**
* Règle permettant de gérer la création d'un utilisateur
*/
public class SignupRule extends ProtocolReader {
// Constants
private static final String PATTERN = "^SIGNUP ([A-Za-z0-9]{5,20}) ([^ !]{5,50})\r\n$";
private static final String NAME = "SIGNUP";
private static final int LOGIN = 0;
private static final int PASSWORD = 1;
private ProtocolRepository protocolRep;
public SignupRule(ProtocolRepository protocolRep) {
super(NAME, PATTERN);
this.protocolRep = protocolRep;
}
public class Result extends ProtocolResult {
//Variables
private final String login;
private final String password;
public Result(Context context, String login, String password) {
super(context);
this.login = login;
this.password = password;
}
public String getLogin() {
return login;
}
public String getPassword() {
return password;
}
}
@Override
protected SignupRule.Result onExecuted(Context context, String... data) {
SignupRule.Result result = new SignupRule.Result(context, data[LOGIN], data[PASSWORD]);
if (context.createUser(result.getLogin(), result.getPassword())) {
result.setResultCommand(this.protocolRep.executeWriter(context, SignOkRule.NAME), ResultCmdReceiver.CLIENT);
} else {
result.setResultCommand(this.protocolRep.executeWriter(context, SignErrorRule.NAME), ResultCmdReceiver.CLIENT);
}
return result;
}
@Override
protected ProtocolReader.ProtocolResult onError(Context context) {
ProtocolReader.ProtocolResult result = new ProtocolReader.ProtocolResult(context);
result.setResultCommand(protocolRep.executeWriter(context, SignErrorRule.NAME), ResultCmdReceiver.CLIENT);
return result;
}
}

3
app/src/main/java/lightcontainer/protocol/rules/writer/FilesRule.java
View File

@ -2,6 +2,9 @@ package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
/**
* Règle permettant de construire une commande contenant la liste des fichiers d'un utilisateur
*/
public class FilesRule extends ProtocolWriter {
private static final String PATTERN = "^FILES( ([^ !]{1,20})!([0-9]{1,10})){0,50}\r\n$";

3
app/src/main/java/lightcontainer/protocol/rules/writer/SaveFileErrorRule.java
View File

@ -2,6 +2,9 @@ package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
/**
* Règle signifiant que la sauvegarde d'un fichier a échoué
*/
public class SaveFileErrorRule extends ProtocolWriter {
private static final String PATTERN = "^SAVEFILE_ERROR\r\n$";

3
app/src/main/java/lightcontainer/protocol/rules/writer/SaveFileOkRule.java
View File

@ -2,6 +2,9 @@ package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
/**
* Règle signifiant que la sauvegarde d'un fichier fût un succès
*/
public class SaveFileOkRule extends ProtocolWriter {
private static final String PATTERN = "^SAVEFILE_OK\r\n$";

23
app/src/main/java/lightcontainer/protocol/rules/writer/SendfileRule.java
View File

@ -1,11 +1,14 @@
package lightcontainer.protocol.rules.writer;
import lightcontainer.domains.client.Context;
import lightcontainer.protocol.ProtocolWriter;
import lightcontainer.utils.FileReceiver;
import lightcontainer.utils.FileSender;
import java.io.OutputStream;
/**
* Règle envoyée au SBE, demandant la sauvegarde d'un fichier.
*/
public class SendfileRule extends ProtocolWriter {
private static final String PATTERN = "^SENDFILE [A-Za-z0-9.]{0,200} [0-9]{1,10} [A-Za-z0-9.]{50,200}\r\n$";
@ -15,9 +18,12 @@ public class SendfileRule extends ProtocolWriter {
private static final int HASHED_FILE_NAME = 0; // Index file name hashed.
private static final int FILE_SIZE = 1; // Index file size.
private static final int HASHED_FILE_CONTENT = 2; // Index file content hashed.
private String storagePath;
public SendfileRule() {
public SendfileRule(String storagePath) {
super(NAME, PATTERN);
this.storagePath = storagePath;
}
public class Result extends ProtocolWriter.ProtocolResult {
@ -26,7 +32,8 @@ public class SendfileRule extends ProtocolWriter {
private final int fileSize;
private final String hashedFileContent;
public Result(String hashedFileName, int fileSize, String hashedFileContent) {
public Result(Context context, String hashedFileName, int fileSize, String hashedFileContent) {
super(context);
this.hashedFileName = hashedFileName;
this.fileSize = fileSize;
this.hashedFileContent = hashedFileContent;
@ -36,14 +43,18 @@ public class SendfileRule extends ProtocolWriter {
public void write(OutputStream writer) {
super.write(writer);
System.out.println("Envoie du fichier au SBE");
FileSender fileSender = new FileSender("/home/benjamin/ffe");
FileSender fileSender = new FileSender(storagePath);
fileSender.sendFile(hashedFileName, writer);
// TODO : Supprimer le fichier du FFE
}
}
@Override
protected SendfileRule.Result onExecuted(String... data) {
return new SendfileRule.Result(data[HASHED_FILE_NAME], Integer.parseInt(data[FILE_SIZE]), data[HASHED_FILE_CONTENT]);
protected SendfileRule.Result onExecuted(Context context, String... data) {
return new SendfileRule.Result(context, data[HASHED_FILE_NAME], Integer.parseInt(data[FILE_SIZE]), data[HASHED_FILE_CONTENT]);
}
}

3
app/src/main/java/lightcontainer/protocol/rules/writer/SignErrorRule.java
View File

@ -2,6 +2,9 @@ package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
/**
* Règle renvoyée au client lorsque l'authentification a échoué.
*/
public class SignErrorRule extends ProtocolWriter {
private static final String PATTERN = "^SIGN_ERROR\r\n$";

3
app/src/main/java/lightcontainer/protocol/rules/writer/SignOkRule.java
View File

@ -2,6 +2,9 @@ package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
/**
* Règle renvoyée au client lorsque l'authentification a réusie.
*/
public class SignOkRule extends ProtocolWriter {
private static final String PATTERN = "^SIGN_OK\r\n$";

14
app/src/main/java/lightcontainer/protocol/rules/writer/SignoutRule.java
View File

@ -1,14 +0,0 @@
package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
public class SignoutRule extends ProtocolWriter {
private static final String PATTERN = "^SIGNOUT\r\n$";
public static final String NAME = "SIGNOUT";
public SignoutRule() {
super(NAME, PATTERN);
}
}

6
app/src/main/java/lightcontainer/repository/ClientHandlerRepository.java
View File

@ -55,6 +55,12 @@ public class ClientHandlerRepository implements AutoCloseable, UnicastCHR {
this.handlers.add(client);
}
@Override
public void disconnect(ClientHandler client) {
if (handlers.remove(client))
client.close();
}
@Override
public void respondToClient(String login, ProtocolWriter.ProtocolResult response) {
for (ClientHandler client : handlers) {

5
app/src/main/java/lightcontainer/repository/FileFrontEnd.java
View File

@ -1,5 +1,6 @@
package lightcontainer.repository;
import lightcontainer.domains.client.Context;
import lightcontainer.domains.client.StoreProcessor;
import lightcontainer.domains.Task;
import lightcontainer.enumerations.TaskStatus;
@ -76,8 +77,8 @@ public class FileFrontEnd implements ClientHandlerFFE, StoreProcessorFFE {
@Override
public void newCommand(ProtocolWriter.ProtocolResult command, String client) {
Task task = Task.newInstance(command, client);
public void newCommand(Context context, ProtocolWriter.ProtocolResult command) {
Task task = Task.newInstance(context, command);
tasks.add(task);
alertStoreProcessors(task);
}

10
app/src/main/java/lightcontainer/repository/ProtocolRepositoryImpl.java
View File

@ -1,5 +1,6 @@
package lightcontainer.repository;
import lightcontainer.domains.client.Context;
import lightcontainer.interfaces.ProtocolRepository;
import lightcontainer.protocol.ProtocolReader;
import lightcontainer.protocol.ProtocolWriter;
@ -12,9 +13,9 @@ public class ProtocolRepositoryImpl implements ProtocolRepository {
private final Set<ProtocolWriter> writers = new HashSet<>();
@Override
public <T extends ProtocolReader.ProtocolResult> T executeReader(String data) {
public <T extends ProtocolReader.ProtocolResult> T executeReader(Context context, String data) {
for (ProtocolReader reader : readers) {
T readerResult = reader.execute(data);
T readerResult = reader.execute(context, data);
if (readerResult != null) {
return readerResult;
}
@ -23,13 +24,14 @@ public class ProtocolRepositoryImpl implements ProtocolRepository {
}
@Override
public <T extends ProtocolWriter.ProtocolResult> T executeWriter(String cmdName, String... data) {
public <T extends ProtocolWriter.ProtocolResult> T executeWriter(Context context, String cmdName, String... data) {
for (ProtocolWriter writer : writers) {
T command;
if (cmdName.equals(writer.getCmdName()) && (command = writer.execute(data)) != null) {
if (cmdName.equals(writer.getCmdName()) && (command = writer.execute(context, data)) != null) {
return command;
}
}
System.out.println("COMMANDE NULL");
return null;
}

3
app/src/main/java/lightcontainer/repository/StoreProcessorRepository.java
View File

@ -74,7 +74,8 @@ public class StoreProcessorRepository implements AutoCloseable, MulticastSPR {
@Override
public void assignTask(String stor, Task task) {
StoreProcessor handler = findSBE(task);
handler.executeCommand(task.getCommand());
System.out.println("Find stor : " + handler);
handler.executeCommand(task.getContext(), task.getCommand());
}
/**

4
app/src/main/java/lightcontainer/storage/Adapter.java
View File

@ -1,8 +1,8 @@
package lightcontainer.storage;
public interface Adapter {
String toString();
String toString(AppData appData);
AppData fromString(String appDataString);
}

19
app/src/main/java/lightcontainer/storage/AppConfig.java
View File

@ -8,13 +8,14 @@ package lightcontainer.storage;
* @since 1.0
*/
public class AppConfig {
// Variables
private static AppConfig instance = null;
private int unicastPort;
private String multicastIp;
private int multicastPort;
private String networkInterface;
private boolean isTls;
private String storagePath;
/**
* Constructs a new instance of AppConfig.
@ -26,6 +27,7 @@ public class AppConfig {
this.multicastPort = -1;
this.networkInterface = "NONE";
this.isTls = false;
storagePath = "";
}
/**
@ -85,4 +87,19 @@ public class AppConfig {
public void setTls(boolean tls) {
this.isTls = tls;
}
/**
* Méthode permettant de récupérer le chemin de sauvegarde des fichiers
* @return Chemin de sauvegarde
*/
public String getStoragePath() {
return this.storagePath;
}
/**
* Méthode permettant d'assigner le chemin de sauvegarde des fichiers
*/
public void setStoragePath(String storagePath) {
this.storagePath = storagePath;
}
}

96
app/src/main/java/lightcontainer/storage/AppData.java
View File

@ -2,6 +2,7 @@ package lightcontainer.storage;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
@ -67,10 +68,33 @@ public class AppData {
return this.users.get(userName);
}
public List<String> getStringifiedFilesOf(String login) {
User user = users.get(login);
if (user != null) {
return user.getFilesWithSize();
}
return null;
}
/**
* Use this method when a user signs up.
*
* @return True if the user was added. False if a user with the same name already exists.
*/
public boolean addUser(String login, String password, String key, String passwordSalt) {
User user = new User(login, password, key, passwordSalt, new HashMap<>());
if (this.users.containsKey(user.getName())) {
return false;
} else {
this.users.put(user.getName(), user);
return true;
}
}
/**
* Use this method when a user signs up.
*
* @param user The user to add.
* @return True if the user was added. False if a user with the same name already exists.
*/
public boolean addUser(User user) {
@ -82,19 +106,17 @@ public class AppData {
}
}
public boolean canAddFile(String login) {
if (this.users.containsKey(login)) {
return this.users.get(login).canAddFile();
}
return false;
}
public Iterator<User> usersIterator() {
return users.values().iterator();
}
/**
* @param fileName The name of the file
* @param user The user
* @return The file corresponding to the given name and belonging to the user. Null if the user cannot be found or the file cannot be found
* @deprecated Maybe not useful. DO NOT USE FOR THE TIME BEING
*/
public File getFileOf(String fileName, User user) {
return this.users.get(user.getName()).getFile(fileName);
}
/**
* Call this method after receiving SAVEFILE_OK from the StorBackEnd.
@ -104,16 +126,15 @@ public class AppData {
* True indicates the success of the operation.
* False indicates the failure of the operation.
*
* @param file The file to add
* @param user The user who wants to add the file
* @param file The file to add
* @param userName The name of the user who wants to add the file
* @return True if the user is found and a file with the same name doesn't already exist for this user. False otherwise.
*/
public boolean addFileFor(File file, User user) {
if (!this.users.containsKey(user.getName())) {
public boolean addFileFor(File file, String userName) {
if (!this.users.containsKey(userName)) {
return false;
} else {
this.users.get(user.getName()).addFile(file);
return true;
return this.users.get(userName).addFile(file);
}
}
@ -125,28 +146,51 @@ public class AppData {
* False indicates the failure of the operation.
*
* @param fileName The name of the file to delete
* @param user The user who wants to delete the file
* @param userName The name of the user who wants to delete the file
* @return True if the user is found and the file was deleted. False otherwise.
*/
public boolean deleteFileOf(String fileName, User user) {
if (!this.users.containsKey(user.getName())) {
public boolean deleteFileOf(String fileName, String userName) {
if (!this.users.containsKey(userName)) {
return false;
} else {
return this.users.get(user.getName()).deleteFile(fileName);
return this.users.get(userName).deleteFile(fileName);
}
}
/**
* @param user The user who wants to add a storage for their file
* @param file The file that needs a new storage
* @param storage The storage to add
* @param userName The name of the user who wants to add a storage for their file
* @param file The file that needs a new storage
* @param storage The storage to add
* @return True if the storage was added. False otherwise.
*/
public boolean addStorage(User user, File file, String storage) {
if (!this.users.containsKey(user.getName())) {
public boolean addStorage(String userName, File file, String storage) {
if (!this.users.containsKey(userName)) {
return false;
} else {
return this.users.get(user.getName()).addStorage(file, storage);
return this.users.get(userName).addStorage(file, storage);
}
}
public boolean verifyUser(String login, String password) {
User user = getUser(login);
return user != null && user.verifyPassword(password);
}
public String getUserPasswordSalt(String login) {
User user = getUser(login);
return user == null ? null : user.getPasswordSalt();
}
/**
* Méthode permettant de récupérer la clé AES d'un utilisateur
*
* @param login Login de l'utilisateur
* @return Clé AES
*/
public String getUserAesKey(String login) {
User user = getUser(login);
return user == null ? null : user.getAesKey();
}
}

10
app/src/main/java/lightcontainer/storage/File.java
View File

@ -9,12 +9,14 @@ import java.util.Set;
public class File {
private final String name;
private final String fileNameSalt;
private final int size;
private final String iv;
private final Set<String> storage;
public File(String name, int size, String iv, Set<String> storage) {
public File(String name, String fileNameSalt, int size, String iv, Set<String> storage) {
this.name = name;
this.fileNameSalt = fileNameSalt;
this.size = size;
this.iv = iv;
this.storage = storage;
@ -24,6 +26,10 @@ public class File {
return name;
}
public String getFileNameSalt() {
return fileNameSalt;
}
public int getSize() {
return size;
}
@ -44,4 +50,6 @@ public class File {
return true;
}
}
}

23
app/src/main/java/lightcontainer/storage/JsonAdapter.java
View File

@ -9,18 +9,11 @@ import java.util.*;
*/
public class JsonAdapter implements Adapter {
private AppData appData;
public JsonAdapter(AppData appData) {
this.appData = appData;
}
/**
*
* @return A Json String containing AppData properties
*/
@Override
public String toString() {
public String toString(AppData appData) {
return addData(appData);
}
@ -32,6 +25,7 @@ public class JsonAdapter implements Adapter {
config.addProperty("multicast_port", appConfig.getMulticastPort());
config.addProperty("network_interface", appConfig.getNetworkInterface());
config.addProperty("tls", appConfig.isTls());
config.addProperty("storagePath", appConfig.getStoragePath());
JsonArray users = new JsonArray();
Iterator<User> userIterator = appData.usersIterator();
addUsers(users, userIterator);
@ -46,6 +40,7 @@ public class JsonAdapter implements Adapter {
user.addProperty("name", current.getName());
user.addProperty("password", current.getPassword());
user.addProperty("aes_key", current.getAesKey());
user.addProperty("passwordSalt", current.getPasswordSalt());
JsonArray files = new JsonArray();
Iterator<File> fileIterator = current.fileIterator();
addFiles(fileIterator, files);
@ -59,6 +54,7 @@ public class JsonAdapter implements Adapter {
File currentFile = fileIterator.next();
JsonObject file = new JsonObject();
file.addProperty("name", currentFile.getName());
file.addProperty("fileNameSalt", currentFile.getFileNameSalt());
file.addProperty("size", currentFile.getSize());
file.addProperty("iv", currentFile.getIv());
JsonArray storage = new JsonArray();
@ -77,7 +73,6 @@ public class JsonAdapter implements Adapter {
}
/**
*
* @param appDataString The Json String to convert
* @return An AppData instance
*/
@ -92,6 +87,7 @@ public class JsonAdapter implements Adapter {
appConfig.setMulticastPort(jsonAppData.get("multicast_port").getAsInt());
appConfig.setNetworkInterface(jsonAppData.get("network_interface").getAsString());
appConfig.setTls(jsonAppData.get("tls").getAsBoolean());
appConfig.setStoragePath(jsonAppData.get("storagePath").getAsString());
JsonArray jsonUsers = jsonAppData.getAsJsonArray("users");
List<User> users = new ArrayList<>();
getUsers(jsonUsers, users);
@ -100,8 +96,7 @@ public class JsonAdapter implements Adapter {
for (User user : users) {
appData.addUser(user);
}
this.appData = appData;
return this.appData;
return appData;
} catch (JsonParseException parseException) {
System.out.println("[FFE] : Error while loading configuration file"); //TODO - changer en log
return null;
@ -114,10 +109,11 @@ public class JsonAdapter implements Adapter {
String name = jsonUser.get("name").getAsString();
String password = jsonUser.get("password").getAsString();
String aeskey = jsonUser.get("aes_key").getAsString();
String passwordSalt = jsonUser.get("passwordSalt").getAsString();
Map<String, File> userFiles = new HashMap<>();
JsonArray jsonFiles = jsonUser.getAsJsonArray("files");
getFiles(userFiles, jsonFiles);
User user = new User(name, password, aeskey, userFiles);
User user = new User(name, password, aeskey, passwordSalt, userFiles);
users.add(user);
}
}
@ -126,12 +122,13 @@ public class JsonAdapter implements Adapter {
for (JsonElement fileElement : jsonFiles) {
JsonObject jsonFile = fileElement.getAsJsonObject();
String fileName = jsonFile.get("name").getAsString();
String fileNameSalt = jsonFile.get("fileNameSalt").getAsString();
int size = jsonFile.get("size").getAsInt();
String iv = jsonFile.get("iv").getAsString();
Set<String> storage = new HashSet<>();
JsonArray jsonStorage = jsonFile.getAsJsonArray("storage");
getStorage(storage, jsonStorage);
File file = new File(fileName, size, iv, storage);
File file = new File(fileName, fileNameSalt, size, iv, storage);
userFiles.put(file.getName(), file);
}
}

113
app/src/main/java/lightcontainer/storage/Repository.java
View File

@ -7,16 +7,30 @@ import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.List;
public class Repository {
private final String filePath;
private final Adapter adapter;
private final AppData appData;
/**
* @param filePath The path where the file must be saved
* @param adapter The service that converts Objects to Strings
* @param filePath The path to the configuration file
* @param adapter The adapter that converts objects to string and vice-versa
*/
static void save(String filePath, Adapter adapter) {
public Repository(String filePath, AppData appData, Adapter adapter) {
this.filePath = filePath;
this.appData = appData;
this.adapter = adapter;
}
/**
* Saves configuration file
*/
public void save() {
if (filePath != null) {
String jsonAppData = adapter.toString();
String jsonAppData = adapter.toString(appData);
try (BufferedWriter bufferedWriter = Files.newBufferedWriter(Paths.get(filePath).toAbsolutePath(), StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
bufferedWriter.write(jsonAppData);
bufferedWriter.flush();
@ -26,17 +40,54 @@ public class Repository {
}
}
public boolean addUser(String login, String password, String key, String passwordSalt) {
if (appData.addUser(login, password, key, passwordSalt)) {
save();
return true;
}
return false;
}
public boolean addFileFor(File file, String userName) {
if (appData.addFileFor(file, userName)) {
save();
return true;
}
return false;
}
public boolean canAddFile(String login) {
return appData.canAddFile(login);
}
public boolean deleteFileOf(String fileName, String userName) {
if (appData.deleteFileOf(fileName, userName)) {
save();
return true;
}
return false;
}
public boolean addStorage(String userName, File file, String storage) {
if (appData.addStorage(userName, file, storage)) {
save();
return true;
}
return false;
}
/**
* @param filePath The path where the file is stored
* @param adapter The service that converts Strings to objects
* @return
* Loads configuration file
*
* @return AppData
*/
static AppData load(String filePath, Adapter adapter) {
public AppData load() {
String jsonString = readFile(filePath);
return adapter.fromString(jsonString);
}
private static String readFile(String filePath) {
private String readFile(String filePath) {
StringBuilder builder = new StringBuilder();
try (BufferedReader reader = Files.newBufferedReader(Paths.get(filePath).toAbsolutePath(), StandardCharsets.UTF_8)) {
while (reader.ready()) {
@ -48,4 +99,48 @@ public class Repository {
}
return builder.toString();
}
public int getUnicastPort() {
return appData.getAppConfig().getUnicastPort();
}
public String getMulticastIp() {
return appData.getAppConfig().getMulticastIp();
}
public int getMulticastPort() {
return appData.getAppConfig().getMulticastPort();
}
public boolean verifyUser(String login, String password) {
return appData.verifyUser(login, password);
}
public String getUserPasswordSalt(String login) {
return appData.getUserPasswordSalt(login);
}
/**
* Méthode permettant de récupérer le chemin de sauvegarde des fichiers
*
* @return Chemin de sauvegarde
*/
public String getStoragePath() {
return appData.getAppConfig().getStoragePath();
}
/**
* Méthode permettant de récupérer la clé AES d'un utilisateur
*
* @param login Login de l'utilisateur
* @return Clé AES
*/
public String getUserAesKey(String login) {
return appData.getUserAesKey(login);
}
public List<String> getStringifiedFilesOf(String login) {
return this.appData.getStringifiedFilesOf(login);
}
}

45
app/src/main/java/lightcontainer/storage/User.java
View File

@ -1,6 +1,8 @@
package lightcontainer.storage;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
@ -12,20 +14,23 @@ import java.util.Map;
*/
public class User {
private final String Name;
private final String name;
private final String password;
private final String aesKey;
private final String passwordSalt;
private final Map<String, File> files;
public User(String Name, String password, String aesKey, Map<String, File> files) {
this.Name = Name;
public User(String name, String password, String aesKey, String passwordSalt, Map<String, File> files) {
this.name = name;
this.password = password;
this.aesKey = aesKey;
this.passwordSalt = passwordSalt;
this.files = files;
System.out.println(files.size() + " fichiers trouvéssss pour " + name);
}
public String getName() {
return Name;
return name;
}
public String getPassword() {
@ -36,10 +41,25 @@ public class User {
return aesKey;
}
public String getPasswordSalt() {
return this.passwordSalt;
}
public Iterator<File> fileIterator() {
return files.values().iterator();
}
public List<String> getFilesWithSize() {
Iterator<File> fileIterator = fileIterator();
List<String> result = new ArrayList<>();
while (fileIterator.hasNext()) {
File file = fileIterator.next();
String stringify = file.getName() + "!" + file.getSize();
result.add(stringify);
}
return result;
}
public File getFile(String fileName) {
return this.files.get(fileName);
}
@ -48,8 +68,16 @@ public class User {
* @param file The file to add.
* @return False if a file with the same name already exists. Otherwise, adds the file and returns true.
*/
public void addFile(File file) {
this.files.put(file.getName(), file);
public boolean addFile(File file) {
if (canAddFile()) {
this.files.put(file.getName(), file);
return true;
}
return false;
}
public boolean canAddFile() {
return this.files.size() <= 50;
}
/**
@ -77,4 +105,9 @@ public class User {
return false;
}
}
public boolean verifyPassword(String password) {
return this.password.equals(password);
}
}

334
app/src/main/java/lightcontainer/utils/AES_GCM.java
View File

@ -1,51 +1,108 @@
package lightcontainer.utils;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.*;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.util.Base64;
/**
* AES GCM 256 Encryption Class [DO NOT EDIT]
*
* @since 1.0
* @version 1.0
*
* @author Jérémi Nihart <contact@endmove.eu>
*/
public class AES_GCM {
// Constants
public static final int AES_KEY_SIZE = 256;
public static final int GCM_IV_LENGTH = 16;
public static final int GCM_TAG_LENGTH = 16;
// Main method for testing
public static void main(String[] args) throws Exception
{
// Text pour test :
String plainText = "salut fils de pute";
/*
* FILE ENCRYPTION DEMO
*/
// Init files
File inFile = new File("D:\\HELMo.png");
File outFile = new File("D:\\HELMoCrypted.png");
File clearFile = new File("D:\\HELMoClear.png");
outFile.createNewFile();
clearFile.createNewFile();
// Make options
String IVFile = generateIV();
String keyFile = generateSecretKey();
// Show options
System.out.println("IV : "+IVFile);
System.out.println("Key : "+keyFile);
// Encrypt
encryptStream(
new FileInputStream(inFile),
new FileOutputStream(outFile),
inFile.length(),
IVFile,
keyFile
);
// Decrypt
decryptStream(
new FileInputStream(outFile),
new FileOutputStream(clearFile),
outFile.length(),
IVFile,
keyFile
);
/*
* TEXT ENCRYPTION DEMO
*/
// Make option
String plainText = "Salut sombre fils de pute, comment vas tu ?";//TODO enlever le text chelou de Jérémi (ce fou là)
String IV = generateIV();
String key = generateSecretKey();
System.out.println("Original Text : " + plainText);
byte[] cipherText = encrypt(plainText.getBytes(), key, IV);
System.out.println("Encrypted Text : " + Base64.getEncoder().encodeToString(cipherText));
String decryptedText = decrypt(cipherText, key, IV);
System.out.println("DeCrypted Text : " + decryptedText);
// Show options
System.out.println("IV : "+IV);
System.out.println("Key : "+key);
System.out.println("Original text : " + plainText);
// Crypt
String cryptText = encrypt(plainText, key, IV);
System.out.println("Encrypted text : " + cryptText);
// Decrypt
String decryptedText = decrypt(cryptText, key, IV);
System.out.println("Decrypted text : " + decryptedText);
}
/**
* Decoder to decode base64 vector to byte vector.
* @param base64Vector A base64 encoded vector.
* @return Byte vector.
*
* @param base64Vector A base64 encoded vector.
* @return Byte vector.
*/
private static byte[] decodeBase64(String base64Vector) {
private static byte[] decodeBase64Vector(String base64Vector) {
Base64.Decoder b64Decoder = Base64.getDecoder();
return b64Decoder.decode(base64Vector);
}
/**
* Decoder to decode base64 string to plain string.
*
* @param base64String A base64 encoded string.
* @return Plain string.
*
* @see AES_GCM#decodeBase64Vector(String)
*/
private static String decodeBase64String(String base64String) {
return new String(decodeBase64Vector(base64String));
}
/**
* Encoder to encode vector to base64 string.
* @param rawVector A raw vector.
* @return A base64 encoded vector.
* @param rawVector A raw vector.
* @return A base64 encoded vector.
*/
private static String encodeBase64(byte[] rawVector) {
Base64.Encoder b64Encoder = Base64.getEncoder();
@ -53,19 +110,66 @@ public class AES_GCM {
}
/**
* Generate a secret key base64 encoded.
* @return New Secret key b64 encoded.
* Encoder to encode string to base64 string.
* @param rawString A raw string.
* @return A base64 encoded string.
*
* @see AES_GCM#encodeBase64(byte[]))
*/
public static String generateSecretKey() throws NoSuchAlgorithmException {
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(AES_KEY_SIZE);
SecretKey key = keyGenerator.generateKey();
return encodeBase64(key.getEncoded());
private static String encodeBase64(String rawString) {
return encodeBase64(rawString.getBytes(StandardCharsets.UTF_8));
}
/**
* FACTORY, to setting up a Java cryptographic cypher.
*
* @param op_mode the operation mode of this cipher (this is one of the
* following: ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE or UNWRAP_MODE)
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
*
* @return A Cryptography cypher.
*
* @throws AesGcmException Throw an exception in case of an error occur while setting up the the cypher.
*/
private static Cipher createCipher(int op_mode, String key, String IV) throws AesGcmException {
try {
// Get a cipher instance
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
// Create a secret key from the key for the specific crypto algo
SecretKeySpec keySpec = new SecretKeySpec(decodeBase64Vector(key), "AES");
// Create a GCMParameterSpec to setting up the AES init vector
GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, decodeBase64Vector(IV));
// Init the cipher for the selected operation
cipher.init(op_mode, keySpec, gcmParameterSpec);
return cipher;
} catch (InvalidAlgorithmParameterException | NoSuchPaddingException | NoSuchAlgorithmException | InvalidKeyException e) {
throw new AesGcmException(e, "Error while creating the Cipher object");
}
}
/**
* Generate a secret key base64 encoded.
*
* @return New Secret key b64 encoded.
*
* @throws AesGcmException Exception if an error occur.
*/
public static String generateSecretKey() throws AesGcmException {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(AES_KEY_SIZE);
SecretKey key = keyGenerator.generateKey();
return encodeBase64(key.getEncoded());
} catch (NoSuchAlgorithmException e) {
throw new AesGcmException("Error while generating the AES secret key");
}
}
/**
* Generate an IV (initialisation vector) base64 encoded.
* @return New generated IV b64 encoded.
*
* @return New generated IV b64 encoded.
*/
public static String generateIV() {
byte[] IV = new byte[GCM_IV_LENGTH];
@ -75,52 +179,154 @@ public class AES_GCM {
}
/**
* Encrypt, with AES GCM.
* @param plainContent Content to encrypt.
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
* @return The encrypted cipherContent.
* Encrypt text, with AES GCM.
*
* @param plainText Plain text to encrypt.
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
*
* @return The encrypted plain text Base64 encoded.
*
* @throws AesGcmException Exception if an error occur.
*/
public static byte[] encrypt(byte[] plainContent, String key, String IV) throws Exception
{
// Get Cipher Instance
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
public static String encrypt(String plainText, String key, String IV) throws AesGcmException {
try {
// Make the cipher for encryption
Cipher cipher = createCipher(Cipher.ENCRYPT_MODE, key, IV);
// Perform Encryption
return encodeBase64(cipher.doFinal(plainText.getBytes()));
} catch (Exception e) {
throw new AesGcmException(e);
}
}
// Create SecretKeySpec
SecretKeySpec keySpec = new SecretKeySpec(decodeBase64(key), "AES");
// Create GCMParameterSpec
GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, decodeBase64(IV));
// Initialize Cipher for ENCRYPT_MODE
cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmParameterSpec);
// Perform Encryption
return cipher.doFinal(plainContent);
/**
* Encrypt stream, with AES GCM.
*
* @param in InputStream to the input, flux to encrypt.
* @param out OutputStream to the output, encrypted flux.
* @param fileSize Stream/file size.
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
*
* @throws AesGcmException Exception if an error occur.
*/
public static void encryptStream(InputStream in, OutputStream out, long fileSize, String key, String IV) throws AesGcmException {
byte[] buffer = new byte[1024];
int currentSize = 0;
int bytes;
try {
// Make the cipher for encryption
Cipher cipher = createCipher(Cipher.ENCRYPT_MODE, key, IV);
// Initialize a CipherOutputStream
CipherOutputStream cipherOut = new CipherOutputStream(out, cipher);
// Encryption Process
while((currentSize < fileSize) && (bytes = in.read(buffer)) > 0) {
cipherOut.write(buffer, 0, bytes);
cipherOut.flush();
currentSize += bytes;
}
// Close CipherOutputStream
cipherOut.close();
} catch (Exception e) {
throw new AesGcmException(e);
}
}
/**
* Decrypt, with AES GCM.
* @param cipherContent The encrypted cipherContent
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
* @return The decrypted plainContent.
*
* @param cryptText The encrypted text.
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
*
* @return The decrypted plain text.
*
* @throws AesGcmException Exception if an error occur.
*/
public static String decrypt(byte[] cipherContent, String key, String IV) throws Exception
{
// Get Cipher Instance
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
public static String decrypt(String cryptText, String key, String IV) throws AesGcmException {
try {
// Make the cipher for decryption
Cipher cipher = createCipher(Cipher.DECRYPT_MODE, key, IV);
// Perform Decryption
return new String(cipher.doFinal(decodeBase64Vector(cryptText)));
} catch (Exception e) {
throw new AesGcmException(e);
}
}
// Create SecretKeySpec
SecretKeySpec keySpec = new SecretKeySpec(decodeBase64(key), "AES");
/**
* Decrypt stream, with AES GCM.
*
* @param in InputStream to the input, flux to decrypt.
* @param out OutputStream to the output, decrypted flux.
* @param fileSize Stream/file size.
* @param key Base64 encoded secret key.
* @param IV Base64 encoded vector.
*
* @throws AesGcmException Exception if an error occur.
*/
public static void decryptStream(InputStream in, OutputStream out, long fileSize, String key, String IV) throws AesGcmException {
byte[] buffer = new byte[1024];
int currentSize = 0;
int bytes;
try {
// Make the cipher for decryption
Cipher cipher = createCipher(Cipher.DECRYPT_MODE, key, IV);
// Initialize a CipherOutputStream
CipherInputStream cipherIn = new CipherInputStream(in, cipher);
// Encryption Process
while((currentSize < fileSize) && (bytes = cipherIn.read(buffer)) > 0) {
out.write(buffer, 0, bytes);
out.flush();
currentSize += bytes;
}
// Close CipherOutputStream
cipherIn.close();
} catch (Exception e) {
throw new AesGcmException(e);
}
}
// Create GCMParameterSpec
GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH*8, decodeBase64(IV));
/**
* Internal Error from AES_GCM encryption Class
*/
public static class AesGcmException extends Exception {
// Constant
private static final long serialVersionUID = -145972354893514657L;
// Initialize Cipher for DECRYPT_MODE
cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmParameterSpec);
/**
* Constructor of AesGcmException,
* which define it's own detail message.
*
* @param msg The detail message.
*/
public AesGcmException(String msg) {
super(msg);
}
// Perform Decryption
return new String(cipher.doFinal(cipherContent));
/**
* Constructor of AesGcmException,
* which propagates the error triggering
* a crash of the encryption system.
*
* @param e Previous exception throwable.
*/
public AesGcmException(Throwable e) {
super(e);
}
/**
* Constructor of AesGcmException,
* which propagates the error triggering
* a crash of the encryption system with
* a chosen detail message.
*
* @param e Previous exception throwable.
* @param msg The detail message.
*/
public AesGcmException(GeneralSecurityException e, String msg) {
super(msg, e);
}
}
}

23
app/src/main/java/lightcontainer/utils/FileReceiver.java
View File

@ -1,36 +1,29 @@
package lightcontainer.utils;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.*;
public class FileReceiver {
private static final int DEFAULT_BUFFER = 8000;
private String path;
public FileReceiver(String path) { this.path = path; }
public boolean receiveFile(InputStream input, String fileName, long fileSize) {
int bytesReceived = 0;
public int receiveFile(InputStream input, String fileName, int fileSize, String key, String iv) {
BufferedOutputStream bosFile = null;
try {
byte[] buffer = new byte[DEFAULT_BUFFER];
bosFile = new BufferedOutputStream(new FileOutputStream(String.format("%s/%s", path, fileName)));
long currentOffset = 0;
while((currentOffset < fileSize) && ((bytesReceived = input.read(buffer)) > 0)) {
bosFile.write(buffer, 0, bytesReceived);
currentOffset += bytesReceived;
}
AES_GCM.encryptStream(input, bosFile, fileSize, key, iv);
bosFile.flush();
bosFile.close();
return true;
} catch(Exception ex) {
File f = new File(String.format("%s/%s", path, fileName));
return (int)f.length();
} catch(IOException | AES_GCM.AesGcmException ex) {
ex.printStackTrace();
if(bosFile != null) { try { bosFile.close(); } catch(Exception e) {} }
return false;
return -1;
}
}

25
app/src/main/java/lightcontainer/utils/FileSender.java
View File

@ -4,12 +4,32 @@ import java.io.*;
public class FileSender {
private static final int DEFAULT_BUFFER=8000;
private String path;
private final String path;
public FileSender(String path) { this.path = path; }
public boolean sendFile(String filename, OutputStream out, int fileSize, String aesKey, String iv) {
BufferedInputStream bisFile;
System.out.printf("Envoie fichier : %s - %s - %s \n", filename, aesKey, iv);
try {
File f = new File(String.format("%s/%s", path, filename));
if(f.exists()) {
bisFile = new BufferedInputStream(new FileInputStream(f));
AES_GCM.decryptStream(bisFile, out, fileSize, aesKey, iv);
bisFile.close();
return true;
} else
return false;
} catch(IOException | AES_GCM.AesGcmException ex) {
ex.printStackTrace();
return false;
}
}
public boolean sendFile(String filename, OutputStream out) {
BufferedInputStream bisFile = null;
BufferedInputStream bisFile;
int bytesReaded = 0;
try {
@ -32,4 +52,5 @@ public class FileSender {
return false;
}
}
}

115
app/src/main/java/lightcontainer/utils/SHA.java Normal file
View File

@ -0,0 +1,115 @@
package lightcontainer.utils;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.util.Base64;
/**
* SHA 256 Hashing and borrowing Class [DO NOT EDIT]
*
* @since 1.0
* @version 1.0
*
* @author Jérémi Nihart <contact@endmove.eu>
*/
public class SHA {
// Constants
public static final String SHA_VERSION = "SHA-256";
// Main method for testing
public static void main(String[] args) throws Exception {
/*
* BORROWING ENCRYPTION DEMO
*/
File inFile = new File("D:\\HELMo.txt");
System.out.println(hashStream(
new FileInputStream(inFile),
(int)inFile.length()
));
System.out.println(hashFile( // caca5439dc02f2ced5094e95f1a3403d42127cda29feecd2eb1c68ff38a6fee3
"D:\\ffe",
"46ba86ddecd2fe80c3bdb9fb2f9480b4c92057447e9d1b43863dd1a6d540f3a316571684f9e3a7459f533a9792d4925e"
));
}
/**
* Make a borrowing of the stream.
*
* @param in InputStream to the input, flux to hash.
* @param fileSize Stream/file size.
*
* @return Borrowing of the full current flux.
*
* @throws ShaException if an error occur.
*/
public static String hashStream(InputStream in, int fileSize) throws ShaException {
StringBuilder sb = new StringBuilder();
byte[] buffer = new byte[1024];
int currentSize = 0;
int bytes;
try {
// Init Digest algo
MessageDigest digest = MessageDigest.getInstance(SHA_VERSION);
// Process flux
while ((currentSize < fileSize) && (bytes=in.read(buffer)) > 0) {
digest.update(buffer, 0, bytes);
currentSize += bytes;
}
// Make hash result
byte[] hashBytes = digest.digest();
// Convert result and make the final hash formatting
for (byte hashByte : hashBytes) {
sb.append(String.format("%02x", hashByte));
}
} catch (Exception e) {
throw new ShaException(e);
}
return sb.toString();
}
/**
* Make a borrowing of the file.
*
* @param rootPath Root path of the file.
* @param fileName File Name.
*
* @return Borrowing of the file.
*
* @throws ShaException if an error occur.
*/
public static String hashFile(String rootPath, String fileName) throws ShaException {
try {
File file = new File(String.format("%s/%s", rootPath, fileName));
return hashStream(new FileInputStream(file), (int)file.length());
} catch (Exception e) {
throw new ShaException(e);
}
}
/**
* Internal Error from SHA encryption Class
*/
public static class ShaException extends Exception {
// Constant
private static final long serialVersionUID = -145979547823516845L;
/**
* Constructor of ShaException,
* which propagates the error triggering
* a crash of the hash system.
*
* @param e Previous exception throwable.
*/
public ShaException(Throwable e) {
super(e);
}
}
}

75
app/src/main/java/lightcontainer/utils/ShaHasher.java Normal file
View File

@ -0,0 +1,75 @@
package lightcontainer.utils;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
/**
* Permet de hasher du texte
*/
public class ShaHasher {
/**
* Mot de passe non-hashé
*/
private final String text;
/**
* Sallage appliqué sur le mot de passe précédement généré
*/
private byte[] salt;
public ShaHasher(String text) {
this.text = text;
}
/**
* Permet de demander un nouvel hashage sur le mot de passe
*
* @return Mot de passe hashé
* <p>
* Source : https://www.javaguides.net/2020/02/java-sha-384-hash-with-salt-example.html
*/
public String nextHashing() {
this.salt = generateSalt();
return fromSalt(this.salt);
}
public String fromSalt(byte[] textSalt) {
String generatedText = null;
try {
MessageDigest md = MessageDigest.getInstance("SHA-384");
md.update(textSalt);
byte[] bytes = md.digest(text.getBytes(StandardCharsets.UTF_8));
StringBuilder sb = new StringBuilder();
for (byte aByte : bytes) {
sb.append(Integer.toString((aByte & 0xff) + 0x100, 16).substring(1));
}
generatedText = sb.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return generatedText;
}
private byte[] generateSalt() {
this.salt = new byte[16];
SecureRandom random = new SecureRandom();
random.nextBytes(salt);
return salt;
}
public String getSalt() {
Base64.Encoder b64Encoder = Base64.getEncoder();
return b64Encoder.encodeToString(this.salt);
}
public byte[] saltToByte(String salt) {
Base64.Decoder b64Decoder = Base64.getDecoder();
return b64Decoder.decode(salt);
}
}

1
app/src/main/resources/appdata.json Normal file
View File

@ -0,0 +1 @@
{"unicast_port":8000,"multicast_ip":"226.66.66.1","multicast_port":15502,"network_interface":"My network interface","tls":true,"storagePath":"/home/benjamin/ffe","users":[{"name":"endmove","password":"1f82407cace28cd7d97d23f82e8235d9da97575d033a12334fc71d3517f6a90fa04af829df3c722c38d3b68842e4ca2b","aes_key":"p0G+iViPp656O6aMKgcXSDT/e9/00wQH/ztUWf4tyr4=","passwordSalt":"ItYiXkwPa84Gwb6dGHQvXQ==","files":[]},{"name":"aaaaa","password":"5d628c274ebb008324f1e199d3bfff0a3fe839730a7f2355e82850d7acca5e5ca64db9071abf3d91034295695f84a617","aes_key":"qlTH6TijnfMRnrS0Qf+k6IPKGp5LoRMXGxCq16e+mF4=","passwordSalt":"Ns8Al6DpqPsIDlCSRBVTEg==","files":[{"name":"ca.crt","fileNameSalt":"Mjo7iQeEl2PYX1RDUZbSlQ==","size":4207,"iv":"uALI+Feo1lIg1lBxbCMwIQ==","storage":["lightcontainerSB01"]},{"name":"main.py","fileNameSalt":"YRwnBiXINCJ+zyxwADgNRQ==","size":854,"iv":"9LXrJFtcgU4DeUBghc4Dgw==","storage":["lightcontainerSB01"]}]}]}

4
app/src/main/resources/rules.txt
View File

@ -29,8 +29,8 @@ ffe_retrievefile = ^RETRIEVEFILE ([A-Za-z0-9.]{50,200})\r\n$
sbe_retrieveresult = ^(RETRIEVE_OK ([A-Za-z0-9.]{50,200} [0-9]{1,10} [A-Za-z0-9.]{50,200})\r\n)|(RETRIEVE_ERROR\r\n)$
//Client to FileFrontEnd
client_signin = ^SIGNIN ([A-Za-z0-9]{2,20}) ([^ !]{5,50})\r\n$
client_signup = ^SIGNUP ([A-Za-z0-9]{2,20}) ([^ !]{5,50})\r\n$
client_signin = ^SIGNIN ([A-Za-z0-9]{5,20}) ([^ !]{5,50})\r\n$
client_signup = ^SIGNUP ([A-Za-z0-9]{5,20}) ([^ !]{5,50})\r\n$
ffe_signresult = ^(SIGN_OK|SIGN_ERROR)\r\n$
client_filelist = ^FILELIST\r\n$
ffe_filelistresult = ^FILES( ([^ !]{1,20})!([0-9]{1,10})){0,50}$

6
app/src/test/java/lightcontainer/protocol/rules/reader/HelloRuleTest.java
View File

@ -14,11 +14,11 @@ class HelloRuleTest {
String request = "HELLO bento 42890\r\n";
// WHEN
HelloRule.Result ruleResult = protocolReader.execute(request);
// HelloRule.Result ruleResult = protocolReader.execute(request);
// THEN
assertEquals("bento", ruleResult.getDomain());
assertEquals(42890, ruleResult.getPort());
// assertEquals("bento", ruleResult.getDomain());
// assertEquals(42890, ruleResult.getPort());
}
}

8
app/src/test/java/lightcontainer/protocol/rules/writer/SignoutRuleTest.java
View File

@ -1,6 +1,7 @@
package lightcontainer.protocol.rules.writer;
import lightcontainer.protocol.ProtocolWriter;
import lightcontainer.protocol.rules.reader.SignoutRule;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
@ -9,13 +10,6 @@ class SignoutRuleTest {
@Test
public void whenRuleIsRightThenReturnCommand() {
//GIVEN
ProtocolWriter protocolWriter = new SignoutRule();
String[] datas = {};
//EXPECT
assertNotNull(protocolWriter.execute(datas));
assertEquals("SIGNOUT\r\n", protocolWriter.execute(datas));
}
}

18
app/src/test/java/lightcontainer/storage/JsonAdapterTests.java
View File

@ -2,16 +2,14 @@ package lightcontainer.storage;
import org.junit.jupiter.api.Test;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
public class JsonAdapterTests {
/*
@Test
public void convertAppDataToJson() {
//GIVEN an AppData instance and a Json Adapter
@ -22,17 +20,15 @@ public class JsonAdapterTests {
appConfig.setMulticastPort(15502);
appConfig.setNetworkInterface("My network interface");
appConfig.setTls(false);
Map<String, File> files = new HashMap<>();
Set<String> storage = new HashSet<>();
storage.add("StorBackEnd1");
File file1 = new File("File1", 15, "8d8d8d8d", storage);
files.put(file1.getName(), file1);
User user1 = new User("User1", "Password", "djdjjdj", files);
appData.setAppConfig(appConfig);
appData.addUser(user1);
JsonAdapter jsonAdapter = new JsonAdapter(appData);
appData.addUser("User1", "Password","djdjjdj", "");
appData.addFileFor(file1, "User1");
JsonAdapter jsonAdapter = new JsonAdapter();
//WHEN the adapter converts AppData to Json
String jsonAppData = jsonAdapter.toString();
String jsonAppData = jsonAdapter.toString(appData);
//THEN
assertTrue(jsonAppData.contains("32000"));
assertTrue(jsonAppData.contains("224.25.0.1"));
@ -53,7 +49,7 @@ public class JsonAdapterTests {
//GIVEN a Json string
String json = "{\"unicast_port\":32000,\"multicast_ip\":\"224.25.0.1\",\"multicast_port\":15502,\"network_interface\":\"My network interface\",\"tls\":false,\"users\":[{\"name\":\"User1\",\"password\":\"Password\",\"aes_key\":\"djdjjdj\",\"files\":[{\"name\":\"File1\",\"size\":15,\"iv\":\"8d8d8d8d\",\"storage\":[\"StorBackEnd1\"]}]}]}";
//WHEN the adapter converts Json to Appdata
JsonAdapter jsonAdapter = new JsonAdapter(null);
JsonAdapter jsonAdapter = new JsonAdapter();
AppData appData = jsonAdapter.fromString(json);
//THEN
assertNotNull(appData.getAppConfig());
@ -63,4 +59,6 @@ public class JsonAdapterTests {
assertEquals(15502, appData.getAppConfig().getMulticastPort());
assertFalse(appData.getAppConfig().isTls());
}
*/
}

24
app/src/test/java/lightcontainer/storage/RepositoryTests.java
View File

@ -1,17 +1,12 @@
package lightcontainer.storage;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.InvalidPathException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
@ -19,6 +14,7 @@ import static org.junit.jupiter.api.Assertions.*;
public class RepositoryTests {
/*
@AfterEach
public void destroyTestFile() {
try {
@ -38,18 +34,17 @@ public class RepositoryTests {
appConfig.setMulticastPort(15502);
appConfig.setNetworkInterface("My network interface");
appConfig.setTls(false);
Map<String, File> files = new HashMap<>();
Set<String> storage = new HashSet<>();
storage.add("StorBackEnd1");
File file1 = new File("File1", 15, "8d8d8d8d", storage);
files.put(file1.getName(), file1);
User user1 = new User("User1", "Password", "djdjjdj", files);
appData.setAppConfig(appConfig);
appData.addUser(user1);
JsonAdapter jsonAdapter = new JsonAdapter(appData);
appData.addUser("User1", "Password", "djdjjdj", "");
JsonAdapter jsonAdapter = new JsonAdapter();
appData.addFileFor(file1, "User1");
//WHEN Repository calls save method
String filePath = "src/test/resources/test.json";
Repository.save(filePath, jsonAdapter);
Repository repository = new Repository(filePath, appData, jsonAdapter);
repository.save();
//THEN
assertTrue(Files.exists(Paths.get("src/test/resources/test.json").toAbsolutePath()));
}
@ -57,9 +52,10 @@ public class RepositoryTests {
@Test
public void load() {
//GIVEN a test json file loadTest.json
JsonAdapter jsonAdapter = new JsonAdapter(null);
JsonAdapter jsonAdapter = new JsonAdapter();
//WHEN repository calls load method
AppData appData = Repository.load("src/test/resources/loadTest.json", jsonAdapter);
Repository repository = new Repository("src/test/resources/loadTest.json", AppData.getInstance(), jsonAdapter);
AppData appData = repository.load();
//THEN
assertNotNull(appData.getAppConfig());
assertEquals("My network interface", appData.getAppConfig().getNetworkInterface());
@ -68,4 +64,6 @@ public class RepositoryTests {
assertEquals(15502, appData.getAppConfig().getMulticastPort());
assertFalse(appData.getAppConfig().isTls());
}
*/
}

BIN
ffe.labo.swilabus.com.p12 Normal file
View File

Binary file not shown.