230419_it-IT

liliconcom

salvare le password in modo sicuro

Qualcuno dispone di un modo sicuro per archiviare le password in modo che gli utenti non debbano inserirle ogni volta?  

Non voglio semplicemente memorizzare la password come testo semplice in un file delle preferenze o qualcosa del genere.  

 

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

Ri: salvare le password in modo sicuro

Ecco una versione che utilizza un modulo disponibile in PowerShell, forse è un'opzione?

 

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'.

Ri: salvare le password in modo sicuro

Su Windows I credere questo codice potrebbe essere ricreato con JSL e la riga di comando per interagire con il gestore delle credenziali di Windows potrebbe essere errata.Forse un giorno lo affronterò; condividendolo qui nel caso qualcun altro lo capisca prima.

 

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

Da kkm qui:

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

Ri: salvare le password in modo sicuro

Sei stato più che utile.Grazie.  

Re: salvare le password in modo sicuroPuoi provare a eseguire la crittografia utilizzando un componente aggiuntivo JMP. Tieni presente che la spedizione di una libreria di crittografia ha implicazioni legali e di esportazione. La soluzione migliore sarebbe scrivere un componente aggiuntivo che richiami le librerie di crittografia native già presenti sul sistema operativo host e quindi eseguirlo comunque presso il tuo team legale.
Ri: salvare le password in modo sicuro

Mi piace questa.Sfortunatamente non posso obbligare i clienti a installare Python (alcuni hanno esplicitamente vietato ai propri utenti di installarlo).Ma ho convinto la maggior parte a installare il driver sqlite odbc, quindi forse posso usarlo con MD5.

Dovrei ancora trovare un modo per crittografare.

Grazie per l'aiuto, ho sicuramente delle ricerche da fare.  

Ri: salvare le password in modo sicuro

Prendo un percorso in stile offuscamento.Converto i caratteri in numeri, quindi inserisco questi numeri in una formula matematica per generare una rappresentazione "crittografata". 

 

Tendo a utilizzare la tecnica più per i codici di licenza software piuttosto che per le password degli utenti.Quindi prenderò il nome o il codice di un prodotto combinato con le informazioni sull'ID del sito, oltre a una data di scadenza, costruirò una rappresentazione numerica e la analizzerò attraverso una formula matematica complessa: l'output finale potrebbe essere qualcosa come 1143932720966.

Ri: salvare le password in modo sicuro

Ho trovato questo mentre cercavo una soluzione migliore per me.Per gli script sul mio computer, chiamo R e utilizzo la funzione portachiavi.Utilizza Portachiavi su Mac, Credential Store su Windows e API Secret Service su Linux.Ovviamente questo comporta un sovraccarico, sarebbe bello farlo senza R.Se interessati metto a Voce della lista dei desideri JMP per creare queste funzioni nel 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();

Ri: salvare le password in modo sicuro

Script Python di esempio per creare un archivio dati 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()

Ri: salvare le password in modo sicuro

L’archiviazione sicura delle credenziali è una questione difficile. È davvero difficile fare la cosa giusta. Per lo meno probabilmente avrai ancora bisogno che l'utente inserisca una qualche forma di credenziali una volta per sessione, per impedire l'uso non autorizzato dei segreti che stai cercando di proteggere. Pertanto, per ciascun "utente" sarà probabilmente necessario memorizzare una password per il relativo archivio di credenziali. Quindi è necessario l'archivio credenziali stesso. Quanto è abbastanza sicuro? Hai solo bisogno di offuscamento, come un semplice codice di sostituzione come rot13 (sposta le lettere dell'alfabeto di 13 quindi m => z, a => n o hai bisogno di qualcosa di più forte come la crittografia AES o la crittografia a chiave pubblica? Puoi creare il tuo archivio dati utilizzando una tabella JMP, un file di testo o una tabella di database, JMP dispone del supporto ODBC per la connettività del database. Migliori checksum e supporto per la crittografia, scritti in JSL o caricati da librerie condivise tramite la funzionalità aggiuntiva di JMP o tramite il bridge Python.

 

Protezione delle password,

Un modo tradizionale per proteggere i file delle password è utilizzare una funzione hash. Un modo ha funzioni come MD5, la famiglia SHA, SHA1, SHA256, ... tutte prendono dati e creano un hash che non può essere invertito per rivelare i dati originali. L'idea è di prendere i dati che desideri proteggere e creare un hash dai dati. Di solito tali hash vengono mescolati con un valore SALT, un valore casuale che viene memorizzato con i dati della password. Il sale rende molto più costoso mantenere le tabelle di ricerca dei dati noti nei valori hash. Quindi, quando l'utente digita la password, si esegue l'hashing del valore immesso e si confronta l'hash con il valore memorizzato.Se corrispondono == successo e la password viene convalidata. JMP espone il checksum MD5 a JSL. Dall'indice degli script, vedere Blob MD5(). Tieni presente che l'uso di MD5 per scopi crittografici non è sicuro rispetto alle moderne tecniche crittografiche, ma per un livello di sicurezza basso dovrebbe comunque andare bene.

 

Quindi, puoi utilizzare l'hash o persino combinare l'hash con dati aggiuntivi per creare un hash derivato o HMAC https://en.wikipedia.org/wiki/HMAC per fungere da chiave password per l'archivio dati protetto. Alcuni database dispongono di funzionalità di crittografia per i campi dati oppure potrebbe essere necessario crittografare personalmente i dati e archiviarli nella tabella.

 

Infine, se hai bisogno di maggiore sicurezza, dai un'occhiata alle funzionalità aggiuntive di JMP che possono richiamare librerie condivise, lì potresti implementare uno schema di gestione dei dati complesso quanto desideri. Oppure guarda l'interfaccia Python di JMP, richiamare i pacchetti Python può darti accesso a sqlite e migliori checksum e metodi di crittografia.

 

Come potrei costruire un archivio dati di questo tipo? Mi appoggerei molto all'interfaccia Python di JMP. Il supporto del database SQLite è integrato in Python e utilizzerebbe quello o le tabelle JMP per il mio archivio dati. Inoltre Python è generalmente costruito con supporto per la crittografia, checksum e algoritmi di crittografia. Per prima cosa inizierei creando una tabella di tabelle delle password che abbia un hash delle password. Quindi crea un archivio dati come un'altra tabella con campi crittografati. Quanto è sicuro, quanto è complicato, è questione di quanto codice e quanti test...

Ri: salvare le password in modo sicuro

Ho pensato di provare a segnalarlo per vedere se qualcuno ha qualche idea.  

Perché ora ho problemi anche con altri tipi di segreti.Codici di accesso utente e cosa no.  

Ri: salvare le password in modo sicuro

Ciò comporterebbe che avessi accesso a tutte le password degli utenti.Decisamente non fattibile.E anche dire a un utente di salvare la propria password come script crittografato non è un'opzione praticabile.Voglio davvero un'opzione "ricordami" in cui posso archiviare qualsiasi nome utente/password digitati a livello di codice, ma tale archiviazione è sicura.  

Ri: salvare le password in modo sicuro

Crea uno script che contenga le password... negli array associativi o negli elenchi, ecc. Quindi salva lo script come script crittografato.