Partage

Authentification à 2 facteurs

16 novembre 2018 à 8:02:52

Bonjour à toute la communauté

J espère posté au bon endroit lol

Voici ma question : comment développer un script pour une authentification a 2 facteurs avec pgp ?

Explication : sur mon site web en création je souhaiterais que lorsque un membre se connecte il y est une demande d authentification avec pgp

P.S : je souhaite uniquement avec pgp car pour moi c est ce qu il se fait de mieux

Merci à tous

romantik

16 novembre 2018 à 8:35:12

Salut,

Bien, tout dépend la façon dont tu développes ton site web, c'est du PHP ? Avec un framework (WordPress, Dupal, autre...) ?

Par contre là il faut que tu m'expliques où est ton authentification à 2 facteurs Oo

GaetanMoineau a écrit:

P.S : je souhaite uniquement avec pgp car pour moi c est ce qu il se fait de mieux

Tu es sûr d'avoir les connaissances nécessaires pour affirmer une telle chose ?

Dream on, Dream on, Dream until your dream comes true

LilyKianii

16 novembre 2018 à 14:18:01

GaetanMoineau a écrit:

P.S : je souhaite uniquement avec pgp car pour moi c est ce qu il se fait de mieux

Pourquoi ? Parce qu'il y a plein de metadata en bonus ou parce que la clef publique est générée "aléatoirement" ?

Vous avez une raison de pas passer par du salted (+ pepper ?) hashing ?

romantik a écrit:

Par contre là il faut que tu m'expliques où est ton authentification à 2 facteurs Oo

Même question ? C'est quoi le second facteur ?

-
Edité par LilyKianii 16 novembre 2018 à 14:19:45

Loulou4545

16 novembre 2018 à 20:44:24

Non mon site sera codé de A à Z donc aucun wordpress ou framework

Je souhaite une authentification a 2 facteurs avec pgp lorsqu un utilisateur se connecte mais comment l écrire ?

LilyKianii

17 novembre 2018 à 1:30:33

GaetanMoineau a écrit:

Je souhaite une authentification a 2 facteurs avec pgp lorsqu un utilisateur se connecte mais comment l écrire ?

Arrête moi si je dit des bêtises (et je vais probablement en dire... au moins une quand même !) mais il y a 2 ou 3 trucs que je ne saisi pas...

Vous avez votre script côté serveur.
Donc avec

des metadata fixes
une clef fixe
une longueur de clef fixe
une durabilité dans le temps (non-expirable je suppose ?) de votre clef fixe.

1) Quel intérêt si tout ça ne varie pas ? L'utilisateur ne va rien rentrer de plus puisque c'est votre script qui va générer les clefs.

2) Admettons que vous obteniez vos clefs. Vous gardez la privée sur le serveur et vous partagez la publique. L'utilisateur, il en fait quoi ? Il chiffre quoi ?

3) Pour une raison mystique, l'utilisateur a chiffré "des données" et vous les recevez (par recommandé Amazon ou par la poste). Vous allez les comparer aux données existantes pour vérifier qu'elles correspondent bien.

Soit vous déchiffrez avec votre clef privée auquel cas ça signifie que vous stockez ses données personnelles en plain text dans votre base de données... Et ça, c'est un énoooorme problème niveau privacy policy.

Soit vous stockez de manière bien protégée (c'est-à-dire chiffré) les données de l'utilisateur dans votre base de données, auquel cas votre clef privée ne sert strictement à rien (et par extension, gpg et tout son fonctionnement de chiffrement asymétrique)

Il est tard et je suis fatiguée mais, vous êtes sûr que vous avez un plan de vol en tête ?

-
Edité par LilyKianii 17 novembre 2018 à 1:32:02

Loulou4545

17 novembre 2018 à 5:25:59

Sa sa y ressemble : <? php

// commence la session

session_start ();

en-tête ( ' X-GPGAuth-Version: 1.3.0 ' );

en-tête ( ' X-GPGAuth-Requested: false ' );

// Les en-têtes suivants décrivent au client où rechercher des ressources;

// À la façon dont cet exemple de page PHP fonctionne, les '? Page' sont juste pour

// différenciation des demandes lors du débogage / test - la seule page nécessitant

// une variable de chaîne de requête "? page" dans cet exemple est la page de déconnexion.

// Tous ces chemins doivent être relatifs à la racine du domaine. Rien d'autre ne

// être autorisé par le client.

header ( ' X-GPGAuth-Verify-URL: /tests/php/index.php?server_verify ' );

header ( ' X-GPGAuth-Login-URL: /tests/php/index.php?login ' );

header ( ' X-GPGAuth-Logout-URL: /tests/php/index.php?logout ' );

// Ceci pointe vers une clé publique blindée ACII (peut être plusieurs clés dans un fichier)

// utilisé pour permettre au client d'importer la clé publique du serveur.

en-tête ( ' X-GPGAuth-Pubkey-URL: /tests/gpgauth.org.pub ' );

$ CURRENT_PAGE = " Les tests d'authentification gpgAuth commencent " ;

$ PAGE_CONTENT = " Cette page annonce les en-têtes gpgAuth " ;

$ PAGE_CONTENT . = " Si l'extension est correctement installée, le logo gpgAuth devrait apparaître dans la barre d'adresse à l'extrême droite. " ;

$ PAGE_CONTENT . = " Si vous avez la clé signée associée à ce domaine, vous devriez voir un bouton \" Connexion \ " si vous cliquez sur le logo dans la barre d'adresse. Si vous n'avez pas signé la clé, vous verra que le serveur n’est pas vérifié, mais vous pouvez toujours vous connecter en utilisant le bouton \ " Se connecter quand même \" . Si vous voulez tester la connexion automatique, incluez simplement "" ? protected_content \ " à la fin de l’URL ( REMARQUE: la connexion automatique ne sera pas tentée si la clé du serveur n’est pas validée). " ;

// Variables de base de données

$ dbHost = " AVALIDHOST " ;

$ dbUser = " AVALIDUSER " ;

$ dbPass = " AVALIDPASS " ;

$ dbDatabase = " AVALIDDB " ;

// Cela devrait indiquer un chemin accessible par l'utilisateur auquel l'instance Web est

// courir sous. (www-data dans cet exemple)

putenv ( ' GNUPGHOME = / var / www / gpgauth.org / .gnupg ' );

// crée un nouvel objet GnuPG

$ gpg = new gnupg ();

// déclenche une exception en cas d'erreur

$ gpg -> seterrormode ( gnupg :: ERROR_EXCEPTION );

// Si l'utilisateur ne dispose pas d'une session validée, commencez le traitement.

if ( ! session_is_registered ( $ _SESSION [ ' keyid ' ]))) {

en-tête ( ' X-GPGAuth-Progress: stage0 ' );

en-tête ( ' X-GPGAuth-Authenticated: false ' );

// Cette variable contrôle la fonctionnalité "Connexion automatique";

// par défaut, cette page de test tentera automatiquement de se connecter

// sauf si l'utilisateur a atterri sur la page de déconnexion ou si le paramètre

// "no_auto_login" a été ajouté à la chaîne de requête.

$ request_gpgauth = " false " ;

foreach ( $ _GET as $ key => $ value ) {

if ( $ key == " protected_content " ) {

$ request_gpgauth = " true " ;

}

foreach ( $ _GET as $ key => $ value ) {

if ( $ key == " login " ) {

$ request_gpgauth = " true " ;

}

// Définit l'en-tête Auth-Requested sur ce que nous avons déterminé ci-dessus

header ( ' X-GPGAuth-Requested: ' . $ request_gpgauth );

// L'utilisateur a demandé au serveur de se vérifier

if ( $ _POST [ ' gpg_auth: server_verify_token ' ]) {

$ CURRENT_PAGE = " Test de vérification du serveur " ;

// spécifie le destinataire pour forcer le déchiffrement avec une clé donnée

$ recipient = " cti.localhost " ;

$ ciphertext = $ _POST [ ' gpg_auth: server_verify_token ' ];

essayer {

$ gpg -> adddecryptkey ( $ destinataire , ' ' );

$ texte brut = $ gpg -> décrypter ( $ ciphertext );

$ server_response = $ texte brut ;

en-tête ( ' X-GPGAuth-Verify-Response: ' . $ texte brut );

} catch ( Exception $ e ) {

en-tête ( ' X-GPGAuth-Error: true ' );

header ( ' X-GPGAuth-Verify-Response: ' . $ e -> getMessage ());

}

} elseif ( $ _POST [ ' gpg_auth: keyid ' ]) {

if ( ! $ _POST [ ' gpg_auth: user_token_result ' ]) {

en-tête ( ' X-GPGAuth-Progress: stage1 ' );

$ keyid = $ _POST [ ' gpg_auth: keyid ' ];

// spécifie le destinataire à chiffrer avec l'identifiant de clé fourni par l'utilisateur

$ recipient = $ keyid ;

// générer un jeton aléatoire à chiffrer

$ nonce = md5 ( uniqid ( mt_rand (), true ));

/ * Ensuite, nous encapsulons le jeton dans l'en-tête défini. L'en-tête sert à vérifier si

que quelqu'un ne transmet pas les données cryptées, il ne veut pas décrypter et

renvoyer. Les données cryptées par l'utilisateur à d'autres fins (confidentialité) ne sont pas

contenues dans cet en-tête.

Un en-tête valide est constitué de 4 sections,

1. gpgauthv {VERSION}

2. la longueur de la version décryptée du jeton

3. le jeton déchiffré

4. encore une fois, gpgauthv {VERSION}

* /

$ textext = " gpgauthv1.3.0 | " . strlen ( $ nonce ) . " | " . $ nonce . " | gpgauthv1.3.0 " ;

// tente de le chiffrer à l'utilisateur ou de renvoyer tout échec.

essayer {

$ gpg -> addencryptkey ( $ destinataire );

$ gpg -> addsignkey ( ' COMPLET key fingerprint ' , ' passphrase, s'il y a un ' )

$ ciphertext = $ gpg -> encryptsign ( $ texte brut );

$ server_response = $ token ;

// Cet en-tête contient le jeton crypté transmis au client.

en-tête ( ' X-GPGAuth-User-Auth-Token: ' . quotemeta ( urlencode ( $ ciphertext )));

} catch ( Exception $ e ) {

en-tête ( ' X-GPGAuth-Error: true ' );

en-tête ( ' X-GPGAuth-User-Auth-Token: ' . $ e -> getMessage ());

}

/ *

Connectez-vous à la base de données utilisateur et mettez à jour le user_token que nous avons généré pour cet utilisateur.

Lorsque le client retourne le jeton déchiffré, nous le testons pour une correspondance avec

ce champ de base de données.

* /

$ db = mysql_connect ( " $ dbHost " , " $ dbUser " , " $ dbPass " ) ou die ( " Erreur de connexion à la base de données. " );

mysql_select_db ( " $ dbDatabase " , $ db ) ou die ( " Impossible de sélectionner la base de données. " );

mysql_query ( " Utilisateurs UPDATE SET user_token = ' $ texte brut ' WHERE INSTR (empreinte digitale, ' $ keyid ' ) " );

mysql_close ( $ db );

} else {

/ * Nous avons reçu à la fois un identifiant de clé d’utilisateur et la version décryptée du jeton que nous avons reçu.

précédemment fourni au client, donc soit A.) Le client a vérifié la

identité de notre serveur, ou B.) Ils ont choisi de procéder de toute façon.

* /

en-tête ( ' X-GPGAuth-Progress: stage2 ' );

$ keyid = $ _POST [ ' gpg_auth: keyid ' ];

$ token = $ _POST [ ' gpg_auth: user_token_result ' ];

$ db = mysql_connect ( " $ dbHost " , " $ dbUser " , " $ dbPass " ) ou die ( " Erreur de connexion à la base de données. " );

mysql_select_db ( " $ dbDatabase " , $ db ) ou die ( " Impossible de sélectionner la base de données. " );

// Interroge la base de données pour voir si le jeton décrypté fourni par l'utilisateur correspond au jeton que nous avons

// généré pour cet utilisateur.

$ result = mysql_query ( " SELECT nom d'utilisateur, empreinte digitale, user_token FROM utilisateurs WHERE INSTR (empreinte digitale, ' $ keyid ' ) AND user_token = ' $ token ' " );

$ row = mysql_fetch_row ( $ result );

mysql_close ( $ db );

// Il y a une correspondance, l'utilisateur est connecté; temps pour configurer les variables

if ( $ row ) {

en-tête ( ' X-GPGAuth-Progress: complete ' );

en-tête ( ' X-GPGAuth-Authenticated: true ' );

// Ceci est une valeur d'en-tête facultative qui redirigera l'utilisateur vers

// la page spécifiée.

header ( ' X-GPGAuth-Refer: /tests/php/index.php ' );

session_start ();

// enregistrer la session

session_register ( $ keyid );

$ _SESSION [ ' keyid ' ] = $ keyid ;

$ CURRENT_PAGE = " Test de vérification utilisateur terminé " ;

$ PAGE_CONTENT = " Vous avez été authentifié avec succès avec gpgAuth. " ;

} else {

en-tête ( ' X-GPGAuth-Authenticated: false ' );

$ CURRENT_PAGE = " Le test de vérification de l'utilisateur a échoué " ;

$ PAGE_CONTENT = " Impossible de trouver une correspondance dans la base de données " ;

}

} else {

// l'utilisateur a déjà une session enregistrée

en-tête ( ' X-GPGAuth-Authenticated: true ' );

$ CURRENT_PAGE = " Test de vérification du serveur terminé " ;

$ PAGE_CONTENT = " Vous êtes actuellement connecté; Cliquez ici pour <a href= \" /tests/php/index.php?logout \"> déconnexion </a> " ;

// si le paramètre "logout" est détecté dans la chaîne de requête, nous devrions le faire.

foreach ( $ _GET as $ key => $ value ) {

if ( $ key == " logout " ) {

en-tête ( ' X-GPGAuth-Authenticated: false ' );

en-tête ( ' X-GPGAuth-Requested: false ' );

// la variable de session est enregistrée et l'utilisateur est prêt à se déconnecter

session_unset ();

session_destroy ();

$ CURRENT_PAGE = " Déconnexion du serveur terminée " ;

$ PAGE_CONTENT = " Vous avez été déconnecté avec succès; si vous souhaitez vous reconnecter , <a href= \" /tests/php/index.php?login \"> cliquez ici </a> " ;

}

? >

< html >

< tête >

< titre > <? echo $ CURRENT_PAGE ? > </ title >

</ head >

< body >

<? echo $ PAGE_CONTENT ? >

</ body >

</ html >

LilyKianii

17 novembre 2018 à 11:49:55

Loulou4545 a écrit:

Sa sa y ressemble

Non. Ca, ça ressemble à un code trouvé sur internet (et plutôt vieux avec ça) que vous avez traduit et recopié sans avoir vraiment essayé de comprendre.

Je vous donnerai pas de leçon sur le PHP, et je ne le lirais pas non plus en détails (parce que j'aime pas le PHP, que j'en ai quasi jamais fait et que je préfère encore passer ma journée à lister tout les CLSID de mon registre plutôt que d'en lire).

Mais les 3 (non, 4 ! avec celle du hashing) questions que je vous ai posé, vous pouvez y trouver une raison. Simplement je ne vois pas comment vous allez vous y prendre... Et je crois que votre vision du projet est encore plus floue que la mienne.

Si vous ne savez pas ce que vous voulez faire, laissez tomber de suite. Il me paraît important de vous prévenir pour éviter que vous y perdiez votre temps ou votre santé mentale à vous casser les dents sur quelque chose qui, potentiellement, va vous donner un résultat trop mauvais pour pouvoir être utilisé sur un vrai site.

En conclusion :

Mis à part que je suis persuadée qu'il y a des milliers de façons de faire beaucoup plus simples et plus secure que ce truc là, ce sera de toute façon impossible tant que vous n'aurez pas défini plus en détails la façon dont vous allez procéder.

Le repository github n'expliquant en rien la façon dont cela fonctionne, il fourni juste un petit sample PHP et un wiki expliquant "en bref" comment chiffrer et déchiffrer avec (rien de plus). Et encore une fois, je doute de l'utilitée de la chose.

Pas de détails sur la sécurité,

pas de notion de double facteur (la génération des clefs par nom / prénom / etc... c'est vous qui la faite, côté serveur, dans votre script. Et c'est validé par le wiki de l'auteur github)

Règle n°3 : Si vous n'avez pas d'intérêt à utiliser le chiffrement, utilisez le hashing.

Un plan de vol, c'est une vision claire, précise et globale de votre projet. Pas un bout de code. Prenez un papier, écrivez, dessinez, amusez-vous.

Finissez votre site avant de partir sur de l'authentification double vecteur, c'est pas la priorité. En attendant, un login/mot de passe fera très bien (mieux ?) l'affaire.

-
Edité par LilyKianii 17 novembre 2018 à 11:52:05

Loulou4545

17 novembre 2018 à 13:28:38

Ok J ai regarder sur github

Je suis juste perdu pour la programmation dans quel langage je dois programmer je vais vous donner une partie du tableau de bord ce qui permettra peut être que vous compreniez mieux : Comment programmer ce script d inscription :

- surnom

- mot de passe

- confirmation mot de passe

- défi sécurité captcha

- un second captcha pour prévenir des attaques ddos

Une fois l utilisateur inscrit : dans son tableau de bord il sera indiqué inscrivez votre clé publique pgp pour communiquer avec les différents vendeur du site ( je fais tout sa pour un niveau de sécurité car à l heure actuel il y a trop de probleme de confidentialité )

- enregistrer cle publique pgp

Après il y aura une demande pour confirmer que l utilisateur est bien le propriétaire de la clé privé pgp en signant une transaction avec sa clé privé : l utilisateur devra décrypter le message avec sa clé privé et coller dans un champ le message décrypter

LilyKianii

18 novembre 2018 à 1:17:09

0) Pourquoi Deux captcha ? Le premier suffit pas pour protéger d'un DDoS ? La connexion va devenir trop lourde pour les utilisateurs et au final, je serais étonnée que vous ayez d'autres clients qu'un botnet.

1) Donc vous allez générer un couple de clef pour chaque utilisateur ?

C'est tout de même assez volumineux.

3) Loulou4545 a écrit:

- enregistrer cle publique pgp

Comment ça l'enregistrer ?

4) Loulou4545 a écrit:

Après il y aura une demande pour confirmer que l utilisateur est bien le propriétaire de la clé privé pgp en signant une transaction avec sa clé privé : l utilisateur devra décrypter le message avec sa clé privé et coller dans un champ le message décrypter

Donc si je résume :

A l'inscription :

vous générez un couple de clef à partir des informations de l'utilisateur
Vous renvoyez la clef publique à l'utilisateur qui va la garder précieusement sur son PC sous forme d'un .pem, .crt ou qu'importe
Vous gardez en base de données chaque clef privée de chaque utilisateur

A la connexion :

L'utilisateur rentre son login et mot de passe
Valide le premier captcha
Valide le second captcha !
Rentre sa clef publique

A ce moment-là, ça doit déjà être le Nirvana

Le serveur récupère la clef publique (ah oui ?)
Le serveur chiffre "un truc" avec la clef privée (qu'il va chercher dans la base de données aux entrées liées à l'utilisateur "pas encore connecté")
L'utilisateur déchiffre le ciphertext obtenu
L'utilisateur rentre le résultat dans un champ
Le serveur vérifie qu'il obtient bien "un truc" et renvoie le résultat pour ENFIN laisser l'utilisateur dépenser son argent

La fin est brouillonne. Il y a des incohérences dans ce que vous voulez faire.

Et au delà de ça, c'est bien de se pencher sur la sécurité du site, très bien même ! Mais vous ne devez pas noyer l'utilisateur et rendre le site désagréable à utiliser pour autant. Les gens remarquent bien plus un site bien construit et facile à visiter qu'un site sécurisé. La sécurité, avant de rentrer leur code bancaire, ils ce sont pas une seule fois posé la question de si c'était sécurisé ou si "le cadenas en haut à gauche est vert donc ça va".