[C] Programme de hashage

[Junky]

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!"


On est loin du programme de fou qui va faire tourner la planète a l'envers hein . 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

[Junky]

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.