Effervecreanet

Pour un monde plus net

Les explications

Vous êtes avec votre open source favori et vous lancez la commande pianissimo que je raccourci par pp. Voici ce qui s'affiche sur votre écran:

Capture d'écran générateur aide

Vous vous inscrivez sur un site, et ce site vous demande de fournir un mot de passe qui vous permettra de vous authentifier avec succès. Pensons que vous avez plusieurs site sur lesquels vous vous inscrivez et vous aurez du mal à retenir tous vos mots de passe. Disons que cela devient vite un casse-tête. De retour à votre appareil vous testez le programme pp avec l'option -b qui va vous génerer un mot de passe avec des lettres minuscules. Vous recommencez la commande mais cette fois vous redirigez la sortie vers un fichier, que je nomme ici votre-site.mdp et la partie .mdp du fichier, son suffixe, signifiant (m)ot(d)e(p)asse. Et votre-site est un site dans lequel vous voulez vous authentifier ou créer un compte.

Capture d'écran générateur utilisation

Dans ce qui suit, est l'équivalent de ce que quasi tout le monde a fait au moins une fois, je veux dire 1) ouverture menu 2) copier la sélection. Ici, ces deux étapes sont effectuées avec la commande que vous pouvez voir ci-dessous. xclip est un programme qui a été écrit par quelqu'un d'autre depuis bien longtemps ou années quatre-vingt.

Capture d'écran xclip

Le contenu du fichier est maintenant copié dans la mémoire copier-coller. Pour terminer, il reste à coller la sélection dans l'entrée où il vous est demandé d'entrer votre mot de passe d'inscription ou de connection.

Capture d'écran coller mot de passe

A titre d'exemple, j'ai pris le site internet oui.sncf tout en prenant soin de flouter mon id. Le nom de mon fichier que je ne dit pas ici pourrait être oui-sncf.mdp . Après un clique sur le bouton "coller", les traditionnelles étoiles de recouvrement de signes apparaissent et vous n'avez plus qu'à cliquer sur connection.

L'astuce que je présente dans cet article, permet de pas se prendre la tête pour organiser ses comptes avec authentification par id/mdp.

Pour moi, l'identifiant est quasi tout le temps le même. Seuls les mots de passe changent selon les sites bien que c'est aussi faisable pour un pair id/mdp qui change tout le temps. Mais changer d'identifiant ou e-mail en plus du mot de passe sur tout les comptes internet, je pense que ce serait assez étrange. Tout comme avoir un seul mot de passe pour tous ses comptes internet faute de réussir à s'en souvenir...

Un autre cas d'utilisation

Capture d'écran puce SIM

Un autre cas d'utilisation pourrait être que vous recevez une carte SIM que vous avez commandé. Après réception, vous la déballez et la rentrez dans la fente SIM de votre téléphone. Vous rallumez votre smartphone et le smartphone vous demande de changer le code pin de la puce SIM. Ici, c'est un peu difficile de trouver un code à 4 chiffres. Les dates de naissances et autres anniversaires sont, je pense, déconseillés ou plus de notre époque. Ce code doit en effet être dur à trouver pour les autres et facile à retenir pour vous. Et si vous l'oubliez, vous devez être capable de le retrouver.

Capture d'écran génerer PIN pour SIM

Dans ce qui est ci-dessus, je dirige la sortie de pp vers le fichier code-sim.pin. Ce fichier va donc contenir 4 chiffres à la suite qui sont 8164 que j'affiche avec la commande cat. Le signe dollar ($) n'est pas à prendre en compte c'est un signe d'invite qui signifie que la console accepte des entrées. Et c'est la commande qui a réfléchit à ma place pour trouver les chiffres. Je garde le fichier sur un coin de mon ordi et je ne le retouche plus sauf au début si je n'arrive pas à me souvenir du code ou alors plus tard si j'ai oublié le code.

Ce logiciel est disponible pour windows sur cette page

Le programme dans son état de source est disponible dans l'encadré qui suit:

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <ctype.h>

#include <stdbool.h>

#include <sysexits.h>

#include <err.h>


#define STRING_LENGTH    0xff

#define PIN_LENGTH    4


#define PUNCTSET_MAX_INPUT 23

#define BACKSLASH '\\'


#define DIGIT          0001    /* At least one digit must be in the final

                 * computed password */


#define ALPHA_UPPER  0002    /* At least one upper-case letter must be in

                 * the final computed password */


#define ALPHA_LOWER  0004    /* At least one lower-case letter must be in

                 * the final computed password */


#define PUNCT        0010    /* At least one punctuation character must be

                 * in the final computed password */


#define PUNCTSET     0020    /* At least one user input punctuation

                 * character must be in the final computed

                 * password */


#define ALPHA           (ALPHA_UPPER | ALPHA_LOWER)    /* Alphabetic password

                             * with lower-case

                             * letters and

                             * upper-case letters */


#define ALPHA_NUM       (ALPHA | DIGIT)    /* Alphanumeric password with

                         * lower-case letters,

                         * upper-case letters and

                         * digits */


#define ALPHA_NUM_PUNCT   (ALPHA_NUM | PUNCT)    /* ASCII printable characters

                         * password, the strongest */


#define ALPHA_NUM_PUNCTSET (ALPHA | DIGIT | PUNCTSET)    /* ASCII printable

                             * characters password

                             * with spectified

                             * punctuation

                             * characters */


#define DEFAULT_PASSWORD_LENGTH 8    /* Default password are 7 characters

                     * and 1 nul-terminating '\0'

                     * character */


static int    password_length = DEFAULT_PASSWORD_LENGTH;


/* Prototyped functions */


unsigned int check_passwd(unsigned char *passwd, u_int8_t password_type,  char *punctset);

int gen_string(unsigned char *string, u_int8_t password_type, char *punctset);

void help(void);

int verify_input_set(char *optarg);


unsigned int

check_passwd(unsigned char *passwd, u_int8_t password_type, char *punctset)

{

    bool        alpha = false;

    bool        digit = false;

    bool        punct = false;

    int        ret = 0;


    switch (password_type) {

    case ALPHA_NUM:

        while (*passwd++) {

            if (isalpha(*passwd))

                alpha = true;

            if (isdigit(*passwd))

                digit = true;

        }

        if (alpha && digit)

            ret = 1;

        break;

    case ALPHA_NUM_PUNCT:

    case ALPHA_NUM_PUNCTSET:

        while (*passwd++) {

            if (isalpha(*passwd))

                alpha = true;

            if (isdigit(*passwd))

                digit = true;

            if (ispunct(*passwd))

                punct = true;

        }

        if (alpha && digit && punct)

            ret = 1;


        break;

    default:

        ret = 1;

        break;

    }


    return ret;

}


int

gen_string(unsigned char *string, u_int8_t password_type, char *punctset)

{

    uint32_t    i;

    u_char        c       [4];

    uint        h;

    unsigned char  *string_sav = string;


    while (strlen((const char *)string_sav) < password_length) {

        i = arc4random();


        c[0] = (unsigned char)i & 0x000000ff;

        i = i >> 8;

        c[1] = (unsigned char)i & 0x0000ff;

        i = i >> 8;

        c[2] = (unsigned char)i & 0x00ff;

        i = i >> 8;

        c[3] = (unsigned char)i & 0xff;


        for (h = 0; h < sizeof(c); h++) {

            switch (password_type) {

            case DIGIT:

                if (isdigit(c[h]))

                    *string++ = c[h];

                break;

            case ALPHA:

                if (isalpha(c[h]))

                    *string++ = c[h];

                break;

            case ALPHA_NUM:

        alphanum:    if (isalnum(c[h]))

                    *string++ = c[h];

                break;

            case ALPHA_LOWER:

                if (islower(c[h]))

                    *string++ = c[h];

                break;

            case ALPHA_NUM_PUNCT:

                if (isgraph(c[h]) && c[h] != BACKSLASH)

                    *string++ = c[h];

                break;

            case ALPHA_NUM_PUNCTSET:

                if (ispunct(c[h])) {

                    char           *p_ps = NULL;

                    for (p_ps = punctset; *p_ps; p_ps++) {

                        if (c[h] == *p_ps) {

                            *string++ = c[h];

                            break;

                        }

                    }

                }

                goto alphanum;

                break;

            default:

                break;

            }

        }

    }


    string = string_sav;


    /*

     * Here we terminate the password string, note that the real computed

     * password can be longer than the final password

     */

    *(string + password_length) = '\0';


    return 1;

}


/* Print help */

void

help(void)

{

    printf("usage: pp [-abd] [-c lenght] [-o file] [-s punctset]\n\t"

           "-a generate an alphabetic password\n\t"

           "-b generate a lower-case alphabetic password\n\t"

           "-d generate a digit password\n\t"

           "-e generate an alphanumeric password\n\t"

           "-p generate an alphanumeric password with punctuation\n\t"

        "-s generate a password with specified punctuation punctset\n");

    exit(EX_OK);

}


/*

 * We check that the input punctset is'nt too long or empty or doesn't

 * contain digit and alpha characters

 */

int

verify_input_set(char *optarg)

{

    int        len = 0;

    char           *pr1;


    len = strlen(optarg);


    /* Check that set isn't too long */

    if (len > PUNCTSET_MAX_INPUT) {

        printf("The specified punctset is longer (%i) than the number of accepted " \

               "ascii(7) punctuation characters (23)\n", len);

        return 0;

    } else if (len == 0) {

        /* Check that the set isn't empty */

        printf("The specified punctset is empty.\n");

        return 0;

    }

    /* Check that set is a punctation characters set */

    for (pr1 = optarg; *pr1; pr1++) {

        if (!ispunct(*pr1)) {

            printf("The specified punctset have an alphanumeric character (%c)\n", *pr1);

            return 0;

        }

    }


    return 1;

}


/* main function, entry point of the password provider program */

int

main(int argc, char *argv[])

{

    u_char         *password_string = NULL;

    char        ch;

    unsigned short    nbytes = 0;

    char           *outfile = NULL;

    int        len_punctset;

    int        len_output;

    u_int8_t    password_type;

    char           *punctset = NULL;

    FILE           *output;


    if (argc == 1)

        help();


    output = NULL;


    /*

     * Without options the password type is alpha-numeric with

     * punctation, the strongest password type.

     */

    password_type = ALPHA_NUM_PUNCT;


    while ((ch = getopt(argc, argv, "abdepo:c:s:")) != -1) {

        switch (ch) {

        case 'a':

            password_type = ALPHA;

            break;

        case 'b':

            password_type = ALPHA_LOWER;

            break;

        case 'c':

            nbytes = strtonum(optarg, PIN_LENGTH, STRING_LENGTH, NULL);


            if (nbytes == 0) {

                printf("The length value exceed bounds or is invalid.\n");

                exit(0);

            }

            password_length = nbytes;


            break;

        case 'd':

            password_type = DIGIT;

            break;

        case 'e':

            password_type = ALPHA_NUM;

            break;

        case 'o':

            len_output = strlen(optarg);

            if (!len_output || len_output > 254) {

                printf("The output file specified is null or exceed boundary.\n");

                exit(EX_USAGE);

            }

            outfile = optarg;

            break;

        case 'p':

            password_type = ALPHA_NUM_PUNCT;

            break;

        case 's':

            if (!verify_input_set(optarg))

                exit(EX_DATAERR);

            len_punctset = strlen(optarg);

            if ((punctset = malloc(len_punctset)) == NULL)

                err(EX_OSERR, NULL);

            strncpy(punctset, optarg, len_punctset);

            password_type = ALPHA_NUM_PUNCTSET;

            break;

        default:

            help();

            break;

        }

    }


    if (!outfile) {

        output = stdout;

    } else {

        /* Open the user specified output filename */

        if ((output = fopen(outfile, "w")) == NULL)

            err(EX_CANTCREAT, "%s", outfile);

    }


    if ((password_string = malloc(password_length)) == NULL)

        err(EX_OSERR, NULL);


    do {

        memset(password_string, 0, password_length);

        /*

         * We generate the password string according to specified

         * condition(s)

         */

        gen_string(password_string, password_type, punctset);

        /*

         * Until the password respect the condition(s), we retry

         */

    } while (check_passwd(password_string, password_type, punctset) != 1);


    /*

     * Output the final password into standart output or the user

     * specified file

     */

    if (fprintf(output, "%s", password_string) < 0)

        err(EX_IOERR, "%s", outfile);


    /* Close the user specified file */

    if (fclose(output) != 0)

        err(EX_OSERR, "%s", outfile);


    if (punctset != NULL)

        free(punctset);


    free(password_string);


    exit(EX_OK);

}

Début de la page
contact  mentions légales