562 lines
16 KiB
Java
562 lines
16 KiB
Java
package database;
|
||
|
||
import java.io.File;
|
||
import java.security.InvalidAlgorithmParameterException;
|
||
import java.security.InvalidKeyException;
|
||
import java.security.NoSuchAlgorithmException;
|
||
|
||
import java.sql.Connection;
|
||
import java.sql.DriverManager;
|
||
import java.sql.PreparedStatement;
|
||
import java.sql.ResultSet;
|
||
import java.sql.SQLException;
|
||
import java.util.ArrayList;
|
||
|
||
import javax.crypto.BadPaddingException;
|
||
import javax.crypto.IllegalBlockSizeException;
|
||
import javax.crypto.KeyGenerator;
|
||
import javax.crypto.NoSuchPaddingException;
|
||
import javax.crypto.SecretKey;
|
||
import javax.crypto.spec.IvParameterSpec;
|
||
|
||
|
||
import main.Utilisateur;
|
||
import messages.MauvaisTypeMessageException;
|
||
import messages.Message;
|
||
import messages.MessageTexte;
|
||
import messages.Message.TypeMessage;
|
||
import messages.MessageFichier;
|
||
|
||
public class SQLiteManager {
|
||
|
||
private static final String DATABASE_RELATIVE_PATH = "../database";
|
||
|
||
public static String[] hardcodedNames = {"Olivia","Liam","Benjamin","Sophia","Charlotte","Noah","Elijah","Isabella",
|
||
"Oliver","Emma","William","Amelia","Evelyn","James","Mia","Ava","Lucas","Mason","Ethan","Harper"};
|
||
|
||
private Connection connec;
|
||
private int numDatabase;
|
||
private SecretKey dbDataKey;
|
||
|
||
public SQLiteManager(int numDatabase) {
|
||
this.numDatabase = numDatabase;
|
||
|
||
this.openConnection();
|
||
|
||
try {
|
||
|
||
SQLiteCreateTables.createTableUser(this.connec);
|
||
SQLiteCreateTables.createTableConversation(this.connec);
|
||
SQLiteCreateTables.createTableType(this.connec);
|
||
SQLiteCreateTables.createTableMessage(this.connec);
|
||
|
||
} catch (SQLException e) {
|
||
this.closeConnection();
|
||
File db = new File("../database"+this.numDatabase+".db");
|
||
if(db.delete()) {
|
||
System.out.println("supp");
|
||
}else {
|
||
System.out.println("no supp");
|
||
}
|
||
e.printStackTrace();
|
||
}
|
||
|
||
this.closeConnection();
|
||
}
|
||
|
||
private void openConnection() {
|
||
String url = "jdbc:sqlite:"+ DATABASE_RELATIVE_PATH + this.numDatabase + ".db";
|
||
try {
|
||
this.connec = DriverManager.getConnection(url);
|
||
// System.out.println("Connection to bdd established");
|
||
} catch (SQLException e) {
|
||
System.out.println(e.getMessage());
|
||
}
|
||
}
|
||
|
||
private void closeConnection() {
|
||
try {
|
||
if (this.connec != null) {
|
||
this.connec.close();
|
||
}
|
||
} catch (SQLException e) {
|
||
System.out.println(e.getMessage());
|
||
}
|
||
|
||
}
|
||
|
||
public int insertAllMessages(ArrayList<Message> messages, String usernameSender, String usernameReceiver) throws SQLException{
|
||
int nbRows = 0;
|
||
this.openConnection();
|
||
|
||
int idSender = this.getIDUser(usernameSender);
|
||
int idReceiver = this.getIDUser(usernameReceiver);
|
||
|
||
if(idSender == -1) {
|
||
this.insertUser(usernameSender);
|
||
idSender = this.getIDUser(usernameSender);
|
||
}
|
||
|
||
if(idReceiver == -1) {
|
||
this.insertUser(usernameReceiver);
|
||
idReceiver = this.getIDUser(usernameReceiver);
|
||
}
|
||
|
||
int idConversation = getIDConversation(idSender, idReceiver);
|
||
|
||
if(idConversation == -1) {
|
||
this.insertConversation(idSender, idReceiver);
|
||
idConversation = getIDConversation(idSender, idReceiver);
|
||
}
|
||
|
||
IvParameterSpec ivConversation = this.getIvConversation(idConversation);
|
||
|
||
this.connec.setAutoCommit(false);
|
||
|
||
for(Message m : messages) {
|
||
try {
|
||
nbRows += this.insertMessage(idConversation, m, ivConversation);
|
||
} catch (SQLException e) {
|
||
e.printStackTrace();
|
||
this.connec.rollback();
|
||
}
|
||
}
|
||
|
||
this.connec.commit();
|
||
|
||
this.closeConnection();
|
||
|
||
//System.out.println("Nombre de message(s) ins<6E>r<EFBFBD>e(s) : " + nbRows);
|
||
|
||
return nbRows;
|
||
}
|
||
|
||
|
||
public ArrayList<Message> getHistoriquesMessages(String usernameOther, String pseudoOther) throws SQLException {
|
||
|
||
this.openConnection();
|
||
|
||
|
||
ArrayList<Message> messages = new ArrayList<Message>();
|
||
|
||
String usernameSelf = Utilisateur.getSelf().getId();
|
||
|
||
int idSelf = this.getIDUser(usernameSelf);
|
||
int idOther = this.getIDUser(usernameOther);
|
||
|
||
int idConversationSelf = this.getIDConversation(idSelf, idOther);
|
||
int idConversationOther = this.getIDConversation(idOther, idSelf);
|
||
IvParameterSpec ivConversation = this.getIvConversation(idConversationSelf);
|
||
// String str = "datetime(d1,'unixepoch','localtime')";
|
||
|
||
|
||
String getHistoriqueRequest = "SELECT id_conversation, id_type, content, date, extension "
|
||
+ "FROM message "
|
||
+ "WHERE id_conversation IN (?,?) "
|
||
+ "ORDER by date";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(getHistoriqueRequest);
|
||
prepStmt.setInt(1, idConversationSelf);
|
||
prepStmt.setInt(2, idConversationOther);
|
||
ResultSet res = prepStmt.executeQuery();
|
||
|
||
//Retrieve the messages one by one
|
||
//Create the appropriate message object depending on the type and sender/receiver
|
||
//and add the message in the list
|
||
while(res.next()) {
|
||
int idType = res.getInt("id_type");
|
||
String type = this.getType(idType);
|
||
|
||
String content = null;
|
||
try {
|
||
content = this.bytesToStringContent(res.getBytes("content"), ivConversation);
|
||
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
|
||
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException
|
||
| SQLException e1) {
|
||
//System.out.println("erreur d<>chiffrement");
|
||
}
|
||
|
||
Message message = null;
|
||
String extension;
|
||
|
||
if(!type.equals("")) {
|
||
try {
|
||
switch(type) {
|
||
case "text":
|
||
message = new MessageTexte(TypeMessage.TEXTE, content);
|
||
break;
|
||
case "file":
|
||
extension = res.getString("extension");
|
||
message = new MessageFichier(TypeMessage.FICHIER, content, extension);
|
||
break;
|
||
default:
|
||
extension = res.getString("extension");
|
||
message = new MessageFichier(TypeMessage.IMAGE, content, extension);
|
||
}
|
||
|
||
} catch (MauvaisTypeMessageException e) {
|
||
e.printStackTrace();
|
||
}
|
||
}
|
||
|
||
if(res.getInt("id_conversation") == idConversationSelf) {
|
||
message.setSender("Moi");
|
||
}else{
|
||
message.setSender(pseudoOther);
|
||
}
|
||
message.setDateMessage(res.getString("date"));
|
||
if(content != null) {
|
||
messages.add(message);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
this.closeConnection();
|
||
|
||
return messages;
|
||
}
|
||
|
||
|
||
private void insertUser(String username) throws SQLException {
|
||
String insertUserRequest = "INSERT INTO user (username) " + "VALUES (?);";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(insertUserRequest);
|
||
prepStmt.setString(1, username);
|
||
prepStmt.executeUpdate();
|
||
}
|
||
|
||
|
||
private int getIDUser(String username) throws SQLException {
|
||
String getIDRequest = "SELECT id " + " FROM user" + " WHERE username = ? ;";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
|
||
prepStmt.setString(1, username);
|
||
ResultSet res = prepStmt.executeQuery();
|
||
|
||
if (res.next()) {
|
||
return res.getInt("id");
|
||
}
|
||
return -1;
|
||
|
||
}
|
||
|
||
|
||
private void insertConversation(int idSender, int idReceiver) throws SQLException {
|
||
String insertConversationRequest = "INSERT INTO conversation (id_emetteur, id_recepteur, iv_conversation) " + "VALUES "
|
||
+ "(?, ?, ?),"
|
||
+ "(?, ?, ?);";
|
||
|
||
byte[] ivConversation = SQLiteEncprytion.generateIv().getIV();
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(insertConversationRequest);
|
||
prepStmt.setInt(1, idSender);
|
||
prepStmt.setInt(2, idReceiver);
|
||
prepStmt.setBytes(3, ivConversation);
|
||
prepStmt.setInt(4, idReceiver);
|
||
prepStmt.setInt(5, idSender);
|
||
prepStmt.setBytes(6, ivConversation);
|
||
|
||
prepStmt.executeUpdate();
|
||
}
|
||
|
||
|
||
private int getIDConversation(int idSender, int idReceiver) throws SQLException {
|
||
String getIDRequest = "SELECT id_conversation " + "FROM conversation " + "WHERE id_emetteur = ? "
|
||
+ "AND id_recepteur = ? ;";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
|
||
prepStmt.setInt(1, idSender);
|
||
prepStmt.setInt(2, idReceiver);
|
||
ResultSet res = prepStmt.executeQuery();
|
||
|
||
if (res.next()) {
|
||
return res.getInt("id_conversation");
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
private IvParameterSpec getIvConversation(int idConversation) throws SQLException {
|
||
String getIvRequest = "SELECT iv_conversation " + "FROM conversation " + "WHERE id_conversation = ?;";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(getIvRequest);
|
||
prepStmt.setInt(1, idConversation);
|
||
ResultSet res = prepStmt.executeQuery();
|
||
|
||
if (res.next()) {
|
||
return new IvParameterSpec(res.getBytes("iv_conversation"));
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
|
||
|
||
|
||
private int getIDType(String label) throws SQLException {
|
||
String getIDRequest = "SELECT id_type FROM type WHERE label = ?;";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
|
||
prepStmt.setString(1, label);
|
||
|
||
ResultSet res = prepStmt.executeQuery();
|
||
|
||
if (res.next()) {
|
||
return res.getInt("id_type");
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
private String getType(int idType) throws SQLException {
|
||
String getTypeRequest = "SELECT label FROM type WHERE id_type = ?;";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(getTypeRequest);
|
||
prepStmt.setInt(1, idType);
|
||
|
||
ResultSet res = prepStmt.executeQuery();
|
||
|
||
if(res.next()) {
|
||
return res.getString("label");
|
||
}
|
||
|
||
return "";
|
||
|
||
}
|
||
|
||
|
||
private byte[] stringToBytesContent(Message m, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
|
||
String content;
|
||
if (m.getTypeMessage() == TypeMessage.TEXTE) {
|
||
MessageTexte messageTxt = (MessageTexte) m;
|
||
content = messageTxt.getContenu();
|
||
}else {
|
||
MessageFichier messageFichier = (MessageFichier) m;
|
||
content = messageFichier.getContenu();
|
||
}
|
||
byte[] encryptedContent = SQLiteEncprytion.encrypt(SQLiteEncprytion.encryptAlgorithm, content.getBytes(), this.dbDataKey, iv);
|
||
return encryptedContent;
|
||
|
||
}
|
||
|
||
private String bytesToStringContent(byte[] encryptedContent, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
|
||
return SQLiteEncprytion.decryptString(SQLiteEncprytion.encryptAlgorithm, encryptedContent, this.dbDataKey, iv);
|
||
}
|
||
|
||
|
||
private String processMessageType(Message m) {
|
||
switch (m.getTypeMessage()) {
|
||
case TEXTE: return "text";
|
||
case FICHIER: return "file";
|
||
case IMAGE: return "image";
|
||
default: return "";
|
||
}
|
||
}
|
||
|
||
private String processExtension(Message m) {
|
||
if(m.getTypeMessage() == TypeMessage.TEXTE) {
|
||
return null;
|
||
}else {
|
||
MessageFichier mFile = (MessageFichier) m;
|
||
return mFile.getExtension();
|
||
}
|
||
}
|
||
|
||
|
||
private int insertMessage(int idConversation, Message m, IvParameterSpec iv) throws SQLException {
|
||
|
||
|
||
String dateMessage = m.getDateMessage();
|
||
String extension = this.processExtension(m);
|
||
String type = this.processMessageType(m);
|
||
int idType = this.getIDType(type);
|
||
|
||
byte[] content = null;
|
||
|
||
try {
|
||
content = this.stringToBytesContent(m, iv);
|
||
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
|
||
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
|
||
|
||
e.printStackTrace();
|
||
}
|
||
|
||
String insertMessageRequest = "INSERT INTO message(id_conversation, id_type, content, date, extension) "
|
||
+ "VALUES (?, ?, ?, ?, ?);";
|
||
|
||
PreparedStatement prepStmt = this.connec.prepareStatement(insertMessageRequest);
|
||
prepStmt.setInt(1, idConversation);
|
||
prepStmt.setInt(2, idType);
|
||
prepStmt.setBytes(3, content);
|
||
prepStmt.setString(4, dateMessage);
|
||
prepStmt.setString(5, extension);
|
||
|
||
int nbRows = prepStmt.executeUpdate();
|
||
|
||
return nbRows;
|
||
}
|
||
|
||
public void createNewUserEncrypt(String username, String password) {
|
||
|
||
|
||
String algo = SQLiteEncprytion.encryptAlgorithm;
|
||
|
||
KeyGenerator keyGen = null;
|
||
try {
|
||
keyGen = KeyGenerator.getInstance("AES");
|
||
keyGen.init(256);
|
||
} catch (NoSuchAlgorithmException e) {
|
||
e.printStackTrace();
|
||
}
|
||
|
||
byte[] passwordSalt = SQLiteEncprytion.getNextSalt();
|
||
byte[] dbDataKeySalt = SQLiteEncprytion.getNextSalt();
|
||
|
||
SecretKey dbDataKey = keyGen.generateKey();
|
||
|
||
SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password.toCharArray(), dbDataKeySalt);
|
||
IvParameterSpec ivDbDataKey = SQLiteEncprytion.generateIv();
|
||
|
||
byte[] passwordHash = SQLiteEncprytion.hash(password.toCharArray(), passwordSalt);
|
||
|
||
byte[] dbDataKeyEncrypted = null;
|
||
byte[] encryptedPasswordHash = null;
|
||
|
||
try {
|
||
dbDataKeyEncrypted = SQLiteEncprytion.encrypt(
|
||
algo, SQLiteEncprytion.keyToByte(dbDataKey), dbDataEncryptKey, ivDbDataKey);
|
||
encryptedPasswordHash = SQLiteEncprytion.encrypt(
|
||
algo, passwordHash , dbDataKey, ivDbDataKey);
|
||
|
||
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
|
||
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
|
||
// TODO Auto-generated catch block
|
||
e.printStackTrace();
|
||
}
|
||
|
||
this.openConnection();
|
||
|
||
String createUserRequest = "INSERT INTO user(username, pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey) "
|
||
+ "VALUES (?, ?, ?, ?, ?, ?); ";
|
||
|
||
PreparedStatement prepStmt = null;
|
||
try {
|
||
prepStmt = this.connec.prepareStatement(createUserRequest);
|
||
prepStmt.setString(1, username);
|
||
prepStmt.setBytes(2, passwordSalt);
|
||
prepStmt.setBytes(3, dbDataKeySalt);
|
||
prepStmt.setBytes(4, encryptedPasswordHash);
|
||
prepStmt.setBytes(5, dbDataKeyEncrypted);
|
||
prepStmt.setBytes(6, ivDbDataKey.getIV());
|
||
|
||
} catch (SQLException e) {
|
||
// TODO Auto-generated catch block
|
||
e.printStackTrace();
|
||
}
|
||
|
||
try {
|
||
prepStmt.executeUpdate();
|
||
System.out.println("Utilisateur cr<63>e");
|
||
} catch (SQLException e) {
|
||
System.out.println("Nom d'utilisateur d<>j<EFBFBD> pris");
|
||
}
|
||
|
||
this.closeConnection();
|
||
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param username
|
||
* @param password
|
||
* @return -1 if user do not exists,
|
||
* 0 if password incorrect,
|
||
* 1 if password correct
|
||
* @throws SQLException
|
||
*/
|
||
public int checkPwd(String username, char[] password) throws SQLException {
|
||
|
||
this.openConnection();
|
||
|
||
String selectUserDataRequest = "SELECT pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey "
|
||
+ "FROM user "
|
||
+ "WHERE username = ?;";
|
||
PreparedStatement prepStmt;
|
||
prepStmt = this.connec.prepareStatement(selectUserDataRequest);
|
||
prepStmt.setString(1, username);
|
||
|
||
ResultSet res = prepStmt.executeQuery();
|
||
if(!res.next()) {
|
||
return -1;
|
||
}
|
||
|
||
byte[] passwordSalt = res.getBytes("pwd_salt");
|
||
byte[] dbDataKeySalt = res.getBytes("db_datakey_salt");
|
||
|
||
SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password, dbDataKeySalt);
|
||
IvParameterSpec iv = new IvParameterSpec(res.getBytes("iv_datakey"));
|
||
|
||
byte[] encryptedDbDataKey = res.getBytes("encrypted_db_datakey");
|
||
|
||
|
||
SecretKey dbDataKey = null;
|
||
try {
|
||
dbDataKey = SQLiteEncprytion.byteToKey(
|
||
SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedDbDataKey, dbDataEncryptKey, iv)
|
||
);
|
||
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
|
||
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
|
||
//System.out.println("Probl<62>me d<>chiffrement cl<63> db");
|
||
}
|
||
|
||
this.dbDataKey = dbDataKey;
|
||
|
||
byte[] encryptedPasswordHash = res.getBytes("encrypted_pwd_hashsalt");
|
||
|
||
|
||
byte[] passwordHash = SQLiteEncprytion.hash(password, passwordSalt);
|
||
|
||
this.closeConnection();
|
||
|
||
boolean checkHash = this.checkHashPwd(passwordHash ,encryptedPasswordHash, dbDataKey, iv);
|
||
if(checkHash) {
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
private boolean checkHashPwd(byte[] passwordHash, byte[] encryptedPasswordHash, SecretKey dbDataKey, IvParameterSpec iv) {
|
||
|
||
byte[] expectedHash = "".getBytes();
|
||
try {
|
||
expectedHash = SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedPasswordHash, dbDataKey, iv);
|
||
} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
|
||
| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
|
||
}
|
||
|
||
|
||
|
||
if (passwordHash.length != expectedHash.length) return false;
|
||
for (int i = 0; i < passwordHash.length; i++) {
|
||
if (passwordHash[i] != expectedHash[i]) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
public static void main(String[] args) {
|
||
String[] hardcodedNames = {"Olivia","Liam","Benjamin","Sophia","Charlotte","Noah","Elijah","Isabella",
|
||
"Oliver","Emma","William","Amelia","Evelyn","James","Mia","Ava","Lucas","Mason","Ethan","Harper"};
|
||
|
||
String pwdPrefix = "aze1$";
|
||
|
||
SQLiteManager sqlManager = new SQLiteManager(1);
|
||
|
||
for(int i=0; i<hardcodedNames.length; i++) {
|
||
sqlManager.createNewUserEncrypt(hardcodedNames[i]+i, pwdPrefix+hardcodedNames[i].charAt(0)+i);
|
||
}
|
||
|
||
}
|
||
|
||
}
|