230419_fr-FR

liliconcom

enregistrer les mots de passe en toute sécurité

Quelqu'un a-t-il un moyen sécurisé de stocker les mots de passe afin que les utilisateurs n'aient pas à saisir leur mot de passe à chaque fois ?  

Je ne veux pas simplement stocker le mot de passe sous forme de texte brut dans un fichier de préférences ou quelque chose comme ça.  

 

Names default to here(1);
nw = new window("Login", 
 lineupbox(ncol(2), 
  textbox("Username"), teb_uid = texteditbox("Vincent", <<SET width=""></SET>

Re : sauvegarder les mots de passe en toute sécurité

Voici une version qui utilise un module disponible en PowerShell, c'est peut-être une option ?

 

Names default to here(1);

loadmodule = "
  if (!(Get-Module -ListAvailable -Name CredentialManager)) {
   Install-Module CredentialManager -force -Scope CurrentUser
  }
  ";


//Function to run command in powershell, strips trailing line breaks
RunPowershell = Function( {command},
 Regex(RunProgram(
  Executable( "powershell.exe" ),
  Options( {"/c", command } ),
  ReadFunction( "text" )
 ), "^(.*?)[\r\n]+$", "\1")
);


// Set password
SetPass = Function( {target,user,pass},
 RunPowershell(
  "$target = '" || target || "'
  $usr = '" || user || "'
  $pswd = '" || pass || "'
  " || loadmodule || "
  New-StoredCredential -Target $target -UserName $usr -Password $pswd"
 );
 1; //password is returned as free text, don't return the response
);

// Get password
GetPass = Function( {target},
 RunPowershell(
  "$target = '" || target || "'
  " || loadmodule || "
  $creds = Get-StoredCredential -Target $target

  $creds.GetNetworkCredential().Password"
 )
);

// Get username
GetUser = Function( {target},
 RunPowershell(
  "$target = '" || target || "'
  " || loadmodule || "
  $creds = Get-StoredCredential -Target $target

  $creds.GetNetworkCredential().UserName"
 )
);

// Set and retrieve credentials
SetPass("testcredential", "myusername3", "mypassword3");
GetPass("testcredential");
GetUser("testcredential");

//You can delete these test credentials using the 'windows credential store'.

Re : sauvegarder les mots de passe en toute sécurité

Sous Windows, je croire ce code pourrait être recréé avec JSL et la ligne de commande pour interagir avec le gestionnaire d'informations d'identification Windows pourrait être erronée.Peut-être qu'un jour je m'en chargerai ; partagez-le ici au cas où quelqu'un d'autre le découvrirait en premier.

 

<SPAN class="com">#include</SPAN> <SPAN class="str"><WINDOWS.H></WINDOWS.H></SPAN>
<SPAN class="com">#include</SPAN> <SPAN class="str"><WINCRED.H></WINCRED.H></SPAN>
<SPAN class="com">#include</SPAN> <SPAN class="str"><TCHAR.H></TCHAR.H></SPAN>
<SPAN class="com">#pragma</SPAN><SPAN class="pln"> hdrstop

</SPAN><SPAN class="kwd">void</SPAN><SPAN class="pln"> main </SPAN><SPAN class="pun">()</SPAN>
<SPAN class="pun">{</SPAN>
    <SPAN class="pun">{</SPAN> <SPAN class="com">//--- SAVE</SPAN>
        <SPAN class="kwd">char</SPAN><SPAN class="pun">*</SPAN><SPAN class="pln"> password </SPAN><SPAN class="pun">=</SPAN> <SPAN class="str">"brillant"</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        DWORD cbCreds </SPAN><SPAN class="pun">=</SPAN> <SPAN class="lit">1</SPAN> <SPAN class="pun">+</SPAN><SPAN class="pln"> strlen</SPAN><SPAN class="pun">(</SPAN><SPAN class="pln">password</SPAN><SPAN class="pun">);</SPAN><SPAN class="pln">
        CREDENTIALW cred </SPAN><SPAN class="pun">=</SPAN> <SPAN class="pun">{</SPAN><SPAN class="lit">0</SPAN><SPAN class="pun">};</SPAN><SPAN class="pln">        cred</SPAN><SPAN class="pun">.</SPAN><SPAN class="typ">Type</SPAN> <SPAN class="pun">=</SPAN><SPAN class="pln"> CRED_TYPE_GENERIC</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        cred</SPAN><SPAN class="pun">.</SPAN><SPAN class="typ">TargetName</SPAN> <SPAN class="pun">=</SPAN><SPAN class="pln"> L</SPAN><SPAN class="str">"FOO/account"</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        cred</SPAN><SPAN class="pun">.</SPAN><SPAN class="typ">CredentialBlobSize</SPAN> <SPAN class="pun">=</SPAN><SPAN class="pln"> cbCreds</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        cred</SPAN><SPAN class="pun">.</SPAN><SPAN class="typ">CredentialBlob</SPAN> <SPAN class="pun">=</SPAN> <SPAN class="pun">(</SPAN><SPAN class="pln">LPBYTE</SPAN><SPAN class="pun">)</SPAN><SPAN class="pln"> password</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        cred</SPAN><SPAN class="pun">.</SPAN><SPAN class="typ">Persist</SPAN> <SPAN class="pun">=</SPAN><SPAN class="pln"> CRED_PERSIST_LOCAL_MACHINE</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        cred</SPAN><SPAN class="pun">.</SPAN><SPAN class="typ">UserName</SPAN> <SPAN class="pun">=</SPAN><SPAN class="pln"> L</SPAN><SPAN class="str">"paula"</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">
        BOOL ok </SPAN><SPAN class="pun">=</SPAN> <SPAN class="pun">::</SPAN><SPAN class="typ">CredWriteW</SPAN> <SPAN class="pun">(&</SPAN><SPAN class="pln">cred</SPAN><SPAN class="pun">,</SPAN> <SPAN class="lit">0</SPAN><SPAN class="pun">);</SPAN><SPAN class="pln">        wprintf </SPAN><SPAN class="pun">(</SPAN><SPAN class="pln">L</SPAN><SPAN class="str">"CredWrite() - errno %d\n"</SPAN><SPAN class="pun">,</SPAN><SPAN class="pln"> ok </SPAN><SPAN class="pun">?</SPAN> <SPAN class="lit">0</SPAN> <SPAN class="pun">:</SPAN> <SPAN class="pun">::</SPAN><SPAN class="typ">GetLastError</SPAN><SPAN class="pun">());</SPAN>
        <SPAN class="kwd">if</SPAN> <SPAN class="pun">(!</SPAN><SPAN class="pln">ok</SPAN><SPAN class="pun">)</SPAN> <SPAN class="kwd">exit</SPAN><SPAN class="pun">(</SPAN><SPAN class="lit">1</SPAN><SPAN class="pun">);</SPAN>
    <SPAN class="pun">}</SPAN>
    <SPAN class="pun">{</SPAN> <SPAN class="com">//--- RETRIEVE</SPAN><SPAN class="pln">        PCREDENTIALW pcred</SPAN><SPAN class="pun">;</SPAN><SPAN class="pln">        BOOL ok </SPAN><SPAN class="pun">=</SPAN> <SPAN class="pun">::</SPAN><SPAN class="typ">CredReadW</SPAN> <SPAN class="pun">(</SPAN><SPAN class="pln">L</SPAN><SPAN class="str">"FOO/account"</SPAN><SPAN class="pun">,</SPAN><SPAN class="pln"> CRED_TYPE_GENERIC</SPAN><SPAN class="pun">,</SPAN> <SPAN class="lit">0</SPAN><SPAN class="pun">,</SPAN> <SPAN class="pun">&</SPAN><SPAN class="pln">pcred</SPAN><SPAN class="pun">);</SPAN><SPAN class="pln">        wprintf </SPAN><SPAN class="pun">(</SPAN><SPAN class="pln">L</SPAN><SPAN class="str">"CredRead() - errno %d\n"</SPAN><SPAN class="pun">,</SPAN><SPAN class="pln"> ok </SPAN><SPAN class="pun">?</SPAN> <SPAN class="lit">0</SPAN> <SPAN class="pun">:</SPAN> <SPAN class="pun">::</SPAN><SPAN class="typ">GetLastError</SPAN><SPAN class="pun">());</SPAN>
        <SPAN class="kwd">if</SPAN> <SPAN class="pun">(!</SPAN><SPAN class="pln">ok</SPAN><SPAN class="pun">)</SPAN> <SPAN class="kwd">exit</SPAN><SPAN class="pun">(</SPAN><SPAN class="lit">1</SPAN><SPAN class="pun">);</SPAN><SPAN class="pln">        wprintf </SPAN><SPAN class="pun">(</SPAN><SPAN class="pln">L</SPAN><SPAN class="str">"Read username = '%s', password='%S' (%d bytes)\n"</SPAN><SPAN class="pun">,</SPAN><SPAN class="pln"> 
                 pcred</SPAN><SPAN class="pun">-></SPAN><SPAN class="typ">UserName</SPAN><SPAN class="pun">,</SPAN> <SPAN class="pun">(</SPAN><SPAN class="kwd">char</SPAN><SPAN class="pun">*)</SPAN><SPAN class="pln">pcred</SPAN><SPAN class="pun">-></SPAN><SPAN class="typ">CredentialBlob</SPAN><SPAN class="pun">,</SPAN><SPAN class="pln"> pcred</SPAN><SPAN class="pun">-></SPAN><SPAN class="typ">CredentialBlobSize</SPAN><SPAN class="pun">);</SPAN>
        <SPAN class="com">// must free memory allocated by CredRead()!</SPAN>
        <SPAN class="pun">::</SPAN><SPAN class="typ">CredFree</SPAN> <SPAN class="pun">(</SPAN><SPAN class="pln">pcred</SPAN><SPAN class="pun">);</SPAN>
    <SPAN class="pun">}</SPAN>
<SPAN class="pun">}</SPAN>

De kkm ici :

https://stackoverflow.com/questions/9221245/how-do-i-store-and-retrieve-credentials-from-the-windows-vault-credential-manage

Re : sauvegarder les mots de passe en toute sécurité

Vous avez été plus que utile.Merci.  

Re : sauvegarder les mots de passe en toute sécuritéVous pouvez envisager d'effectuer le chiffrement à l'aide d'un complément JMP. Comprenez que l’envoi d’une bibliothèque de chiffrement a des ramifications juridiques et d’exportation. Votre meilleur pari serait d'écrire un complément qui appelle les bibliothèques de chiffrement natives déjà présentes sur le système d'exploitation hôte, puis de l'exécuter auprès de votre équipe juridique.
Re : sauvegarder les mots de passe en toute sécurité

J'aime ça.Je ne peux malheureusement pas forcer les clients à installer Python (certains ont explicitement interdit à leurs utilisateurs de l'installer).Mais j'ai convaincu la plupart d'installer le pilote odbc sqlite afin que je puisse peut-être l'utiliser avec MD5.

Il me faudrait encore trouver un moyen de chiffrer.

Merci pour votre aide, j'ai certainement des recherches à faire.  

Re : sauvegarder les mots de passe en toute sécurité

je prends un itinéraire de style obscurcissement.Je convertis des caractères en nombres, puis j'intègre ces nombres dans une formule mathématique pour générer une représentation « cryptée ». 

 

J'ai tendance à utiliser davantage cette technique pour les codes de licence de logiciels plutôt que pour les mots de passe des utilisateurs.Je vais donc prendre un nom ou un code de produit combiné avec des informations d'identification du site, ainsi qu'une date d'expiration, créer une représentation numérique et l'analyser à l'aide d'une formule mathématique complexe : le résultat final pourrait être quelque chose comme 1143932720966.

Re : sauvegarder les mots de passe en toute sécurité

J'ai trouvé cela en cherchant une meilleure solution pour moi-même.Pour les scripts sur ma propre machine, j'appelle R et j'utilise la fonction keyring.Il utilise le trousseau sur Mac, le Credential Store sous Windows et l'API Secret Service sous Linux.Évidemment, cela entraîne des frais généraux, ce serait bien de le faire sans R.Si intéressé, je mets un Élément de la liste de souhaits JMP pour créer ces fonctions dans JMP.

 

https://github.com/r-lib/keyring

 

R Init();
R Submit(
 "library(keyring)
 pw <- keyring::key_get(\!"DomainAccount\!", \!"username\!")"
);
pw = R Get("pw");
R Term();

Re : sauvegarder les mots de passe en toute sécurité

Exemple de script Python pour créer un magasin de données SQLite,

#! /usr/bin/env/python3
#
# Author: Paul Nelson - JMP Statistical Discovery, From SAS
# Date: 9 Mar 2020
#
# Description: This sample shows the python code using sqlite to create a data data store
# for saving passwords, credentails...  While Python has hash functions, the standard library
# does not include ciphers.  For purposes of this sample I used lzma compression to 'encode' and
# decompression to 'decrypt'  For use from JSL, I would turn this into a python module and then
# import 'my_dataStore_api' to cut down code in the JSL string.
#
# sample python program using sqlite to create a secure store for passwords and
# key, value data storage.
#
# While Python contains hash functions, does not include encryption primitives in the standard library.
# an example using PyCrypto can be found
# https://stackoverflow.com/questions/12524994/encrypt-decrypt-using-pycrypto-aes-265
# however pycrypto has no been updated since 2014... https://github.com/dlitz/pycrypto
#
# pyca/cryptography - https://cryptography.io/    https://github.com/pyca/cryptography
# seems to be currently maintained.
#
# Don't create your own encryption! The above packages or, openssl, or many other providers are
# better than writing your own.
#
# It is an exercise left to the reader to replace the code using lzma compression with real encrypt
# and decrypt code.  
# 
# 
import sqlite3
import hashlib
import os
from pathlib import Path
import lzma

# Salt should be random quantity, get from OS entropy source
salt = os.urandom(16);
mypasswd = b'JMP in a dried up lake'
dk = hashlib.pbkdf2_hmac('sha256', mypasswd, salt, 1000)
# dk.hex()  will be the actual hashed password saved to db
# but the binary dk, will be what we use as the encryption key
# dkhex = dk.hex()
# binDk = bytes.fromhex(dkhex)
# 

# Path to my credential store , my home directory + AppData
data_path = str(Path.home()) + '/AppData/'
filename = 'dataStore'

# Create directory if it doesn't exist
os.makedirs(data_path, exist_ok=True)

# will create database if it doesn't exist
db = sqlite3.connect(data_path + filename + '.db')

# my username
me = 'jmpuser'

# create our password table storing hashed passwords
db.execute('CREATE TABLE IF NOT EXISTS passwd (uid INTEGER PRIMARY KEY, name TEXT, salt TEXT, key TEXT)')

# should check to see if user is in database and only insert if not found
# exercise left to the reader
db.execute("INSERT INTO passwd (name, salt, key) VALUES( ?,?,? ) ", (me, salt.hex(), dk.hex()) )
db.commit()
print('******* passwd database *******')
for row in db.execute('SELECT * from passwd'):
    print(row)
print('*******************************')    

# create our credentials table which will store the name of the credential, and its value
db.execute('CREATE TABLE IF NOT EXISTS credentials (id INTEGER PRIMARY KEY, uid INTEGER, key TEXT, value TEXT)')

# first we need to have validated that user gave propper password, and we authenticated against passwd
# table assuming user is authenticated

# should check to see if user is in database and only insert if not found, potentially update if found
# exercise left to the reader.

# my user id in this scheme 
id = 0

#The value data I'm going to store into the database
myson1 = """
{
   user: paul
   magic_key: JMP Rocks!
}"""

myson2 = """
{
   user: paul
   magic_key: supercalifragilisticexpialidocious
}"""

# 'encrypt' my data
lvalue = lzma.compress( myson2.encode() )
lvalue2 = lzma.compress( myson1.encode() )

# you could encrypt the 'key' as well as the value if you really want security
db.execute("INSERT INTO credentials (uid, key, value) VALUES( ?,?,? ) ", (id, 'JMPCommunity', lvalue.hex()) )
db.execute("INSERT INTO credentials (uid, key, value) VALUES( ?,?,? ) ", (id, 'WDW', lvalue2.hex()) )
db.commit()
print('******* credentials database *******')
for row in db.execute('SELECT * from credentials WHERE uid=?', (id,) ):
    print(row)
    value = bytes.fromhex(row[3])
    print(lzma.decompress(value).decode())
print('************************************')
db.close()

Re : sauvegarder les mots de passe en toute sécurité

Le stockage sécurisé des informations d’identification est une question difficile. C'est vraiment difficile de bien faire. À tout le moins, vous aurez probablement toujours besoin que l'utilisateur saisisse une certaine forme d'informations d'identification une fois par session, pour empêcher toute utilisation non autorisée des secrets que vous essayez de protéger. Ainsi, pour chaque « utilisateur », vous devrez probablement stocker un mot de passe pour son magasin d’informations d’identification. Ensuite, vous avez besoin du magasin d’informations d’identification lui-même. Dans quelle mesure la sécurité est-elle suffisante ? Avez-vous simplement besoin d'un obscurcissement, comme un simple chiffre de substitution comme rot13 (décalez les lettres de l'alphabet de 13 donc m => z, a =>n ou avez-vous besoin de quelque chose de plus fort comme le cryptage AES ou le cryptage par clé publique ? Vous pouvez créer votre magasin de données à l'aide d'une table JMP, d'un fichier texte ou d'une table de base de données, JMP prend en charge ODBC pour la connectivité de la base de données. Meilleures sommes de contrôle et prise en charge du chiffrement, soit écrites en JSL, soit chargées à partir de bibliothèques partagées via la fonctionnalité complémentaire de JMP ou via le pont Python.

 

Sécurisation des mots de passe,

Une manière traditionnelle de sécuriser les fichiers de mots de passe consiste à utiliser une fonction de hachage. One Way comporte des fonctions telles que MD5, la famille SHA, SHA1, SHA256, ... toutes prennent des données et créent un hachage qui ne peut pas être inversé pour révéler les données d'origine. L'idée est que vous prenez les données que vous souhaitez sécuriser et créez un hachage à partir des données. Habituellement, ces hachages sont mélangés avec une valeur SALT, une valeur aléatoire stockée avec les données du mot de passe. Le sel rend beaucoup plus coûteux la conservation des tables de recherche de données connues pour hacher les valeurs. Ensuite, lorsque l'utilisateur saisit le mot de passe, vous hachez la valeur saisie et comparez le hachage à la valeur stockée.S'ils correspondent == succès et le mot de passe est validé. JMP expose la somme de contrôle MD5 à JSL. À partir de l’index des scripts, consultez Blob MD5(). Veuillez noter que l'utilisation de MD5 à des fins cryptographiques n'est pas sécurisée par rapport aux techniques cryptographiques modernes, mais pour un niveau de sécurité de bas niveau, cela devrait quand même convenir.

 

Ensuite, vous pouvez utiliser le hachage ou même combiner le hachage avec des données supplémentaires pour créer un hachage dérivé ou HMAC. https://en.wikipedia.org/wiki/HMAC pour agir comme clé de mot de passe pour votre magasin de données protégé. Certaines bases de données disposent d'une fonctionnalité de chiffrement pour les champs de données, ou vous devrez peut-être chiffrer les données vous-même et les stocker dans la table.

 

Enfin, si vous avez besoin d'une plus grande sécurité, consultez la fonctionnalité complémentaire de JMP qui peut appeler des bibliothèques partagées. Vous pourrez y implémenter un schéma de gestion de données aussi complexe que vous le souhaitez. Ou consultez l'interface Python de JMP, l'appel aux packages Python peut vous donner accès à SQLite, ainsi qu'à de meilleures sommes de contrôle et méthodes de chiffrement.

 

Comment pourrais-je créer un tel magasin de données ? Je m'appuierais fortement sur l'interface Python de JMP. La prise en charge de la base de données SQLite est intégrée à Python et utiliserait celle-ci ou les tables JMP pour mon magasin de données. De plus, Python est généralement construit avec la prise en charge du cryptage, des sommes de contrôle et des algorithmes de cryptage. Je commencerais d’abord par créer une table de mots de passe contenant un hachage des mots de passe. Créez ensuite un magasin de données sous la forme d'une autre table comportant des champs chiffrés. À quel point c'est sécurisé, à quel point c'est compliqué, une question de quantité de code et de test...

Re : sauvegarder les mots de passe en toute sécurité

J'ai pensé que j'essaierais de résoudre ce problème pour voir si quelqu'un a des idées.  

Parce que maintenant j'ai aussi des problèmes avec d'autres types de secrets.Codes d'accès utilisateur et ainsi de suite.  

Re : sauvegarder les mots de passe en toute sécurité

Cela impliquerait que j'aie accès aux mots de passe de tous les utilisateurs.Certainement pas faisable.Et demander à un utilisateur d’enregistrer son mot de passe sous forme de script crypté n’est pas non plus une option viable.Je veux vraiment une option « se souvenir de moi » où je peux stocker le nom d'utilisateur/mot de passe qu'ils tapent par programme, mais ce stockage est sécurisé.  

Re : sauvegarder les mots de passe en toute sécurité

Créez un script contenant les mots de passe ....... dans des tableaux associatifs, ou dans des listes, etc. Enregistrez ensuite ce script en tant que script chiffré.