Zufällige Passwörter generieren
https://stackoverflow.com/questions/54991
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wenn ein Benutzer auf unserer Website sein Passwort verliert und zur Seite „Passwort verloren“ wechselt, müssen wir ihm ein neues temporäres Passwort geben.Es macht mir nichts aus, wie zufällig das ist, oder wenn es allen „erforderlichen“ Regeln für sichere Passwörter entspricht, möchte ich ihnen nur ein Passwort geben, das sie später ändern können.
Die Anwendung ist eine in C# geschriebene Webanwendung.Also dachte ich darüber nach, gemein zu sein und den einfachen Weg zu wählen, einen Teil eines Guids zu verwenden.d.h.
Guid.NewGuid().ToString("d").Substring(1,8)
Vorschläge?Gedanken?
Andere Tipps
public string CreatePassword(int length)
{
const string valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
StringBuilder res = new StringBuilder();
Random rnd = new Random();
while (0 < length--)
{
res.Append(valid[rnd.Next(valid.Length)]);
}
return res.ToString();
}
Das hat einen guten Vorteil der Lage zu sein, aus einer Liste der verfügbaren Zeichen für das generierte Passwort wählen (zum Beispiel nur Ziffern, nur Großbuchstaben oder nur Klein etc.)
Die Hauptziele meines Codes sind:
- Die Verteilung der Saiten ist fast einheitlich (kümmern sich nicht um geringfügige Abweichungen, solange sie klein)
- Es gibt mehr als ein paar Milliarden Strings für jedes Argument gesetzt. eine 8-Zeichenkette zu erzeugen (~ 47 Bit Entropie) ist bedeutungslos, wenn Ihre PRNG erzeugt nur 2 Milliarden (31 Bit Entropie) unterschiedliche Werte.
- Es ist sicher, da ich die Leute erwarten, dass diese oder andere Sicherheitstoken für Passwörter verwenden.
Die erste Eigenschaft, indem sie einen 64-Bit-Wert erreicht wird, Modulo der Alphabetgröße. Für kleine Alphabete (wie die 62 Zeichen von der Frage) führt diese Vorspannung zu vernachlässigen. Die zweite und dritte Eigenschaft unter Verwendung RNGCryptoServiceProvider anstelle von System.Random .
using System;
using System.Security.Cryptography;
public static string GetRandomAlphanumericString(int length)
{
const string alphanumericCharacters =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
"abcdefghijklmnopqrstuvwxyz" +
"0123456789";
return GetRandomString(length, alphanumericCharacters);
}
public static string GetRandomString(int length, IEnumerable<char> characterSet)
{
if (length < 0)
throw new ArgumentException("length must not be negative", "length");
if (length > int.MaxValue / 8) // 250 million chars ought to be enough for anybody
throw new ArgumentException("length is too big", "length");
if (characterSet == null)
throw new ArgumentNullException("characterSet");
var characterArray = characterSet.Distinct().ToArray();
if (characterArray.Length == 0)
throw new ArgumentException("characterSet must not be empty", "characterSet");
var bytes = new byte[length * 8];
new RNGCryptoServiceProvider().GetBytes(bytes);
var result = new char[length];
for (int i = 0; i < length; i++)
{
ulong value = BitConverter.ToUInt64(bytes, i * 8);
result[i] = characterArray[value % (uint)characterArray.Length];
}
return new string(result);
}
(Dies ist eine Kopie meiner Antwort auf Wie kann ich erzeugen zufällige 8 Zeichen, alphanumerische Zeichenfolgen in C #? )
Hier ist, wie ich erzeugen zufällige Token:
public string GenerateToken(int length)
{
RNGCryptoServiceProvider cryptRNG = new RNGCryptoServiceProvider();
byte[] tokenBuffer = new byte[length];
cryptRNG.GetBytes(tokenBuffer);
return Convert.ToBase64String(tokenBuffer);
}
Es wurde darauf hingewiesen, dass, da dies eine Basis-64-String zurückgibt, die Ausgabelänge ist immer ein Vielfaches von 4, mit dem zusätzlichen Platz = als Füllzeichen verwendet wird. Der length Parameter die Länge des Byte-Puffer gibt, nicht die Ausgabezeichenfolge (und ist daher vielleicht nicht der beste Name für diesen Parameter, jetzt denke ich darüber). Dies steuert, wie viele Bytes von Entropie das Passwort haben. Da jedoch base-64 ein 4-Zeichenblock verwendet jeweils 3 Byte Eingangs zu kodieren, falls sie eine Länge stellen, die nicht ein Vielfaches von 3 ist, wird es etwas mehr „Raum“ sein, und es wird = verwenden zu füllen die zusätzliche.
Wenn Sie nicht wie mit Base64-Strings aus irgendeinem Grunde, können Sie den Convert.ToBase64String() Anruf entweder mit einer Umwandlung in regelmäßigem String oder mit einem der Encoding Methoden ersetzen; z.B. Encoding.UTF8.GetString(tokenBuffer) - so stellen Sie sicher, dass Sie einen Zeichensatz auswählen, die das gesamte Spektrum des Wertes kommt aus dem RNG darstellen kann, und das erzeugt Zeichen, die mit kompatibel sind da, wo Sie senden oder diese zu speichern. Verwendung von Unicode zum Beispiel neigt dazu, eine Menge von chinesischen Zeichen zu geben. Mit Base-64 garantiert einen weitgehend kompatiblen Satz von Zeichen, und die Eigenschaften eines solchen String sollte es weniger nicht machen jede sichern, solange Sie einen anständigen Hashing-Algorithmus verwenden.
Das ist viel größer, aber ich denke, es ist ein wenig umfassender aussieht: http://www.obviex.com/Samples/Password.aspx
///////////////////////////////////////////////////////////////////////////////
// SAMPLE: Generates random password, which complies with the strong password
// rules and does not contain ambiguous characters.
//
// To run this sample, create a new Visual C# project using the Console
// Application template and replace the contents of the Class1.cs file with
// the code below.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
//
// Copyright (C) 2004 Obviex(TM). All rights reserved.
//
using System;
using System.Security.Cryptography;
/// <summary>
/// This class can generate random passwords, which do not include ambiguous
/// characters, such as I, l, and 1. The generated password will be made of
/// 7-bit ASCII symbols. Every four characters will include one lower case
/// character, one upper case character, one number, and one special symbol
/// (such as '%') in a random order. The password will always start with an
/// alpha-numeric character; it will not start with a special symbol (we do
/// this because some back-end systems do not like certain special
/// characters in the first position).
/// </summary>
public class RandomPassword
{
// Define default min and max password lengths.
private static int DEFAULT_MIN_PASSWORD_LENGTH = 8;
private static int DEFAULT_MAX_PASSWORD_LENGTH = 10;
// Define supported password characters divided into groups.
// You can add (or remove) characters to (from) these groups.
private static string PASSWORD_CHARS_LCASE = "abcdefgijkmnopqrstwxyz";
private static string PASSWORD_CHARS_UCASE = "ABCDEFGHJKLMNPQRSTWXYZ";
private static string PASSWORD_CHARS_NUMERIC= "23456789";
private static string PASSWORD_CHARS_SPECIAL= "*$-+?_&=!%{}/";
/// <summary>
/// Generates a random password.
/// </summary>
/// <returns>
/// Randomly generated password.
/// </returns>
/// <remarks>
/// The length of the generated password will be determined at
/// random. It will be no shorter than the minimum default and
/// no longer than maximum default.
/// </remarks>
public static string Generate()
{
return Generate(DEFAULT_MIN_PASSWORD_LENGTH,
DEFAULT_MAX_PASSWORD_LENGTH);
}
/// <summary>
/// Generates a random password of the exact length.
/// </summary>
/// <param name="length">
/// Exact password length.
/// </param>
/// <returns>
/// Randomly generated password.
/// </returns>
public static string Generate(int length)
{
return Generate(length, length);
}
/// <summary>
/// Generates a random password.
/// </summary>
/// <param name="minLength">
/// Minimum password length.
/// </param>
/// <param name="maxLength">
/// Maximum password length.
/// </param>
/// <returns>
/// Randomly generated password.
/// </returns>
/// <remarks>
/// The length of the generated password will be determined at
/// random and it will fall with the range determined by the
/// function parameters.
/// </remarks>
public static string Generate(int minLength,
int maxLength)
{
// Make sure that input parameters are valid.
if (minLength <= 0 || maxLength <= 0 || minLength > maxLength)
return null;
// Create a local array containing supported password characters
// grouped by types. You can remove character groups from this
// array, but doing so will weaken the password strength.
char[][] charGroups = new char[][]
{
PASSWORD_CHARS_LCASE.ToCharArray(),
PASSWORD_CHARS_UCASE.ToCharArray(),
PASSWORD_CHARS_NUMERIC.ToCharArray(),
PASSWORD_CHARS_SPECIAL.ToCharArray()
};
// Use this array to track the number of unused characters in each
// character group.
int[] charsLeftInGroup = new int[charGroups.Length];
// Initially, all characters in each group are not used.
for (int i=0; i<charsLeftInGroup.Length; i++)
charsLeftInGroup[i] = charGroups[i].Length;
// Use this array to track (iterate through) unused character groups.
int[] leftGroupsOrder = new int[charGroups.Length];
// Initially, all character groups are not used.
for (int i=0; i<leftGroupsOrder.Length; i++)
leftGroupsOrder[i] = i;
// Because we cannot use the default randomizer, which is based on the
// current time (it will produce the same "random" number within a
// second), we will use a random number generator to seed the
// randomizer.
// Use a 4-byte array to fill it with random bytes and convert it then
// to an integer value.
byte[] randomBytes = new byte[4];
// Generate 4 random bytes.
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(randomBytes);
// Convert 4 bytes into a 32-bit integer value.
int seed = BitConverter.ToInt32(randomBytes, 0);
// Now, this is real randomization.
Random random = new Random(seed);
// This array will hold password characters.
char[] password = null;
// Allocate appropriate memory for the password.
if (minLength < maxLength)
password = new char[random.Next(minLength, maxLength+1)];
else
password = new char[minLength];
// Index of the next character to be added to password.
int nextCharIdx;
// Index of the next character group to be processed.
int nextGroupIdx;
// Index which will be used to track not processed character groups.
int nextLeftGroupsOrderIdx;
// Index of the last non-processed character in a group.
int lastCharIdx;
// Index of the last non-processed group.
int lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
// Generate password characters one at a time.
for (int i=0; i<password.Length; i++)
{
// If only one character group remained unprocessed, process it;
// otherwise, pick a random character group from the unprocessed
// group list. To allow a special character to appear in the
// first position, increment the second parameter of the Next
// function call by one, i.e. lastLeftGroupsOrderIdx + 1.
if (lastLeftGroupsOrderIdx == 0)
nextLeftGroupsOrderIdx = 0;
else
nextLeftGroupsOrderIdx = random.Next(0,
lastLeftGroupsOrderIdx);
// Get the actual index of the character group, from which we will
// pick the next character.
nextGroupIdx = leftGroupsOrder[nextLeftGroupsOrderIdx];
// Get the index of the last unprocessed characters in this group.
lastCharIdx = charsLeftInGroup[nextGroupIdx] - 1;
// If only one unprocessed character is left, pick it; otherwise,
// get a random character from the unused character list.
if (lastCharIdx == 0)
nextCharIdx = 0;
else
nextCharIdx = random.Next(0, lastCharIdx+1);
// Add this character to the password.
password[i] = charGroups[nextGroupIdx][nextCharIdx];
// If we processed the last character in this group, start over.
if (lastCharIdx == 0)
charsLeftInGroup[nextGroupIdx] =
charGroups[nextGroupIdx].Length;
// There are more unprocessed characters left.
else
{
// Swap processed character with the last unprocessed character
// so that we don't pick it until we process all characters in
// this group.
if (lastCharIdx != nextCharIdx)
{
char temp = charGroups[nextGroupIdx][lastCharIdx];
charGroups[nextGroupIdx][lastCharIdx] =
charGroups[nextGroupIdx][nextCharIdx];
charGroups[nextGroupIdx][nextCharIdx] = temp;
}
// Decrement the number of unprocessed characters in
// this group.
charsLeftInGroup[nextGroupIdx]--;
}
// If we processed the last group, start all over.
if (lastLeftGroupsOrderIdx == 0)
lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
// There are more unprocessed groups left.
else
{
// Swap processed group with the last unprocessed group
// so that we don't pick it until we process all groups.
if (lastLeftGroupsOrderIdx != nextLeftGroupsOrderIdx)
{
int temp = leftGroupsOrder[lastLeftGroupsOrderIdx];
leftGroupsOrder[lastLeftGroupsOrderIdx] =
leftGroupsOrder[nextLeftGroupsOrderIdx];
leftGroupsOrder[nextLeftGroupsOrderIdx] = temp;
}
// Decrement the number of unprocessed groups.
lastLeftGroupsOrderIdx--;
}
}
// Convert password characters into a string and return the result.
return new string(password);
}
}
/// <summary>
/// Illustrates the use of the RandomPassword class.
/// </summary>
public class RandomPasswordTest
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
// Print 100 randomly generated passwords (8-to-10 char long).
for (int i=0; i<100; i++)
Console.WriteLine(RandomPassword.Generate(8, 10));
}
}
//
// END OF FILE
///////////////////////////////////////////////////////////////////////////////
Ich weiß, dass dies ist ein alter Thread, aber ich habe, was eine ziemlich einfache Lösung für jemanden verwenden könnte. Einfach zu implementieren, einfach zu verstehen und einfach zu validieren.
Betrachten Sie die folgende Anforderung:
Ich brauche ein zufälliges Passwort generiert werden, die mindestens zwei Kleinbuchstaben hat, 2 Großbuchstaben und 2 Zahlen. Das Passwort muss auch mindestens 8 Zeichen lang sein.
Der folgende reguläre Ausdruck kann diesen Fall bestätigen:
^(?=\b\w*[a-z].*[a-z]\w*\b)(?=\b\w*[A-Z].*[A-Z]\w*\b)(?=\b\w*[0-9].*[0-9]\w*\b)[a-zA-Z0-9]{8,}$
Es ist nicht in den Anwendungsbereich dieser Frage - aber die regex basiert auf Look-Ahead / Lookbehind und Lookarounds .
Der folgende Code wird einen zufälligen Zeichensatz erstellen, die diese Anforderung entsprechen:
public static string GeneratePassword(int lowercase, int uppercase, int numerics) {
string lowers = "abcdefghijklmnopqrstuvwxyz";
string uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string number = "0123456789";
Random random = new Random();
string generated = "!";
for (int i = 1; i <= lowercase; i++)
generated = generated.Insert(
random.Next(generated.Length),
lowers[random.Next(lowers.Length - 1)].ToString()
);
for (int i = 1; i <= uppercase; i++)
generated = generated.Insert(
random.Next(generated.Length),
uppers[random.Next(uppers.Length - 1)].ToString()
);
for (int i = 1; i <= numerics; i++)
generated = generated.Insert(
random.Next(generated.Length),
number[random.Next(number.Length - 1)].ToString()
);
return generated.Replace("!", string.Empty);
}
die oben genannten Anforderungen gerecht zu werden, rufen Sie einfach den folgenden:
String randomPassword = GeneratePassword(3, 3, 3);
Der Code beginnt mit einem ungültigen Zeichen ("!") - so dass die Zeichenfolge, die eine Länge aufweist, in die neuen Zeichen injiziert werden können
Es dann in einer Schleife von 1 bis zur Anzahl der Kleinbuchstaben erforderlich, und bei jeder Iteration, schnappt sich ein zufälliges Element aus der Liste Klein und spritzt es an einer beliebigen Stelle in der Zeichenkette.
Es wiederholt sich dann die Schleife für Großbuchstaben und für Numerik.
Das gibt Ihnen zurück Strings der Länge = lowercase + uppercase + numerics in die Klein- und Großbuchstaben und Ziffern der Zählung Sie in zufälliger Reihenfolge platziert wurden möchten.
Für diese Art von Passwort, neige ich dazu, ein System zu verwenden, die leichter zu generieren „verwendet“ Passwörter wahrscheinlich ist. Kurz gesagt, häufig aus pronouncable Fragmente und ein paar Zahlen hergestellt und ohne Zwischenzeichen Mehrdeutigkeit (ist, dass eine 0 oder eine O? A 1 oder ein I?). So etwas wie
string[] words = { 'bur', 'ler', 'meh', 'ree' };
string word = "";
Random rnd = new Random();
for (i = 0; i < 3; i++)
word += words[rnd.Next(words.length)]
int numbCount = rnd.Next(4);
for (i = 0; i < numbCount; i++)
word += (2 + rnd.Next(7)).ToString();
return word;
(rechts in den Browser eingegeben, so nur als Richtlinien verwendet werden. Außerdem können mehr Wörter hinzufügen).
Ich habe diese Klasse dass verwendet RNGCryptoServiceProvider und es ist flexibel. Beispiel:
var generator = new PasswordGenerator(minimumLengthPassword: 8,
maximumLengthPassword: 15,
minimumUpperCaseChars: 2,
minimumNumericChars: 3,
minimumSpecialChars: 2);
string password = generator.Generate();
Ich mag es nicht, die Passwörter, die Membership.GeneratePassword () erzeugt, wie sie zu hässlich sind und haben zu viele Sonderzeichen.
Dieser Code erzeugt ein 10-stellige nicht allzu hässlich Passwort.
string password = Guid.NewGuid().ToString("N").ToLower()
.Replace("1", "").Replace("o", "").Replace("0","")
.Substring(0,10);
Natürlich könnte ich eine Regex verwenden, um alle ersetzt zu tun, aber das ist besser lesbar und wartbar IMO.
Ich habe immer sehr zufrieden mit dem Passwort-Generator eingebaut, um KeePass gewesen. Da KeePass ein .Net Programm und Open Source ist, habe ich beschlossen, um den Code ein wenig zu graben. Ich landete nur referncing KeePass.exe auf, die Kopie in der Standardanwendung zur Verfügung gestellt installieren, als Referenz in meinem Projekt und den Code zu schreiben. Sie können sehen, wie flexibel es dank KeePass ist. Sie können Länge angeben, welche Zeichen enthalten / nicht enthalten, etc ...
using KeePassLib.Cryptography.PasswordGenerator;
using KeePassLib.Security;
public static string GeneratePassword(int passwordLength, bool lowerCase, bool upperCase, bool digits,
bool punctuation, bool brackets, bool specialAscii, bool excludeLookAlike)
{
var ps = new ProtectedString();
var profile = new PwProfile();
profile.CharSet = new PwCharSet();
profile.CharSet.Clear();
if (lowerCase)
profile.CharSet.AddCharSet('l');
if(upperCase)
profile.CharSet.AddCharSet('u');
if(digits)
profile.CharSet.AddCharSet('d');
if (punctuation)
profile.CharSet.AddCharSet('p');
if (brackets)
profile.CharSet.AddCharSet('b');
if (specialAscii)
profile.CharSet.AddCharSet('s');
profile.ExcludeLookAlike = excludeLookAlike;
profile.Length = (uint)passwordLength;
profile.NoRepeatingCharacters = true;
KeePassLib.Cryptography.PasswordGenerator.PwGenerator.Generate(out ps, profile, null, _pool);
return ps.ReadString();
}
Ich habe dieses Verfahren ähnlich den in den Mitgliedschaftsanbietern. Dies ist nützlich, wenn Sie nicht über die Web-Referenz in einigen Anwendungen hinzufügen wollen.
Es funktioniert großartig.
public static string GeneratePassword(int Length, int NonAlphaNumericChars)
{
string allowedChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789";
string allowedNonAlphaNum = "!@#$%^&*()_-+=[{]};:<>|./?";
Random rd = new Random();
if (NonAlphaNumericChars > Length || Length <= 0 || NonAlphaNumericChars < 0)
throw new ArgumentOutOfRangeException();
char[] pass = new char[Length];
int[] pos = new int[Length];
int i = 0, j = 0, temp = 0;
bool flag = false;
//Random the position values of the pos array for the string Pass
while (i < Length - 1)
{
j = 0;
flag = false;
temp = rd.Next(0, Length);
for (j = 0; j < Length; j++)
if (temp == pos[j])
{
flag = true;
j = Length;
}
if (!flag)
{
pos[i] = temp;
i++;
}
}
//Random the AlphaNumericChars
for (i = 0; i < Length - NonAlphaNumericChars; i++)
pass[i] = allowedChars[rd.Next(0, allowedChars.Length)];
//Random the NonAlphaNumericChars
for (i = Length - NonAlphaNumericChars; i < Length; i++)
pass[i] = allowedNonAlphaNum[rd.Next(0, allowedNonAlphaNum.Length)];
//Set the sorted array values by the pos array for the rigth posistion
char[] sorted = new char[Length];
for (i = 0; i < Length; i++)
sorted[i] = pass[pos[i]];
string Pass = new String(sorted);
return Pass;
}
Ich mag zu generieren Passwörter suchen, wie Software-Schlüssel zu generieren. Sie sollten aus einem Array von Zeichen wählen, die eine gute Praxis folgen. Nehmen Sie, was @ Radu094 beantwortet mit und ändern es gute Praxis zu folgen. Nicht jeden einzelnen Buchstaben im Zeichenfeld setzen. Einige Buchstaben sind schwerer zu sagen, oder das Telefon zu verstehen über.
Sie sollten auch eine Prüfsumme auf dem Passwort verwenden, die erstellt wurde, um sicherzustellen, dass es die von Ihnen erstellt wurde. Ein guter Weg, dies zu erreichen, ist die LUHN Algorithmus verwenden.
Hier ist, was ich schnell zusammen setzen.
public string GeneratePassword(int len)
{
string res = "";
Random rnd = new Random();
while (res.Length < len) res += (new Func<Random, string>((r) => {
char c = (char)((r.Next(123) * DateTime.Now.Millisecond % 123));
return (Char.IsLetterOrDigit(c)) ? c.ToString() : "";
}))(rnd);
return res;
}
public static string GeneratePassword(int passLength) {
var chars = "abcdefghijklmnopqrstuvwxyz@#$&ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
var random = new Random();
var result = new string(
Enumerable.Repeat(chars, passLength)
.Select(s => s[random.Next(s.Length)])
.ToArray());
return result;
}
Das ist kurz und es funktioniert gut für mich.
public static string GenerateRandomCode(int length)
{
Random rdm = new Random();
StringBuilder sb = new StringBuilder();
for(int i = 0; i < length; i++)
sb.Append(Convert.ToChar(rdm.Next(101,132)));
return sb.ToString();
}
Auf meiner Website verwende ich diese Methode:
//Symb array
private const string _SymbolsAll = "~`!@#$%^&*()_+=-\\|[{]}'\";:/?.>,<";
//Random symb
public string GetSymbol(int Length)
{
Random Rand = new Random(DateTime.Now.Millisecond);
StringBuilder result = new StringBuilder();
for (int i = 0; i < Length; i++)
result.Append(_SymbolsAll[Rand.Next(0, _SymbolsAll.Length)]);
return result.ToString();
}
Edit String _SymbolsAll für Ihre Array-Liste.
einige zusätzliche Code an die akzeptierte Antwort hinzugefügt. Es verbessert auf Antworten nur zufällig mit und ermöglicht einige Kennwortoptionen. Ich mochte auch einige der Optionen aus der Antwort KeePass aber wollte nicht die ausführbare Datei in meiner Lösung einzubeziehen.
private string RandomPassword(int length, bool includeCharacters, bool includeNumbers, bool includeUppercase, bool includeNonAlphaNumericCharacters, bool includeLookAlikes)
{
if (length < 8 || length > 128) throw new ArgumentOutOfRangeException("length");
if (!includeCharacters && !includeNumbers && !includeNonAlphaNumericCharacters) throw new ArgumentException("RandomPassword-Key arguments all false, no values would be returned");
string pw = "";
do
{
pw += System.Web.Security.Membership.GeneratePassword(128, 25);
pw = RemoveCharacters(pw, includeCharacters, includeNumbers, includeUppercase, includeNonAlphaNumericCharacters, includeLookAlikes);
} while (pw.Length < length);
return pw.Substring(0, length);
}
private string RemoveCharacters(string passwordString, bool includeCharacters, bool includeNumbers, bool includeUppercase, bool includeNonAlphaNumericCharacters, bool includeLookAlikes)
{
if (!includeCharacters)
{
var remove = new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };
foreach (string r in remove)
{
passwordString = passwordString.Replace(r, string.Empty);
passwordString = passwordString.Replace(r.ToUpper(), string.Empty);
}
}
if (!includeNumbers)
{
var remove = new string[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
foreach (string r in remove)
passwordString = passwordString.Replace(r, string.Empty);
}
if (!includeUppercase)
passwordString = passwordString.ToLower();
if (!includeNonAlphaNumericCharacters)
{
var remove = new string[] { "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "+", "=", "{", "}", "[", "]", "|", "\\", ":", ";", "<", ">", "/", "?", "." };
foreach (string r in remove)
passwordString = passwordString.Replace(r, string.Empty);
}
if (!includeLookAlikes)
{
var remove = new string[] { "(", ")", "0", "O", "o", "1", "i", "I", "l", "|", "!", ":", ";" };
foreach (string r in remove)
passwordString = passwordString.Replace(r, string.Empty);
}
return passwordString;
}
Dies war die erste Verbindung, wenn ich zur Erzeugung von Zufallskennwörter gesucht und die folgende ist für die aktuelle Frage außerhalb des Bereichs, sondern könnte wichtig sein, zu betrachten.
- Basierend auf der Annahme, dass
System.Web.Security.Membership.GeneratePasswordmit einem Minimum von 20% der Charaktere sind nicht-alphanumerische kryptografisch sicher ist. - Nicht sicher Zeichen, wenn das Entfernen und Strings anhängen in diesem Fall gute Praxis betrachtet und bietet genügend Entropie.
- Vielleicht möchten in irgendeiner Weise mit Secure für sichere Passwortspeicherung im Speicher.
ValidChars kann jedes Konstrukt sein, aber ich beschloss, auf ASCII-Code wählen basierend Bereiche Entfernungssteuerung Zeichen. In diesem Beispiel ist es eine 12-Zeichenfolge.
string validChars = String.Join("", Enumerable.Range(33, (126 - 33)).Where(i => !(new int[] { 34, 38, 39, 44, 60, 62, 96 }).Contains(i)).Select(i => { return (char)i; }));
string.Join("", Enumerable.Range(1, 12).Select(i => { return validChars[(new Random(Guid.NewGuid().GetHashCode())).Next(0, validChars.Length - 1)]; }))
Generate random password of specified length with
- Special characters
- Number
- Lowecase
- Uppercase
public static string CreatePassword(int length = 12)
{
const string lower = "abcdefghijklmnopqrstuvwxyz";
const string upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string number = "1234567890";
const string special = "!@#$%^&*";
var middle = length / 2;
StringBuilder res = new StringBuilder();
Random rnd = new Random();
while (0 < length--)
{
if (middle == length)
{
res.Append(number[rnd.Next(number.Length)]);
}
else if (middle - 1 == length)
{
res.Append(special[rnd.Next(special.Length)]);
}
else
{
if (length % 2 == 0)
{
res.Append(lower[rnd.Next(lower.Length)]);
}
else
{
res.Append(upper[rnd.Next(upper.Length)]);
}
}
}
return res.ToString();
}
Ich werde eine andere schlecht beraten Antwort auf den Topf hinzufügen.
Ich habe einen Anwendungsfall, wo ich zufällige Passwörter für Maschine-Maschine-Kommunikation benötigen, so habe ich keine Voraussetzung für die menschliche Lesbarkeit. Ich habe auch keinen Zugang zu Membership.GeneratePassword in meinem Projekt, und will nicht die Abhängigkeit hinzuzufügen.
Ich bin ziemlich sicher, Membership.GeneratePassword ist dies etwas ähnliches zu tun, aber hier können Sie stimmen die Pools von Zeichen aus zu ziehen.
public static class PasswordGenerator
{
private readonly static Random _rand = new Random();
public static string Generate(int length = 24)
{
const string lower = "abcdefghijklmnopqrstuvwxyz";
const string upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string number = "1234567890";
const string special = "!@#$%^&*_-=+";
// Get cryptographically random sequence of bytes
var bytes = new byte[length];
new RNGCryptoServiceProvider().GetBytes(bytes);
// Build up a string using random bytes and character classes
var res = new StringBuilder();
foreach(byte b in bytes)
{
// Randomly select a character class for each byte
switch (_rand.Next(4))
{
// In each case use mod to project byte b to the correct range
case 0:
res.Append(lower[b % lower.Count()]);
break;
case 1:
res.Append(upper[b % upper.Count()]);
break;
case 2:
res.Append(number[b % number.Count()]);
break;
case 3:
res.Append(special[b % special.Count()]);
break;
}
}
return res.ToString();
}
}
Und ein Beispiel einer Ausgabe:
PasswordGenerator.Generate(12)
"pzY=64@-ChS$"
"BG0OsyLbYnI_"
"l9#5^2&adj_i"
"#++Ws9d$%O%X"
"IWhdIN-#&O^s"
Um Beschwerden über die Verwendung von Random preempt: Die primäre Quelle der Zufälligkeit noch der Krypto-RNG ist. Auch wenn Sie deterministisch die Sequenz aus Random kommenden preordain können (sagen, es ist nur 1 produziert) Sie würden immer noch nicht das nächste Zeichen wissen, dass abgeholt würde (obwohl das würde die Palette der Möglichkeiten begrenzen).
Eine einfache Erweiterung wäre Gewichtung der verschiedenen Zeichensätze hinzufügen, die als upping den maximalen Wert könnten so einfach sein und das Hinzufügen von Durchfall Fällen Gewicht zu erhöhen.
switch (_rand.Next(6))
{
// Prefer letters 2:1
case 0:
case 1:
res.Append(lower[b % lower.Count()]);
break;
case 2:
case 3:
res.Append(upper[b % upper.Count()]);
break;
case 4:
res.Append(number[b % number.Count()]);
break;
case 5:
res.Append(special[b % special.Count()]);
break;
}
Für einen humanistischen zufälligen Passwort-Generator, sobald ich ein promptes System implementiert die EFF Würfel-Wortliste .
Setzen Sie einen Timer: timer1, 2 Tasten: button1, button2, 1 textBox: textBox1 und ein comboBox: comboBox1. Stellen Sie sicher, dass Sie erklären:
int count = 0;
Source Code:
private void button1_Click(object sender, EventArgs e)
{
// This clears the textBox, resets the count, and starts the timer
count = 0;
textBox1.Clear();
timer1.Start();
}
private void timer1_Tick(object sender, EventArgs e)
{
// This generates the password, and types it in the textBox
count += 1;
string possible = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
string psw = "";
Random rnd = new Random { };
psw += possible[rnd.Next(possible.Length)];
textBox1.Text += psw;
if (count == (comboBox1.SelectedIndex + 1))
{
timer1.Stop();
}
}
private void Form1_Load(object sender, EventArgs e)
{
// This adds password lengths to the comboBox to choose from.
comboBox1.Items.Add("1");
comboBox1.Items.Add("2");
comboBox1.Items.Add("3");
comboBox1.Items.Add("4");
comboBox1.Items.Add("5");
comboBox1.Items.Add("6");
comboBox1.Items.Add("7");
comboBox1.Items.Add("8");
comboBox1.Items.Add("9");
comboBox1.Items.Add("10");
comboBox1.Items.Add("11");
comboBox1.Items.Add("12");
}
private void button2_click(object sender, EventArgs e)
{
// This encrypts the password
tochar = textBox1.Text;
textBox1.Clear();
char[] carray = tochar.ToCharArray();
for (int i = 0; i < carray.Length; i++)
{
int num = Convert.ToInt32(carray[i]) + 10;
string cvrt = Convert.ToChar(num).ToString();
textBox1.Text += cvrt;
}
}
public string Sifre_Uret(int boy, int noalfa)
{
// 01.03.2016
// Genel amaçlı şifre üretme fonksiyonu
//Fonskiyon 128 den büyük olmasına izin vermiyor.
if (boy > 128 ) { boy = 128; }
if (noalfa > 128) { noalfa = 128; }
if (noalfa > boy) { noalfa = boy; }
string passch = System.Web.Security.Membership.GeneratePassword(boy, noalfa);
//URL encoding ve Url Pass + json sorunu yaratabilecekler pass ediliyor.
//Microsoft Garanti etmiyor. Alfa Sayısallar Olabiliyorimiş . !@#$%^&*()_-+=[{]};:<>|./?.
//https://msdn.microsoft.com/tr-tr/library/system.web.security.membership.generatepassword(v=vs.110).aspx
//URL ve Json ajax lar için filtreleme
passch = passch.Replace(":", "z");
passch = passch.Replace(";", "W");
passch = passch.Replace("'", "t");
passch = passch.Replace("\"", "r");
passch = passch.Replace("/", "+");
passch = passch.Replace("\\", "e");
passch = passch.Replace("?", "9");
passch = passch.Replace("&", "8");
passch = passch.Replace("#", "D");
passch = passch.Replace("%", "u");
passch = passch.Replace("=", "4");
passch = passch.Replace("~", "1");
passch = passch.Replace("[", "2");
passch = passch.Replace("]", "3");
passch = passch.Replace("{", "g");
passch = passch.Replace("}", "J");
//passch = passch.Replace("(", "6");
//passch = passch.Replace(")", "0");
//passch = passch.Replace("|", "p");
//passch = passch.Replace("@", "4");
//passch = passch.Replace("!", "u");
//passch = passch.Replace("$", "Z");
//passch = passch.Replace("*", "5");
//passch = passch.Replace("_", "a");
passch = passch.Replace(",", "V");
passch = passch.Replace(".", "N");
passch = passch.Replace("+", "w");
passch = passch.Replace("-", "7");
return passch;
}
