توليد كلمات السر العشوائية
https://stackoverflow.com/questions/54991
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russianسؤال
عندما يقوم مستخدم على موقعنا يفقد كلمة السر و يتجه إلى الصفحة فقدت كلمة السر يجب أن نعطي له كلمة مرور مؤقتة جديدة.أنا لا أمانع حقا كيف العشوائية هذه ، أو إذا كان يتطابق مع كل "حاجة" مرور قوية القواعد ، كل ما أريده هو أن تعطيهم كلمة المرور التي يمكن أن تغير في وقت لاحق.
التطبيق هو تطبيق ويب مكتوب في C#.لذا كنت أفكر كنت تقصد الذهاب الطريق السهل استخدام جزء من Guid.أي
Guid.NewGuid().ToString("d").Substring(1,8)
Suggesstions?الأفكار ؟
نصائح أخرى
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();
}
وهذا له فائدة جيدة من القدرة على الاختيار من بين قائمة من الشخصيات المتاحة من أجل إنشاء كلمة المرور (على سبيل المثالأرقام فقط, فقط أحرف كبيرة أو أحرف صغيرة.... الخ)
الأهداف الرئيسية من التعليمات البرمجية:
- توزيع السلاسل موحد تقريبا (لا تهتم الانحرافات الطفيفة ، طالما أنهم صغيرة)
- فإنه إخراج أكثر من بضعة مليارات من سلاسل لكل تعيين وسيطة.توليد 8 سلسلة أحرف (~47 بت من الكون) لا معنى له إذا كانت اللوائح فقط يولد 2 مليار دولار (31 أجزاء من الكون) قيم مختلفة.
- انها آمنة, منذ أن كنت تتوقع من الناس أن استخدام هذا للحصول على كلمات المرور أو غيرها من الرموز الأمنية.
الخاصية الأولى يتحقق من خلال أخذ 64 بت قيمة نمطية الأبجدية الحجم.على الحروف الهجائية الصغيرة مثل (62 شخصيات من السؤال) وهذا يؤدي إلى تذكر التحيز.الثانية والثالثة الملكية يتم تحقيقها باستخدام RNGCryptoServiceProvider بدلا من 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);
}
(هذه نسخة من جوابي كيف يمكن توليد عشوائية 8 حرف أبجدية السلاسل في C# ؟ )
هنا كيف توليد عشوائية الرموز:
public string GenerateToken(int length)
{
RNGCryptoServiceProvider cryptRNG = new RNGCryptoServiceProvider();
byte[] tokenBuffer = new byte[length];
cryptRNG.GetBytes(tokenBuffer);
return Convert.ToBase64String(tokenBuffer);
}
لقد لوحظ أن هذا يعود قاعدة-64 سلسلة الإخراج طول دائما متعددة من 4 ، مع مساحة إضافية باستخدام = كما الحشو حرف.على length تعين المعلمة طول المخزن المؤقت بايت وليس سلسلة الإنتاج (وبالتالي ربما ليس أفضل اسم لهذا المعلمة, الآن أفكر في ذلك).هذه الضوابط كم بايت الكون سيكون لها كلمة السر.ومع ذلك, لأن القاعدة-64 يستخدم 4-حرف كتلة لترميز كل 3 بايت من المدخلات ، إذا سألت عن طول هذا ليس متعددة من 3 ، وسوف يكون هناك المزيد من "الفضاء" و سوف تستخدم = لملء إضافية.
إذا كنت لا ترغب في استخدام قاعدة-64 سلاسل لأي سبب من الأسباب ، يمكنك استبدال Convert.ToBase64String() الاتصال مع أي تحويل العادية السلسلة ، أو مع أي من Encoding الأساليب ؛ على سبيل المثال. Encoding.UTF8.GetString(tokenBuffer) - فقط تأكد من اختيار مجموعة الأحرف التي يمكن أن تمثل مجموعة كاملة من القيم الخروج من RNG ، التي تنتج الشخصيات التي تتوافق مع أينما كنت إرسال أو تخزين هذا.باستخدام يونيكود ، على سبيل المثال ، يميل إلى إعطاء الكثير من الحروف الصينية.باستخدام قاعدة-64 ضمانات على نطاق واسع متوافق مع مجموعة من الشخصيات ، و خصائص هذه السلسلة يجب أن لا تجعل أي أقل أمنا طالما كنت تستخدم لائق خوارزمية التجزئة.
هذا هو أكبر كثيرا ، ولكن أعتقد أنه يبدو قليلا أكثر شمولا: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
///////////////////////////////////////////////////////////////////////////////
أنا أعلم أن هذا الموضوع القديم لكن لدي ما يمكن أن تكون بسيطة إلى حد ما الحل شخص استخدام.سهلة التنفيذ ، سهلة الفهم وسهلة التحقق من صحة.
تنظر الاتية:
أنا بحاجة إلى كلمة مرور عشوائية إلى أن تتولد الذي لديه على الأقل 2 أقل حدة الحروف 2 رسائل الحالة العلوي و 2 الأرقام.كلمة المرور يجب أيضا أن يكون الحد الأدنى من 8 أحرف في الطول.
التعبير العادي التالي يمكن التحقق من صحة هذه الحالة:
^(?=\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,}$
انها خارج نطاق هذا السؤال - ولكن regex على أساس lookahead/lookbehind و lookaround.
التعليمة البرمجية التالية إنشاء مجموعة عشوائية من الأحرف التي تطابق هذا الشرط:
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);
}
لتلبية الاحتياجات المذكورة أعلاه ، ببساطة الاتصال التالية:
String randomPassword = GeneratePassword(3, 3, 3);
يبدأ رمز مع حرف غير صالح ("!") - حتى أن سلسلة طولها إلى شخصيات جديدة يمكن حقنها.
ثم الحلقات من 1 إلى # من أحرف صغيرة المطلوبة ، وعلى كل التكرار ، سائغة عنصر عشوائي من صغيرة قائمة ، يقحم في موقع عشوائي في السلسلة.
ثم يكرر حلقة الأحرف الكبيرة و العددية.
هذا يتيح لك العودة سلاسل من طول = lowercase + uppercase + numerics الذي صغيرة ، أحرف كبيرة أحرف رقمية من العد تريد تم وضعها في ترتيب عشوائي.
هذا النوع من المرور ، أنا أميل إلى استخدام النظام الذي من المحتمل أن تولد بسهولة أكثر "استخدام" كلمات السر.قصيرة ، وغالبا ما تتكون من pronouncable شظايا أعداد قليلة ، و لا intercharacter الغموض (هو 0 أو O ؟ 1 أو أنا؟).شيء مثل
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;
(كتبته الحق في المتصفح, لذلك استخدام المبادئ التوجيهية.أيضا إضافة المزيد من الكلمات).
أنا خلقت هذه الفئة يستخدم RNGCryptoServiceProvider وهي مرنة.على سبيل المثال:
var generator = new PasswordGenerator(minimumLengthPassword: 8,
maximumLengthPassword: 15,
minimumUpperCaseChars: 2,
minimumNumericChars: 3,
minimumSpecialChars: 2);
string password = generator.Generate();
أنا لا أحب كلمات المرور التي الأعضاء.GeneratePassword() يخلق ، كما أنهم قبيحة جدا ولها الكثير من الأحرف الخاصة.
هذه التعليمة البرمجية بإنشاء 10 أرقام ليست قبيحة كلمة المرور.
string password = Guid.NewGuid().ToString("N").ToLower()
.Replace("1", "").Replace("o", "").Replace("0","")
.Substring(0,10);
وانا متأكد ان استخدام التعابير المنطقية أن تفعل كل محل ولكن هذا هو أكثر قابلية للقراءة و الصيانة المنظمة البحرية الدولية.
لطالما كنت سعيدا جدا مع مولد كلمة السر المدمج في KeePass.منذ KeePass هو .صافي برنامج مفتوح المصدر, قررت حفر حول رمز قليلا.انتهى بي الأمر فقط referncing KeePass.exe, نسخة المنصوص عليها في معيار تثبيت التطبيق ، كمرجع في مشروع كتابة التعليمات البرمجية أدناه.يمكنك أن ترى كيف مرنة وبفضل KeePass.يمكنك تحديد طول الأحرف التي تشمل/لا تشمل ، الخ...
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();
}
أنا خلقت هذه الطريقة مشابهة المتاحة في عضوية مقدم.هذا هو مفيدة إذا كنت لا ترغب في إضافة مرجع ويب في بعض التطبيقات.
يعمل كبيرة.
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;
}
أنا أحب أن ننظر إلى توليد كلمات السر مثل توليد مفاتيح البرامج.يجب عليك أن تختار من بين مجموعة من الشخصيات التي تتبع ممارسة جيدة.خذ ما @Radu094 أجاب مع تعديله إلى اتباع الممارسات الجيدة.لا تضع كل حرف في حرف الصفيف.بعض الرسائل يصعب القول أو فهم عبر الهاتف.
يجب عليك أن تنظر أيضا في استخدام اختباري على كلمة المرور التي تم إنشاؤها للتأكد من أنه تم إنشاؤها بواسطة لك.وسيلة جيدة لتحقيق ذلك هو استخدام LUHN الخوارزمية.
هنا هو ما كنت وضعت معا بسرعة.
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;
}
هذا هو قصير و يعمل كبيرة بالنسبة لي.
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();
}
على موقع الويب الخاص بي يمكنني استخدام هذا الأسلوب:
//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();
}
تحرير سلسلة _SymbolsAll بالنسبة الصفيف الخاص بك القائمة.
وأضاف بعض التكميلية رمز الإجابة المقبولة.فإنه يحسن على إجابات فقط باستخدام عشوائي و يسمح لبعض الخيارات كلمة المرور.أنا أيضا أحب بعض الخيارات من KeePass الإجابة ولكن لم ترغب في تضمين الملف القابل للتنفيذ في الحل.
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;
}
هذا الرابط الأول عندما بحثت عن توليد كلمات السر العشوائية التالية خارج نطاق السؤال الحالي ولكن قد يكون من المهم النظر.
- استنادا إلى افتراض أن
System.Web.Security.Membership.GeneratePasswordهو آمن مشفر مع حد أدنى من 20% من الأحرف غير الأبجدية الرقمية. - لست متأكدا إذا كان إزالة الأحرف إلحاق سلاسل يعتبر من الممارسات الجيدة في هذه الحالة و يوفر ما يكفي من الكون.
- قد ترغب في النظر في تنفيذ في بعض الطريق مع SecureString للحصول على كلمة مرور آمنة التخزين في الذاكرة.
validChars يمكن أن يكون أي بناء ، لكنني قررت أن حدد على أساس رمز ascii يتراوح إزالة السيطرة على حرف.في هذا المثال هو 12 سلسلة أحرف.
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();
}
سأضيف آخر غير حكيمة الإجابة إلى وعاء.
لدي حالة الاستخدام حيث أحتاج كلمات السر العشوائية على آلة-آلة الاتصالات ، لذلك ليس لدي أي شرط الإنسان القراءة.أنا أيضا لم يكن لديك الوصول إلى Membership.GeneratePassword في مشروعي و لا ترغب في إضافة التبعية.
أنا متأكد Membership.GeneratePassword القيام بشيء مشابه لهذا ولكن هنا يمكنك ضبط برك من الشخصيات للاستفادة منها.
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();
}
}
وبعض إخراج المثال:
PasswordGenerator.Generate(12)
"pzY=64@-ChS$"
"BG0OsyLbYnI_"
"l9#5^2&adj_i"
"#++Ws9d$%O%X"
"IWhdIN-#&O^s"
إلى استباق الشكاوى حول استخدام Random:المصدر الرئيسي العشوائية لا تزال التشفير RNG.حتى إذا كنت يمكن أن deterministically preordain تسلسل يخرج من Random (أقول أنها تنتج فقط 1) كنت لا تزال لا تعرف المقبل شار التي قد تكون التقطت (على الرغم من أن أن الحد من مجموعة من الاحتمالات).
واحدة بسيطة التمديد سيكون إضافة الترجيح إلى مختلف مجموعات الأحرف التي يمكن أن تكون بسيطة مثل رفع max قيمة وإضافة خريف-من خلال الحالات إلى زيادة الوزن.
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;
}
أكثر إنسانية عشوائية مولد كلمة السر لا تنفذ مرة واحدة موجه النظام باستخدام EFF الزهر-قائمة الكلمات.
إدراج الموقت:المؤقت1, 2 أزرار:button1 button2, 1 مربع نص:textBox1 و تحرير وسرد:comboBox1.تأكد من أن تعلن:
int count = 0;
المصدر مدونة:
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;
}
