• STATISTIQUES
  • Il y a eu un total de 0 membres et 27307 visiteurs sur le site dans les dernières 24h pour un total de 27 307 personnes!
    Membres: 2 605
    Discussions: 3 579
    Messages: 32 816
    Tutoriels: 78
    Téléchargements: 38
    Sites dans l'annuaire: 58


  • ANNUAIRE
  • [EN] Rosecode
    Programming: 36, Math: 29, Probability: 5, Sequence: 7, Crypto: 4, Brainf**k: 13, TimeRace: 4, Hack: 9
    Challenges
    [FR] PHP Débutant
    Apprendre le PHP par l'exemple, facilement et simplement. Réservé d'abord aux débutants....
    Programmation
    [EN] PHPFreaks
    PHPFreaks est un site dédié à l'apprentissage et l'enseignement du PHP. Ici vous trouver...
    Programmation
    [EN] osix
    Site de challenge qui utilise un système de level on chaque épreuve doit être réussie avant d'accédÃ...
    Challenges
    [FR] Root-me
    Script: 5, Système: 20, Cracking: 16, Cryptanalyse: 17, Programmation: 8, Réaliste: 11, Réseau: 10, Stéganog...
    Challenges
    [EN] hax.tor
    50 level de challenges mélangés
    Challenges
    [FR] Cyber-Hacker
    CH - Cyber Hacker est un jeu par navigateur de simulation de hack, programmez et envoyez vos virus et piratez les aut...
    Hacking

  • DONATION
  • Si vous avez trouvé ce site internet utile, nous vous invitons à nous faire un don du montant de votre choix via Paypal. Ce don servira à financer notre hébergement.

    MERCI!

    €



Note de ce sujet :
  • Moyenne : 0 (0 vote(s))
  • 1
  • 2
  • 3
  • 4
  • 5
[C] Programme de hashage
21-03-2013, 22h30 (Modification du message : 21-03-2013, 22h35 par Junky.)
Message : #1
Junky Hors ligne
Snorky Master
*



Messages : 228
Sujets : 35
Points: 203
Inscription : Mar 2013
[C] Programme de hashage
Bonjour.

Voici un programme que j'ai codé. Je vous le poste pour 2 choses:

=> Pour le partager (normal j'ai envie de dire et sa va dans l'idée/optique de la communauté)
=> Une quelconque optimisation.

En aucun celui-ci fais office de tutoriel ou autre. Mais il peu être pris en exemple pour l'implémentation d'option, savoir comment vérifier qu'un char appartient a un ensemble ou autre.

Le but du programme est simple. En passant les paramètres qui vont bien, on ne fait que hasher une chaine de caratères (char *crypt (const char *clef, const char *salt)) dans le format choisi:
md5
blowfish
sha256
sha512


Comme certains le verront surement , je me suis appuyé sur le format /etc/shadow.

Le salt est par défault généré aléatoirement, mais il est possible de pouvoir mettre son propre salt (option -s). Il ne vous sera demandé que les 8 caractères. Les $n$ et le $ de fin du salt seront rajoutés automatiquement. le n entre les $ aura une valeur en fonction du type de hashage choisi:
1 - md5
2 - blowfish
5 - sha256
6 - sha512



Voici le code:

Code :
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX         255
#define MD5         "md5"
#define BLOWFISH    "blowfish"
#define SHA256      "sha256"
#define SHA512      "sha512"
#define SIZE_SALT   13
#define SIZE_S      8
#define TYPE_CHAR   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/."
char *crypt (const char *clef, const char *salt);
char *strtok( char *str1, const char *str2 );


/********************************************************************
void salt_gene(char [], char );
    Fonction génération du salt:

    Arguments:
        buf[]: buffer vide afin de stocker le salt
        type:  Numero du type de hashage
                        - 1: md5
                        - 2: blowfish
                        - 5: SHA256
                        - 6: SHA512
    Action:
        Cette fonction génère aleatoirement une chaine de caractères
        dans l'ensemble suivant:
            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/."

********************************************************************/
void salt_gene(char buf[SIZE_SALT], char type)
{
    int i;
    srand(time(NULL));

    buf[0]='$';
    buf[1]=type;
    buf[2]='$';
    for (i=3; i < 11;i++){
        buf[i]=(TYPE_CHAR)[rand() % 64];
    }
    buf[11]='$';
    buf[12]='\0';
}

/************************************************************************
void usage();
    Fonction d'affichage du menu.

    Arguments:
        Aucun!

    Action:
        Affiche le menu d'aide et quit le programme avec un statut de 1
************************************************************************/
void usage() {
    printf("Usage:\nhash -c [CHAINE A HASHER] -t [md5|blowfish|sha256|sha512] -s [SALT] -v -h\n\nOptions:\n");
    printf("\t-c:\tchaine de caractère a hasher. (Option Obligatoire)\n");
    printf("\t-t:\tType de hashage (md5:blowfish:sha256:sha512). (Option Obligatoire)\n");
    printf("\t-s:\tDéfini le salt désiré. [SIZE => 8 char]\n");
    printf("\t   \tCaractères autorisés:\n");
    printf("\t   \t[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/.]\n");
    printf("\t-v:\tMode verbose.\n");
    printf("\t-h:\tAffiche ce menu.\n");
    exit(1);
}

/************************************************************************
void check_arg(int , char **);
    Fonction de gestion de paramètres obligatoire

    Arguments:
        nb:     est tout simplement argc. Cad le nombre de paramètres
                passé
        chaine: est tout simplement argv[].

    Action:
        Check tout les paramètres passé et verifie si les options -c -t
        sont bien présentes. Si oui on continue le programme, Si non on
        affiche le menu d'aide et cloture le programme.
************************************************************************/
void check_arg(int nb, char **chaine) {

    int opt_c = 0, opt_t = 0, i;
    for ( i = 0; i < nb; i++) {
        if (strcmp(chaine[i], "-c") == 0)
            opt_c = 1;
        if (strcmp(chaine[i], "-t") == 0)
            opt_t = 1;
    }

    if (!opt_c)
        usage();
    else if (!opt_t)
        usage();
}

/************************************************************************
void check_salt(char [], char );
    Fonction de check de l'arg de l'option -s

    Argument:
        salt[]: cahine de caractères choisi par l'$USER

        type:  Numero du type de hashage
                        - 1: md5
                        - 2: blowfish
                        - 5: SHA256
                        - 6: SHA512

    Action: cette fonction a pour but de parser la chaine de caractères
            saisie par l'$USER et de checker si celui-ci n'a pas saisie
            de mauvais caractères.
            Les caractères autorisés sont:
                abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/.
************************************************************************/
void check_salt(char salt[SIZE_S], char type){
    char carac[]=TYPE_CHAR, tab[SIZE_S];
    int i, j, check;

    memset(tab, 0, SIZE_S);
    strncpy(tab, salt, SIZE_S);
    
    salt[0]='$';
    salt[1]=type;
    salt[2]='$';

    for (i = 0; i < SIZE_S  ; i++){
        check = 0;
        j = 0;
        while(j<strlen(carac)) {
            if (tab[i] == carac[j]) {
                check = 1;
            }
            j++;
        }
        if (check == 0)
            usage();
        else
            salt[i+3] = tab[i];
    }
    salt[11]='$';
    salt[12]='\0';
}

int main (int argc, char* argv[])
{

    
    //Avant de tout initialiser, on check le nombre d'arguments
    if (argc < 2)
        usage();
    else {
        //On va déjà check les arguments OBLIGATOIRES comme le -t et -c
        check_arg(argc, argv);
        //Le salt fait 8 caratères de long + $n$ au début et $\0 a la fin donc 13
        char type = {0}, salt[SIZE_SALT], buffer[256], option[]="hc:t:s:v", type_Name[10];
        int verbose = 0, opt = 0, opt_s = 0;

        //Initialisation des tab
        memset(buffer, 0, 255);
        memset(salt, 0, SIZE_SALT);
        memset(type_Name, 0,10);

        //Check des arg
        while((opt=getopt(argc, argv, option)) != -1) {
            switch(opt) {
                case 'c':
                    strncpy(buffer, optarg, MAX);
                    break;
                case 't':
                    if (strcmp(optarg, MD5) == 0) {
                        strcpy(type_Name, MD5);
                        type = '1';
                    }
                    else if (strcmp(optarg, BLOWFISH) == 0){
                        strcpy(type_Name, BLOWFISH);
                        type = '2';
                    }
                    else if (strcmp(optarg, SHA256) == 0) {
                        strcpy(type_Name, SHA256);
                        type = '5';
                    }
                    else if (strcmp(optarg, SHA512) == 0) {
                        strcpy(type_Name, SHA512);
                        type = '6';
                    }
                    break;
                case 'v':
                    verbose = 1;
                    break;
                case 's':
                    if ((strlen(optarg) > SIZE_S) || (strlen(optarg) < SIZE_S)) {
                        usage();
                    }
                    else {
                        strncpy(salt, optarg, SIZE_SALT);
                        check_salt(salt, type);
                        opt_s = 1;
                    }
                    break;
                case 'h':
                    usage();
                    break;
            }
        }
        
        //Génération du salt
        if (!opt_s)
           salt_gene(salt, type);

        //Si mode verbose on affiche ttes les infos
        if (verbose)
            printf("Salt: %s\nChaine à hasher: %s\nType de hash: %s\n\nRésultat: %s\n", salt, buffer, type_Name,crypt(buffer,salt));
        //Sinon juste le résultat
        else
            printf("Résultat: %s\n", crypt(buffer,salt));
    }
return 0;
}

voici un lien pour une meilleur vision:

http://silentd.root-me.org/scripts/hash1.c.html

Pour les personnes qui le téléchargerons, il vous faudrat rajouter -lcrypt comme option a gcc.
Code :
gcc -o hash1 hash1.c -lcrypt

L'option -h vous donnera les différentes options.

J'ai essayé de commenter les fonctions un maximum. Comme vous pourrez le voir, je pose trés peu de commentaire l'intérieur de celle-ci mais préfère expliquer leur fonctionnement dans un bloc de commentaire situé juste au dessus de celle-ci.

Je suis ouvert à toutes "réflextions" sur le code car celles-ci ne peuvent qu'être bénéfiques. Aussi bien pour moi (faut savoir être égoîste un peu des fois :p) mais aussi pour ceux qui liront la discussion et qui désirent approfondir leur connaissances.

Il doit certainement y avoir des exploitations diverses a ce code. Donc certainement des choses à en dire alors comme dirais un ami (qui se reconnaitra)
"bah go!" Smile


On est loin du programme de fou qui va faire tourner la planète a l'envers hein Wink. Je suis juste dans une démarche de partage et de "perfectionnement" aussi bien personelle que communautaire.

Junky

PS: vous avez la source ici:
http://silentd.root-me.org/scripts/sourc...es/hash1.c
Pour la sécurité, sous linux, le principal soucis est l'interface chaise/clavier

+1 (4) -1 (0) Répondre
23-03-2013, 12h11
Message : #2
Junky Hors ligne
Snorky Master
*



Messages : 228
Sujets : 35
Points: 203
Inscription : Mar 2013
RE: [C] Programme de hashage
Bonjour.

J'ai modifié le code en changeant une fonction. Ma fonction check_salt() était itérative, cad (pour ceux qui ne connaisse pas) que j'utilisais des boucles for() while().

J'ai donc décidé de la rendre récursive, cad (tjs pour ceux qui ne connaisse pas) un algorithme quil s'appelle lui-même.

Voici le code de la fonction:

Code :
/************************************************************************
void check_salt(char [], int i, int j, int check);
    Fonction de check de l'arg de l'option -s

    Argument:
        salt[]: chaine de caractères choisi par l'$USER

        i:      compteur sur SIZE_S (longueur de l'argument de l'opt -s)
        j:      compteur sur TYPE_CHAR
        check:  bool
    
    Action:     cette fonction est récursive. Elle s'appelle elle même
                afin check si les caractères saisis par le $USER font bien
                parti de l'ensemble suivant:
                abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/.
************************************************************************/
void check_salt(char salt[SIZE_S], int i, int j, int check){
    if(i < SIZE_S){
        if (j < strlen(TYPE_CHAR))
            if (salt[i] == TYPE_CHAR[j]){
                check = 1;
                check_salt(salt, i+1, 0, check);
            }
            else {
                if ((check == 0) && (j == strlen(TYPE_CHAR)-1))
                    usage();
                check = 0;
                check_salt(salt, i , j+1, check);
            }
    }
}

La compréhension reste assez simple. On tourne sur deux compteurs. Un qui est la longueur de l'argument pour l'option -s et l'autre la longueur de la chaine contenant les caractères autorisé.

J'ai aussi modifié la fonction salt_gene() afin d'optimiser et de pouvoir implémenter correctement ma nouvelle fonction.

Pour le voir en couleur et dans le contexte, c'est par ici

Et pour dl directement la source c'est par là

Junky.
Pour la sécurité, sous linux, le principal soucis est l'interface chaise/clavier

+1 (1) -1 (0) Répondre


Sujets apparemment similaires…
Sujet Auteur Réponses Affichages Dernier message
  [C-AIDE] Fuzzer De Programme sakiir 2 212 16-05-2013, 11h21
Dernier message: Sh4dows
  [C] Programme Serveur/Client Creepy_p0ney 1 289 13-10-2012, 14h13
Dernier message: Creepy_p0ney

Atteindre :


Utilisateur(s) parcourant ce sujet : 1 visiteur(s)
N-PN
Accueil | Challenges | Tutoriels | Téléchargements | Forum | Retourner en haut