Demande aide personnalisé conception JAVA

Bonjour,

Je suis étudiant (bac+2) et je finis mon stage de 2 mois dans 2 semaines. Je suis trop à labour.....Je panique et je m'embrouille.... J'ai besoin d'aide
Le but de mon projet est de comparer les temps d'exécution du hash d'un fichier passé en paramètre en fonction des différents providers disponibles sur le marché (JCA, BoucyCastle, IAIK et Openssl).
Les réultats ainsi obtenus sont à insérer dans une base de donnée (ça je ne l'est pas encore fait... )
Je demande de l'aide pour finaliser mon code :
- séparer l'interface graphique de la crypto (un petit framework ?)
- développer une classe qui permette l'insertion des résultats dans une base de donnée mysql

Si en plus il y avait conception UML, ce serait super.

Suis prêt à dédommager largement la personne qui se penchera sur mon sujet et me fournira un projet finalisé. (Contactez-moi en message privé pour plus de renseignaments, notamment pour que je vous passe les bibliothèques Bouncycastle et IAIK que j'utilise ainsi qu'Openssl.).

Mon mail : comeochris@hotmail.com

#################################################################

Ci-dessous mon code :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;

import java.security.*;
import iaik.security.provider.IAIK;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public class Test
{
public static void main(String[] args)
{
// Ajoute le provider BouncyCastle
Security.addProvider(new BouncyCastleProvider());
// Ajoute le provider IAIK
Security.addProvider(new IAIK());

// Crée un obet MessageDigestFrame (cf classe MessgeDigestFrame extends JFrame)
JFrame frame = new MessageDigestFrame();
frame.setVisible(true); // Rends la Frame visible
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// Quitte le logiciel lorsqu'on ferme la JFrame
}
}

class MessageDigestFrame extends JFrame
{
private MessageDigest md;
private JTextArea message = new JTextArea(); // Multiligne
private byte [] hash;
static final long serialVersionUID = 00001;

public MessageDigestFrame()
{
this.setTitle ("Test Hash"); //Titre de la JFrame
this.setSize (500,300); //Taille de la JFrame

// Création de la zone de choix (boutons radios)
JPanel panel = new JPanel (); //1er panel
JPanel panel2 = new JPanel (); //2ème panel

ButtonGroup group = new ButtonGroup(); // Sert à contenir plusieurs boutons.Un et un seul de ses boutons sera sélectionné simultanément.
// Définitions des 4 boutons permettant à l'utilisateur de choisir le provider qu'il souhaite utiliser pour le test
this.addRadioButton (panel, "JCA", group);
this.addRadioButton (panel, "BC", group);
this.addRadioButton (panel, "IAIK", group);
this.addRadioButton (panel, "OpenSSL", group);
// Définition du bouton servant à choisir le fichier à hacher
this.addFileButton (panel2, "Choix du Fichier");

// Composition graphique
this.getContentPane().add(panel, BorderLayout.NORTH); // En haut, les boutons
this.getContentPane().add(new JScrollPane(message), BorderLayout.CENTER); // Au centre, le résultat
this.getContentPane().add(panel2, BorderLayout.SOUTH); // En bas, le bouton de choix du fichier
message.setFont(new Font ("Monospaced", Font.PLAIN,12)); // Affichage personnalisé de l'empreinte

setProvider("JCA");
}

/**
Ajouter un bouton dans un groupe de boutons permettant de choisir le provider
@param c est le container dans lequel on va placer le bouton
@param name est le nom du provider
@param g est le groupe de bouton
*/
public void addRadioButton(Container c, final String name, ButtonGroup g)
{
ActionListener listener = new ActionListener() // Ajout d'un évenement
{
public void actionPerformed(ActionEvent event) //Action de l'événément (clic sur le bouton radio)
{
setProvider(name); //Mets à jour le provider à utiliser dans le programme
}
};
// Crée un bouton radio (le premier bouton créé sera celui qui sera coché)
JRadioButton RadioButton = new JRadioButton(name, g.getButtonCount() == 0);
c.add(RadioButton); // Ajoute le bouton au container (panel)
g.add(RadioButton); // Ajoute le bouton au groupe (group)
RadioButton.addActionListener(listener); // Ajoute l'événement "listener" au bouton
}
/**
Ajouter un bouton permettant de choisir le fichier à hacher
@param c est le container dans lequel on va placer le bouton
@param name est le nom du bouton

*/
public void addFileButton(Container c, final String name)
{
ActionListener listener = new ActionListener() // Ajout d'un évenement
{
public void actionPerformed(ActionEvent event) //Action de l'événément (clic sur le bouton)
{
// Création d'un nouveau filechosser
JFileChooser chooser = new JFileChooser();
// Définition du répertoire sur lequel va se positionner le filechooser
chooser.setCurrentDirectory(new File("D:\\File"));
// Initialise le bouton de confirmation (ApproveButton)
chooser.setApproveButtonText("Calcul le hash");
// affiche la boite de dialogue
int r = chooser.showOpenDialog(null);
if (r == JFileChooser.APPROVE_OPTION) // si un fichier est selectionné,
{
try
{
// Récupère le nom du fichier puis son path
String name = chooser.getSelectedFile().getAbsolutePath();
long result = repeatDigest(10000,name);
message.setText("Provider utilisé : " + md.getProvider().toString() + "\nFichier à Hacher : " + chooser.getSelectedFile().getAbsolutePath() + "\nTemps d'exécution de 10000 hasch de ce fichier : " +result + "\nValeur du dernier hash traité : " + displayDigest(hash));
}
catch (IOException e)
{
JOptionPane.showMessageDialog(null,e);
}
}
}
};
// Crée un bouton
JButton FileButton = new JButton(name);
c.add(FileButton); // Ajoute le bouton au container (panel)
FileButton.addActionListener(listener); // Ajoute l'événement "listener" au bouton
}

/**
Fonction permettant de mettre à jour le provider qui sera utilisé dans le calcul du hash
@param prov Le provider choisi
*/
public void setProvider(String prov)
{
try
{
if (prov=="JCA")
{
md = MessageDigest.getInstance("SHA-1");//JCA
}
else
{
if (prov!="OpenSSL")
{
md = MessageDigest.getInstance("SHA-1",prov); //BouncyCasle et IAIK
}
else
{
md = null; //OpenSSL
}
}
message.setText(""); //Initialise la zone de texte
}
catch (NoSuchAlgorithmException e) // Gestion Exception NoSuchAlgorithmException
{
message.setText("L'alghorithme de hash SHA-1 est inconnu.");
}
catch (NoSuchProviderException e) // Gestion Exception NoSuchProviderException
{
message.setText("Le provider "+ prov + " est introuvable.");
}
}
/**
Fonction permettant de charger dans un buffer les bytes d'un fichier
@param name Le nom du fichier (son chemin absolu)
@return un tableau de bytes
*/
public byte[] loadBytes(String name) throws IOException
{
// Ouvre un flux vers le fichier passé en paramètre de la fonction
RandomAccessFile raf = new RandomAccessFile(name, "r");
try
{
// Tableau d' octets servant à stocker les valeurs de la séquence d'octets composant le fichier
byte[] buffer = new byte[(int)raf.length()];
raf.readFully(buffer); // lit chaque octet de "raf" et stocke les dans le tableau d'octets "buffer"
return buffer; //Retourne le tableaux d'octets composant le fichier passer en paramètre de cette fonction
}
finally // Dans tous les cas ferme le flux
{
raf.close();
}
}
/**
Fonction permettant de calculer le messagedigest à partir d'un tableau de bytes
@param b Le tableau de bytes servant au calcul
*/
public byte[] computeDigest(byte[] b)
{
md.reset(); //Réinitialise l'objet
md.update(b); //On donne le tableau de bytes servant à faire le digest
// Calcul le hash à partir du tableau de bytes et place le résultat dans un autre tableau de bytes
hash = md.digest(); //Mémorise le hash pour pouvoir l'afficher plus tard
return hash;
}
/**
Fonction permettant de calculer le messagedigest 'OpenSSL' à partir du nom du fichier à hacher
@param name Le nom du fichier à hacher
*/
public byte[] computeOpensslDigest(String name)throws IOException
{
Process p = Runtime.getRuntime().exec("C:\\Openssl\\Bin\\openssl dgst -sha1 -binary " + name);
// Ouvre un flux vers le fichier passé en paramètre de la fonction
InputStream in = new BufferedInputStream(p.getInputStream());
try
{
// Tableau de 20 octets permettant de stocker les 20 octets du hash
byte [] buffer = new byte [20];
in.read(buffer);// lit chaque octet de "in" et stocke les dans le tableau d'octets "buffer"
hash = buffer; //Mémorise le hash pour pouvoir l'afficher plus tard
return buffer; //Retourne le tableau de byte ainsi obtenu
}
finally // Dans tous les cas ferme le flux
{
in.close();
}
}
/**
Fonction permettant de répéter x fois le hash du fichier sélectionné
@param nbOfRep Le nombre de hash à traiter
@param name Le nom du fichier à hacher
*/
public long repeatDigest (int nbOfRep, String name) throws IOException
{
long t_depart = System.currentTimeMillis(); // Heure courante (ms)
// Boucle servant à calculer le temps d'exécution de 'nbOfRep' traitements
for (int cpt=0;cpt<nbOfRep;cpt++)
{
// Si md==null alors calcule le hash via openssl sinon extrais les bytes du fichier et calcules le hash
if (md == null){computeOpensslDigest(name);}
else {computeDigest(loadBytes(name));}
}

return System.currentTimeMillis() - t_depart; //Temps d'exécution de 'nbOfRep' traitements
}
/**
Fonction permettant de transformer un tableau de bytes sous forme hexadécimale
@param b Le tableau de bytes à transformer en hexa
*/
public String displayDigest(byte[] b)
{
String d = "";
for (int i = 0; i < b.length; i++)
{
int v = b[i] & 0xFF;
if (v < 16) d += "0";
d += Integer.toString(v, 16).toUpperCase() + " ";
}
return d;
}


}