Example #1
0
 public STG insertToken(STG oSTG)
 {
     oSTG.SetData("query", "UPDATE t_user "+
                 "SET [use_token] = '" + oSTG.TokenUser + "' "+
                 "WHERE use_login = '******' ;");
     return oSTG;
 }
Example #2
0
 public STG checkToken(STG oSTG)
 {
     oSTG.SetData("query", "SELECT * "+
                           "FROM t_user "+
                           "WHERE use_token = '"+ oSTG.TokenUser + "';");
     return oSTG;
 }
Example #3
0
        public STG Execute(STG oSTG)
        {
            for (int i = 1; i < 10000; i++)
            {

            }
            return oSTG;
        }
Example #4
0
        public STG executeRQuery(STG oSTG)
        {
            if (oSTG.GetData("query") != null)
            {
                SqlCommand sqlCommand = new SqlCommand((string)oSTG.GetData("query"), this.sqlConn);
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                oSTG.SetData("sqldatareader", sqlDataReader);
            }
            return oSTG;
        }
 public STG Execute(STG oSTG)
 {
     if (!string.IsNullOrEmpty((string)oSTG.GetData("login")))
     {
         if (!string.IsNullOrEmpty((string)oSTG.GetData("password")))
         {
             string login = (string)oSTG.GetData("login");
             string password = (string)oSTG.GetData("password");
             User oUser = new User(login, password);
             oSTG = oUser.checkUser(oSTG);
             CAD oCAD = new CAD();
             oCAD.openConnection();
             oSTG = oCAD.executeRQuery(oSTG);
             SqlDataReader resultset = (SqlDataReader)oSTG.GetData("sqldatareader");
             if (resultset.HasRows) // Vérification de l'utilisateur en base de données
             {
                 oSTG.Status_op = true;
                 oSTG.Info = "Connexion réussie";
                 //Console.WriteLine("Connexion réussie de l'utilisateur " + login);
                 int unixTimestamp = (int)(DateTime.Now.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
                 string log = login;
                 if (login.Length > 10)
                 {
                     log = login.Substring(0, 10);
                     log += unixTimestamp;
                 }
                 else
                 {
                     log += unixTimestamp;
                     log += unixTimestamp.ToString().Substring(0, (10-login.Length));
                 }
                 oSTG.TokenUser = log;
             }
             else
             {
                 oSTG.Status_op = false;
                 oSTG.Info = "Le login et le mot de passe ne correspondent pas";
             }
         }
         else
         {
             oSTG.Status_op = false;
             oSTG.Info = "Le mot de passe n'est pas fourni";
         }
     }
     else
     {
         oSTG.Status_op = false;
         oSTG.Info = "Le login n'est pas fourni";
     }
     return oSTG;
 }
        public STG Execute(STG oSTG)
        {
            if (!string.IsNullOrEmpty((string)oSTG.GetData("login")))
            {
                if (!string.IsNullOrEmpty(oSTG.TokenUser))
                {
                    string login = (string)oSTG.GetData("login");
                    string token = oSTG.TokenUser;
                    User oUser = new User(login, token);
                    oSTG = oUser.insertToken(oSTG);

                    cad.openConnection();
                    oSTG = cad.executeCUDQuery(oSTG);

                    SqlDataReader sqlDataReader = (SqlDataReader)oSTG.GetData("sqldatareader");
                    if (sqlDataReader.RecordsAffected != 0) //verification du token en base
                    {
                        oSTG.Status_op = true;
                        oSTG.Info = "Token Updaté";
                        //Console.WriteLine("Le token de l'utilisateur est bon " + login);
                    }
                    else
                    {
                        oSTG.Status_op = false;
                        oSTG.Info = "L'utilisation du token utilisateur n'a pas réussi";
                    }
                    cad.closeConnection();
                }
                else
                {
                    oSTG.Status_op = false;
                    oSTG.Info = "Le token User n'est pas fourni";
                }
            }
            else
            {
                oSTG.Status_op = false;
                oSTG.Info = "Le login n'est pas fourni";
            }
            return oSTG;
        }
        public STG Execute(STG oSTG)
        {
            if (!string.IsNullOrEmpty((string)oSTG.GetData("login")))
            {
                if (!string.IsNullOrEmpty((string)oSTG.TokenUser))
                {
                    string login = (string)oSTG.GetData("login");
                    string token = (string)oSTG.GetData("token");
                    User oUser = new User(login, token);
                    oSTG = oUser.checkToken(oSTG);

                    cad.openConnection();
                    oSTG = cad.executeRQuery(oSTG);

                    SqlDataReader sqlDataReader = (SqlDataReader)oSTG.GetData("sqldatareader");
                    if (sqlDataReader.HasRows) //verification du token en base
                    {
                        oSTG.Status_op = true;
                        oSTG.Info = "Token Trouvé";
                        //Console.WriteLine("Le CheckTokenUser de l'utilisateur est bon " + login);
                    }
                    else
                    {
                        oSTG.Status_op = false;
                        oSTG.Info = "Le token utilisateur n'existe pas en base";
                    }
                    cad.closeConnection();
                }
                else
                {
                    oSTG.Status_op = false;
                    oSTG.Info = "Le token User n'est pas fourni";
                }
            }
            else
            {
                oSTG.Status_op = false;
                oSTG.Info = "Le login n'est pas fourni";
            }
            return oSTG;
        }
Example #8
0
        public STG connection(STG oSTG)
        {
            oSTG.Info = "arrivée sur le serveur";
            oSTG.SetData("test", "this is a test");
            if (oSTG.TokenApp == "Generator")
            {
                if (!string.IsNullOrEmpty(oSTG.Operationname))
                {
                    string[] operationSplit = oSTG.Operationname.Split(new char[] { '_' });
                    if (operationSplit.Length >= 2)
                    {
                        string nomClasse = operationSplit[0];
                        string nomMethode = operationSplit[1];
                        if (nomClasse == "GpcsUser")
                        {
                            GpcsUser oGpcsUser = new GpcsUser();
                            oSTG.Operationname = nomMethode;
                            oSTG = oGpcsUser.ConnectionUser(oSTG);
                        }
                        else if (nomClasse == "GpcsDecrypt")
                        {
                            GpcsDecrypt oGpcsDecrypt = new GpcsDecrypt();
                            oSTG.Operationname = nomMethode;
                            oSTG = oGpcsDecrypt.Decrypter(oSTG);
                        }
                        else
                        {
                            oSTG.Status_op = false;
                            oSTG.Info = "Le nom de l'opération n'est pas valide";
                        }
                    }
                    else
                    {
                        oSTG.Status_op = false;
                        oSTG.Info = "Le nom de l'opération n'est pas valide";
                    }
                }
                else
                {
                    oSTG.Status_op = false;
                    oSTG.Info = "Le nom de l'opération n'est pas spécifié";
                }

            }
            else
            {
                oSTG.Status_op = false;
                oSTG.Info = "Le token de l'application n'est pas valide";
            }
            oSTG.SetData("sqldatareader", "");
            oSTG.SetData("query", "");
            try
            {
                //oSTG.files.Clear();
            }
            catch (Exception)
            {

            }
            oSTG.SetData("mail", GlobalVariables.mail);
            GlobalVariables.cleTrouve = false;

            return oSTG;
        }
Example #9
0
 public STG Decrypter(STG oSTG)
 {
     oSTG = oCAM.connection(oSTG);
     return oSTG;
 }
Example #10
0
        public STG connection(STG oSTG)
        {
            ConnectionUser oConnectionUser = new ConnectionUser();
            UpdateTokenUser oUpdateTokenUser = new UpdateTokenUser();
            CheckTokenUser oCheckTokenUser = new CheckTokenUser();
            Dechiffrer oDechiffrer = new Dechiffrer();
            Stop oStop = new Stop();

            if (!string.IsNullOrEmpty(oSTG.Operationname))
            {
                string operationName = (string)oSTG.Operationname;
                if (operationName == "ConnectionUser") // Vérifie si le nom de la méthode à appeller est ConnectionUser
                {

                    oSTG = oConnectionUser.Execute(oSTG);

                    if (oSTG.Status_op) //User est en base
                    {
                        oSTG = oUpdateTokenUser.Execute(oSTG);
                        if (oSTG.Status_op)
                        {
                            oSTG.Status_op = true;
                            oSTG.Info = "Connection Succeed";
                        }// Token updaté
                    }
                    else {
                        oSTG.Status_op = false;
                        oSTG.Info = "Echec connection User";
                    }
                }
                else// Vérifie le token en base de données
                {
                    oSTG = oCheckTokenUser.Execute(oSTG);
                    if (oSTG.Status_op)
                    {
                        if (operationName == "Dechiffrer")
                        {
                            oDechiffrer.Execute(oSTG);
                        }
                        else if (operationName == "Stop")
                        {
                            oStop.Execute();
                        }
                        else
                        {
                            oSTG.Status_op = false;
                            oSTG.Info = "Le nom de l'opération n'est pas valide";
                        }
                    }
                    else
                    {
                        oSTG.Status_op = false;
                        oSTG.Info = "Le token n'est pas trouvé";
                    }
                }

            }
            else
            {
                oSTG.Status_op = false;
                oSTG.Info = "Le nom de l'opération n'est pas spécifié";
            }
            return oSTG;
        }
Example #11
0
 public STG checkUser(STG oSTG)
 {
     oSTG.SetData("query", "select * from dbo.t_user where use_login = '******'and use_pwd = '"+ oSTG.GetData("password") + "'");
     return oSTG;
 }
Example #12
0
        public STG Execute(STG oSTG)
        {
            Stopwatch sw2 = new Stopwatch();
            sw2.Start();
            Hashtable files = (Hashtable) oSTG.files;
            int sampleSize = (int)oSTG.GetData("sampleSize");
            bool useSample = true;
            if (sampleSize < 1)
            {
                useSample = false;
            }
            ReceptionSTGClient rSTG = new ReceptionSTGClient();
            foreach (DictionaryEntry key in files)
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                //Console.WriteLine("key : "+key.Key/* + " - value :" + key.Value*/);
                string texte = key.Value.ToString();
                string echantillon;
                if (texte.Length > sampleSize && useSample)
                {
                    echantillon = texte.Substring(0, sampleSize);
                }
                else
                {
                    echantillon = texte;
                }
                int taille = echantillon.Length;
                uint[] txt_tab = new uint[taille];
                for (int j = 0; j < taille; j++)
                {
                    txt_tab[j] = (uint)echantillon[j];
                }
                Console.WriteLine("début de l'envoi des messages : ");
                Helper help = new Helper();
                // on lit le fichier
                help.Txt_tab = txt_tab;
                // On compte le nombre de processeur :
                int heart = Environment.ProcessorCount;
                int keyNumber = 10000;
                string file_name = key.Key.ToString();

                //On complete les tableau de start et operations
                help.calculOperation(heart, keyNumber);

                // Création du delegate de traitement :
                paramDelegate dlg = new paramDelegate(help.decrypter);

                // ON commence le traitement sur les 10 000 clés
                Parallel.For(0, heart, i =>
                {
                    help.decrypter(i, file_name);
                });
                sw.Stop();
                Console.WriteLine("messages envoyés : " + help.Envoi + " en " + sw.Elapsed + " secondes");
                if (GlobalVariables.cleTrouve)
                {
                    break;
                }
            }
            if (GlobalVariables.cleTrouve)
            {
                int nb_files = 0;
                foreach (DictionaryEntry key in files)
                {

                    string texte = key.Value.ToString();
                    int taille = texte.Length;
                    uint[] txt_tab = new uint[taille];
                    for (int j = 0; j < taille; j++)
                    {
                        txt_tab[j] = (uint)texte[j];
                    }
                    string txt = EncryptOrDecrypt(txt_tab, GlobalVariables.cle);
                    txt = CleanInvalidXmlChars(txt);
                    rSTG.sendToQueue(txt, key.Key.ToString(), GlobalVariables.cle, false);
                    nb_files++;
                    //Console.WriteLine(txt);
                    //Console.WriteLine("l'email trouve est" + GlobalVariables.mail);
                }
                while (GlobalVariables.nb_callback < nb_files)
                {
                    System.Threading.Thread.Sleep(500);
                }
                oSTG.files.Clear();
                oSTG.SetData("cle", GlobalVariables.cle);
                oSTG.SetData("mail", GlobalVariables.mail);

                oSTG.files = GlobalVariables.files;
            }
            sw2.Stop();
            Console.WriteLine("Temps de traitement total : " + sw2.Elapsed.ToString());
            return oSTG;
        }