Generando contraseñas aleatorias

Cuando un usuario en nuestro sitio pierde su contraseña y se dirige a la página de Contraseña Perdida, necesitamos darle una nueva contraseña temporal. Realmente no me importa cuán aleatorio sea, o si coincide con todas las reglas de contraseña segura “necesarias”, todo lo que quiero hacer es darles una contraseña que puedan cambiar más adelante.

La aplicación es una aplicación web escrita en C #. así que estaba pensando en ser malo e ir por la ruta fácil de usar parte de un Guid. es decir

Guid.NewGuid().ToString("d").Substring(1,8) 

Sugerencias? pensamientos?

Siempre hay System.Web.Security.Membership.GeneratePassword(int length, int numberOfNonAlphanumericCharacters ) .

 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(); } 

Esto tiene un buen beneficio de poder elegir de una lista de caracteres disponibles para la contraseña generada (por ejemplo, solo dígitos, solo mayúsculas o minúsculas, etc.)

Los principales objectives de mi código son:

  1. La distribución de las cadenas es casi uniforme (no se preocupan por desviaciones menores, siempre que sean pequeñas)
  2. Genera más de unos mil millones de cadenas para cada conjunto de argumentos. Generar una cadena de 8 caracteres (~ 47 bits de entropía) no tiene sentido si su PRNG solo genera valores diferentes de 2 billones (31 bits de entropía).
  3. Es seguro, ya que espero que las personas lo usen para contraseñas u otros tokens de seguridad.

La primera propiedad se logra tomando un módulo de valor de 64 bit el tamaño del alfabeto. Para los pequeños alfabetos (como los 62 caracteres de la pregunta) esto lleva a un sesgo insignificante. La segunda y tercera propiedad se logran utilizando RNGCryptoServiceProvider lugar de 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 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); } 

(Esta es una copia de mi respuesta a ¿Cómo puedo generar cadenas alfanuméricas aleatorias de 8 caracteres en C #? )

Así es como genero tokens aleatorios:

 public string GenerateToken(int length) { RNGCryptoServiceProvider cryptRNG = new RNGCryptoServiceProvider(); byte[] tokenBuffer = new byte[length]; cryptRNG.GetBytes(tokenBuffer); return Convert.ToBase64String(tokenBuffer); } 

Se ha observado que a medida que esto devuelve una cadena de base 64, la longitud de salida siempre es un múltiplo de 4, con el espacio adicional usando = como un carácter de relleno. El parámetro de length especifica la longitud del búfer de bytes, no la cadena de salida (y, por lo tanto, tal vez no sea el mejor nombre para ese parámetro, ahora lo pienso). Esto controla cuántos bytes de entropía tendrá la contraseña. Sin embargo, debido a que base-64 usa un bloque de 4 caracteres para codificar cada 3 bytes de entrada, si solicita una longitud que no sea un múltiplo de 3, habrá un “espacio” adicional, y usará = para completar el extra.

Si no le gusta usar cadenas base-64 por algún motivo, puede reemplazar la llamada Convert.ToBase64String() con una conversión a cadena normal o con cualquiera de los métodos de Encoding ; p.ej. Encoding.UTF8.GetString(tokenBuffer) : solo asegúrate de elegir un conjunto de caracteres que pueda representar la gama completa de valores que salen del RNG, y que genere caracteres que sean compatibles con el lugar donde estés enviando o almacenando esto. El uso de Unicode, por ejemplo, tiende a dar muchos caracteres chinos. El uso de base-64 garantiza un conjunto de caracteres ampliamente compatible, y las características de una cadena de este tipo no deberían ser menos seguras siempre que utilice un algoritmo de hash decente.

Esto es mucho más grande, pero creo que se ve un poco más completo: 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; ///  /// 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). ///  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= "*$-+?_&=!%{}/"; ///  /// Generates a random password. ///  ///  /// Randomly generated password. ///  ///  /// 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. ///  public static string Generate() { return Generate(DEFAULT_MIN_PASSWORD_LENGTH, DEFAULT_MAX_PASSWORD_LENGTH); } ///  /// Generates a random password of the exact length. ///  ///  /// Exact password length. ///  ///  /// Randomly generated password. ///  public static string Generate(int length) { return Generate(length, length); } ///  /// Generates a random password. ///  ///  /// Minimum password length. ///  ///  /// Maximum password length. ///  ///  /// Randomly generated password. ///  ///  /// The length of the generated password will be determined at /// random and it will fall with the range determined by the /// function parameters. ///  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 /// Illustrates the use of the RandomPassword class. ///  public class RandomPasswordTest { ///  /// The main entry point for the application. ///  [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 /////////////////////////////////////////////////////////////////////////////// 

Sé que este es un hilo viejo, pero tengo lo que podría ser una solución bastante simple para que alguien la use. Fácil de implementar, fácil de entender y fácil de validar.

Considere el siguiente requisito:

Necesito que se genere una contraseña aleatoria que tenga al menos 2 letras minúsculas, 2 mayúsculas y 2 números. La contraseña también debe tener un mínimo de 8 caracteres de longitud.

La siguiente expresión regular puede validar este caso:

 ^(?=\b\w*[az].*[az]\w*\b)(?=\b\w*[AZ].*[AZ]\w*\b)(?=\b\w*[0-9].*[0-9]\w*\b)[a-zA-Z0-9]{8,}$ 

Está fuera del scope de esta pregunta, pero la expresión regular se basa en lookahead / lookbehind y lookaround .

El siguiente código creará un conjunto aleatorio de caracteres que coincidan con este requisito:

 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); } 

Para cumplir con el requisito anterior, simplemente llame a lo siguiente:

 String randomPassword = GeneratePassword(3, 3, 3); 

El código comienza con un carácter no válido ( "!" ), Por lo que la cadena tiene una longitud en la que se pueden inyectar nuevos caracteres.

Luego pasa del 1 al # de caracteres en minúscula requeridos, y en cada iteración, toma un elemento aleatorio de la lista en minúsculas y lo inyecta en una ubicación aleatoria en la cadena.

Luego repite el ciclo para letras mayúsculas y para números.

Esto le devuelve cadenas de longitud = lowercase + uppercase + numerics en los que se han colocado los caracteres en minúscula, mayúscula y numérica del conteo que desea en un orden aleatorio.

Para este tipo de contraseña, tiendo a usar un sistema que probablemente genere contraseñas más fáciles de usar. Corto, a menudo formado por fragmentos pronouncables y algunos números, y sin ambigüedad entre caracteres (¿es eso un 0 o un O? A 1 o un I?). Algo como

 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; 

(Escrito a la derecha en el navegador, por lo tanto, use solo como pautas. Además, agregue más palabras).

No me gustan las contraseñas que crea Membership.GeneratePassword (), ya que son demasiado feas y tienen demasiados caracteres especiales.

Este código genera una contraseña de 10 dígitos no demasiado fea.

 string password = Guid.NewGuid().ToString("N").ToLower() .Replace("1", "").Replace("o", "").Replace("0","") .Substring(0,10); 

Claro, podría usar un Regex para hacer todas las sustituciones, pero esta es la OMI más legible y mantenible.

Creé esta clase que usa RNGCryptoServiceProvider y es flexible. Ejemplo:

 var generator = new PasswordGenerator(minimumLengthPassword: 8, maximumLengthPassword: 15, minimumUpperCaseChars: 2, minimumNumericChars: 3, minimumSpecialChars: 2); string password = generator.Generate(); 

Creé este método similar al disponible en el proveedor de membresía. Esto es útil si no desea agregar la referencia web en algunas aplicaciones.

Funciona muy bien.

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

Siempre he estado muy contento con el generador de contraseñas integrado en KeePass. Como KeePass es un progtwig .Net y de código abierto, decidí investigar un poco sobre el código. Acabo de referirme a KeePass.exe, la copia proporcionada en la instalación de la aplicación estándar, como referencia en mi proyecto y escribiendo el código a continuación. Puedes ver lo flexible que es gracias a KeePass. Puede especificar la longitud, qué caracteres incluir / no incluir, 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(); } 

Me gusta ver la generación de contraseñas, al igual que generar claves de software. Debe elegir entre una serie de personajes que siguen una buena práctica. Tome lo que respondió @ Radu094 y modifíquelo para seguir las buenas prácticas. No coloque todas las letras en la matriz de caracteres. Algunas letras son más difíciles de decir o entender por teléfono.

También debería considerar usar una sum de comprobación en la contraseña que se generó para asegurarse de que la generó. Una buena forma de lograr esto es usar el algoritmo LUHN .

Aquí es lo que preparo rápidamente.

  public string GeneratePassword(int len) { string res = ""; Random rnd = new Random(); while (res.Length < len) res += (new Func((r) => { char c = (char)((r.Next(123) * DateTime.Now.Millisecond % 123)); return (Char.IsLetterOrDigit(c)) ? c.ToString() : ""; }))(rnd); return res; } 
  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(); } 

Esto es corto y funciona bien para mí.

 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(); } 

En mi sitio web utilizo este método:

  //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(); } 

Editar cadena _SymbolsAll para su lista de matriz.

Se agregó un código suplementario a la respuesta aceptada. Mejora las respuestas simplemente usando Random y permite algunas opciones de contraseña. También me gustaron algunas de las opciones de la respuesta de KeePass, pero no quería incluir el ejecutable en mi solución.

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

Este fue el primer enlace cuando busqué generar contraseñas aleatorias y el siguiente está fuera del scope de la pregunta actual, pero podría ser importante considerarlo.

  • Basado en la suposición de que System.Web.Security.Membership.GeneratePassword es criptográficamente seguro con un mínimo de 20% de los caracteres no alfanuméricos.
  • No estoy seguro de si la eliminación de caracteres y la adición de cadenas se considera una buena práctica en este caso y proporciona suficiente entropía.
  • Puede que desee considerar la implementación de alguna manera con SecureString para el almacenamiento seguro de contraseñas en la memoria.

validChars puede ser cualquier construcción, pero decidí seleccionar en función de rangos de código ascii quitando los caracteres de control. En este ejemplo, es una cadena de 12 caracteres.

 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)]; })) 
 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; } 

Insert a Timer: timer1, 2 buttons: button1, button2, 1 textBox: textBox1, and a comboBox: comboBox1. Make sure you declare:

 int count = 0; 

Código fuente:

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