230419_de-DE

liliconcom

Passwörter sicher speichern

Hat jemand eine sichere Möglichkeit, Passwörter zu speichern, damit Benutzer nicht jedes Mal ihr Passwort eingeben müssen?  

Ich möchte das Passwort nicht einfach als Klartext in einer Einstellungsdatei oder ähnlichem speichern.  

 

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

Betreff: Passwörter sicher speichern

Hier ist eine Version, die ein verfügbares Modul in Powershell verwendet. Vielleicht ist das eine 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'.

Betreff: Passwörter sicher speichern

Unter Windows I glauben Dieser Code könnte mit JSL und der Befehlszeile zur Interaktion mit dem Windows-Anmeldeinformationsmanager neu erstellt werden und möglicherweise falsch sein.Vielleicht werde ich das eines Tages in Angriff nehmen; Teile es hier, falls es jemand anderes zuerst herausfindet.

 

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

Von kkm hier:

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

Betreff: Passwörter sicher speichern

Du warst mehr als hilfreich.Danke schön.  

Betreff: Passwörter sicher speichernSie können versuchen, die Verschlüsselung mithilfe eines JMP-Add-Ins durchzuführen. Beachten Sie, dass der Versand einer Verschlüsselungsbibliothek rechtliche und exportbezogene Konsequenzen hat. Am besten schreiben Sie ein Add-In, das die nativen Verschlüsselungsbibliotheken aufruft, die sich bereits auf dem Host-Betriebssystem befinden, und führen es dann trotzdem über Ihr Rechtsteam aus.
Betreff: Passwörter sicher speichern

Ich mag das.Leider kann ich Kunden nicht dazu zwingen, Python zu installieren (einige haben ihren Benutzern die Installation ausdrücklich verboten).Aber ich habe die meisten davon überzeugt, den SQLite-ODBC-Treiber zu installieren, damit ich ihn vielleicht mit MD5 verwenden kann.

Ich müsste immer noch einen Weg finden, die Verschlüsselung durchzuführen.

Vielen Dank für die Hilfe, ich muss auf jeden Fall noch etwas recherchieren.  

Betreff: Passwörter sicher speichern

Ich nehme ein Route im Verschleierungsstil.Ich wandle Zeichen in Zahlen um und füge diese Zahlen dann in eine mathematische Formel ein, um eine „verschlüsselte“ Darstellung zu erzeugen. 

 

Ich verwende die Technik eher für Softwarelizenzcodes als für Benutzerkennwörter.Ich nehme also einen Produktnamen oder -code in Kombination mit Site-ID-Informationen und einem Ablaufdatum, erstelle eine numerische Darstellung und analysiere diese mithilfe einer komplexen mathematischen Formel: Die endgültige Ausgabe könnte etwa 1143932720966 lauten.

Betreff: Passwörter sicher speichern

Ich habe dies gefunden, als ich nach einer besseren Lösung für mich selbst gesucht habe.Für Skripte auf meinem eigenen Rechner rufe ich R auf und verwende die Schlüsselbundfunktion.Es verwendet den Schlüsselbund auf dem Mac, den Credential Store unter Windows und die Secret Service API unter Linux.Offensichtlich ist dies mit einem Overhead verbunden, es wäre schön, dies ohne R zu tun.Bei Interesse stelle ich ein JMP-Wunschlistenelement zum Erstellen dieser Funktionen im 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();

Betreff: Passwörter sicher speichern

Beispiel-Python-Skript zum Erstellen eines SQLite-Datenspeichers,

#! /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()

Betreff: Passwörter sicher speichern

Die sichere Speicherung von Anmeldeinformationen ist ein schwieriges Thema. Es ist wirklich schwierig, es richtig zu machen. Zumindest muss der Benutzer wahrscheinlich immer noch einmal pro Sitzung Anmeldeinformationen eingeben, um eine unbefugte Nutzung der Geheimnisse, die Sie schützen möchten, zu verhindern. Daher müssen Sie wahrscheinlich für jeden „Benutzer“ ein Passwort für seinen Anmeldeinformationsspeicher speichern. Dann benötigen Sie den Anmeldeinformationsspeicher selbst. Wie sicher ist genug? Benötigen Sie nur eine Verschleierung, beispielsweise eine einfache Substitutionsverschlüsselung wie rot13 (verschieben Sie die Buchstaben des Alphabets um 13, also m => z, a =>n), oder benötigen Sie etwas Stärkeres wie AES-Verschlüsselung oder Public-Key-Verschlüsselung? Sie können Ihren Datenspeicher mithilfe einer JMP-Tabelle, einer Textdatei oder einer Datenbanktabelle erstellen. JMP bietet ODBC-Unterstützung für die Datenbankkonnektivität. Bessere Prüfsummen und Verschlüsselungsunterstützung, entweder in JSL geschrieben oder über die Add-in-Funktion von JMP oder über die Python-Bridge aus gemeinsam genutzten Bibliotheken geladen.

 

Passwörter sichern,

Eine herkömmliche Möglichkeit, Passwörterdateien sicher aufzubewahren, ist die Verwendung einer Hash-Funktion. Eine Möglichkeit besteht darin, dass Funktionen wie MD5, die SHA-Familie, SHA1, SHA256 usw. alle Daten erfassen und einen Hash erstellen, der nicht rückgängig gemacht werden kann, um die Originaldaten anzuzeigen. Die Idee besteht darin, dass Sie die Daten, die Sie sichern möchten, nehmen und daraus einen Hash erstellen. Normalerweise werden solche Hashes mit einem SALT-Wert gemischt, einem Zufallswert, der mit den Passwortdaten gespeichert wird. Das Salt macht es weitaus kostspieliger, Nachschlagetabellen bekannter Daten zu Hash-Werten zu führen. Wenn der Benutzer dann das Passwort eingibt, hashen Sie den eingegebenen Wert und vergleichen den Hash mit dem gespeicherten Wert.Wenn sie übereinstimmen, ist == erfolgreich und das Passwort wird validiert. JMP stellt die MD5-Prüfsumme JSL zur Verfügung. Aus dem Skriptindex siehe Blob MD5(). Bitte beachten Sie, dass die Verwendung von MD5 für kryptografische Zwecke nicht sicher gegen moderne kryptografische Techniken ist, für ein niedriges Sicherheitsniveau jedoch dennoch in Ordnung sein sollte.

 

Anschließend können Sie den Hash verwenden oder ihn sogar mit zusätzlichen Daten kombinieren, um einen abgeleiteten Hash oder HMAC zu erstellen https://en.wikipedia.org/wiki/HMAC als Passwortschlüssel für Ihren geschützten Datenspeicher fungieren. Einige Datenbanken verfügen über eine Verschlüsselungsfunktion für Datenfelder, oder Sie müssen die Daten möglicherweise selbst verschlüsseln und in der Tabelle speichern.

 

Wenn Sie schließlich mehr Sicherheit benötigen, schauen Sie sich die Add-in-Funktionalität von JMP an, die gemeinsam genutzte Bibliotheken aufrufen kann. Dort können Sie ein so komplexes Datenverwaltungsschema implementieren, wie Sie möchten. Oder schauen Sie sich die Python-Schnittstelle von JMP an. Durch Aufrufen von Python-Paketen erhalten Sie Zugriff auf SQLite und bessere Prüfsummen und Verschlüsselungsmethoden.

 

Wie würde ich beim Aufbau eines solchen Datenspeichers vorgehen? Ich würde mich stark auf die Python-Schnittstelle von JMP verlassen. Die SQLite-Datenbankunterstützung ist in Python integriert und würde diese oder JMP-Tabellen für meinen Datenspeicher verwenden. Darüber hinaus ist Python im Allgemeinen mit Krypto-Unterstützung, Prüfsummen und Verschlüsselungsalgorithmen ausgestattet. Ich würde zunächst mit der Erstellung einer Passworttabelle beginnen, die einen Hash der Passwörter enthält. Erstellen Sie dann einen Datenspeicher als weitere Tabelle mit verschlüsselten Feldern. Wie sicher, wie kompliziert, wie viel Code und wie viele Tests ...

Betreff: Passwörter sicher speichern

Ich dachte mir, ich würde mal versuchen, dies zu durchbrechen, um zu sehen, ob jemand irgendwelche Ideen hat.  

Denn jetzt habe ich auch Probleme mit anderen Arten von Geheimnissen.Benutzerzugriffscodes und was nicht.  

Betreff: Passwörter sicher speichern

Das würde bedeuten, dass ich Zugriff auf die Passwörter aller Benutzer hätte.Definitiv nicht machbar.Und einem Benutzer zu sagen, er solle sein Passwort als verschlüsseltes Skript speichern, ist ebenfalls keine praktikable Option.Ich möchte wirklich eine Option „Angemeldet bleiben“, bei der ich jeden Benutzernamen/jedes Passwort speichern kann, das sie programmgesteuert eingeben, aber dieser Speicher ist sicher.  

Betreff: Passwörter sicher speichern

Erstellen Sie ein Skript, das die Passwörter in assoziativen Arrays, Listen usw. enthält. Speichern Sie das Skript dann als verschlüsseltes Skript.